OpenCSG-1.8.2/0000775000175000017500000000000015141675432012640 5ustar florianflorianOpenCSG-1.8.2/OpenCSG.dev0000664000175000017500000001606215141675417014606 0ustar florianflorian[Project] FileName=OpenCSG.dev Name=OpenCSG Ver=2 IsCpp=1 Type=0 Compiler=-D__GNUWIN32__ -W -Wall -DWIN32 -DNDEBUG -D_WINDOWS_@@_ CppCompiler=-D__GNUWIN32__ -W -Wall -DWIN32 -DNDEBUG -D_WINDOWS_@@_ Includes=include;glew/include;. Linker=-lopengl32_@@_-lglu32_@@_-lfreeglut_@@_ Libs=freeglut\lib UnitCount=39 Folders="Header Files","Source Files","Source Files/OpenCSG","Source Files/OpenCSGexample" ObjFiles= PrivateResource= ResourceIncludes= MakeIncludes= Icon= ExeOutput= ObjectOutput= OverrideOutput=0 OverrideOutputName=OpenCSG.exe HostApplication= CommandLine= IncludeVersionInfo=0 SupportXPThemes=0 CompilerSet=3 CompilerSettings=0000000100000000000000000 UseCustomMakefile=0 CustomMakefile= LogOutput= LogOutputEnabled=0 [Unit1] FileName=src\area.cpp Folder=Source Files/OpenCSG Compile=1 CompileCpp=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit2] FileName=src\area.h Folder=Source Files/OpenCSG Compile=1 CompileCpp=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit3] FileName=src\batch.cpp Folder=Source Files/OpenCSG Compile=1 CompileCpp=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit4] FileName=src\batch.h Folder=Source Files/OpenCSG Compile=1 CompileCpp=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit5] FileName=src\channelManager.cpp Folder=Source Files/OpenCSG Compile=1 CompileCpp=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit6] FileName=src\channelManager.h Folder=Source Files/OpenCSG Compile=1 CompileCpp=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit7] FileName=src\occlusionQuery.cpp Folder=Source Files/OpenCSG Compile=1 CompileCpp=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit8] FileName=src\occlusionQuery.h Folder=Source Files/OpenCSG Compile=1 CompileCpp=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit9] FileName=src\opencsgRender.cpp Folder=Source Files/OpenCSG Compile=1 CompileCpp=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit10] FileName=src\opencsgRender.h Folder=Source Files/OpenCSG Compile=1 CompileCpp=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit11] FileName=src\openglHelper.cpp Folder=Source Files/OpenCSG Compile=1 CompileCpp=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit12] FileName=src\openglHelper.h Folder=Source Files/OpenCSG Compile=1 CompileCpp=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit13] FileName=src\primitive.cpp Folder=Source Files/OpenCSG Compile=1 CompileCpp=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit14] FileName=src\primitiveHelper.cpp Folder=Source Files/OpenCSG Compile=1 CompileCpp=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit15] FileName=src\primitiveHelper.h Folder=Source Files/OpenCSG Compile=1 CompileCpp=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit16] FileName=src\renderGoldfeather.cpp Folder=Source Files/OpenCSG Compile=1 CompileCpp=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit17] FileName=src\renderSCS.cpp Folder=Source Files/OpenCSG Compile=1 CompileCpp=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit20] FileName=src\openglExt.h Folder=Source Files/OpenCSG Compile=1 CompileCpp=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit21] FileName=include\opencsg.h Folder=Header Files Compile=1 CompileCpp=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit23] FileName=example\displaylistPrimitive.h Folder=Source Files/OpenCSGexample Compile=1 CompileCpp=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit24] FileName=example\displaylistPrimitive.cpp Folder=Source Files/OpenCSGexample Compile=1 CompileCpp=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit25] FileName=src\opencsgConfig.h Folder=Source Files/OpenCSG Compile=1 CompileCpp=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit26] FileName=src\settings.h CompileCpp=1 Folder=Source Files/OpenCSG Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit27] FileName=src\frameBufferObject.cpp CompileCpp=1 Folder=Source Files/OpenCSG Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit28] FileName=src\frameBufferObject.h CompileCpp=1 Folder=Source Files/OpenCSG Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit29] FileName=src\offscreenBuffer.h CompileCpp=1 Folder=Source Files/OpenCSG Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit30] FileName=src\settings.cpp CompileCpp=1 Folder=Source Files/OpenCSG Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit31] FileName=src\frameBufferObjectExt.cpp CompileCpp=1 Folder=Source Files/OpenCSG Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit32] FileName=src\sequencer.h CompileCpp=1 Folder=Source Files/OpenCSG Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [VersionInfo] Major=0 Minor=1 Release=1 Build=1 LanguageID=1033 CharsetID=1252 CompanyName= FileVersion=0.1.1.1 FileDescription=Developed using the Dev-C++ IDE InternalName= LegalCopyright= LegalTrademarks= OriginalFilename=OpenCSG.exe ProductName=OpenCSG ProductVersion=0.1 AutoIncBuildNr=0 SyncProduct=0 [Unit32] FileName=src\frameBufferObjectExt.h CompileCpp=1 Folder=Source Files/OpenCSG Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit33] FileName=src\context.h CompileCpp=1 Folder=Source Files/OpenCSG Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit34] FileName=src\context.cpp CompileCpp=1 Folder=Source Files/OpenCSG Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit38] FileName=src\glad\include\KHR\khrplatform.h CompileCpp=1 Folder=Source Files Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit39] FileName=src\sequencer.h CompileCpp=1 Folder=Source Files/OpenCSG Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit40] FileName=src\frameBufferObjectExt.h CompileCpp=1 Folder=Source Files/OpenCSG Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit41] FileName=src\context.h CompileCpp=1 Folder=Source Files/OpenCSG Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit42] FileName=src\context.cpp CompileCpp=1 Folder=Source Files/OpenCSG Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit43] FileName=src\context.cpp CompileCpp=1 Folder=Source Files/OpenCSG Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit35] FileName=example\includeGl.h CompileCpp=1 Folder=Source Files/OpenCSGexample Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit18] FileName=src\scissorMemo.cpp CompileCpp=1 Folder=Source Files/OpenCSG Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit19] FileName=src\scissorMemo.h CompileCpp=1 Folder=Source Files/OpenCSG Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit22] FileName=example\main.cpp CompileCpp=1 Folder=Source Files/OpenCSGexample Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit36] FileName=src\glad\src\gl.cpp CompileCpp=1 Folder=Source Files/OpenCSG Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= [Unit37] FileName=src\glad\include\glad\gl.h CompileCpp=1 Folder=Source Files/OpenCSG Compile=1 Link=1 Priority=1000 OverrideBuildCmd=0 BuildCmd= OpenCSG-1.8.2/src/0000775000175000017500000000000015141675417013432 5ustar florianflorianOpenCSG-1.8.2/src/primitiveHelper.cpp0000664000175000017500000001244115141675417017310 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2002-2026, Florian Kirsch, // Hasso-Plattner-Institute at the University of Potsdam, Germany // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // primitiveHelper.cpp // #include "opencsgConfig.h" #include #include "openglExt.h" #include "openglHelper.h" #include "primitiveHelper.h" #include namespace OpenCSG { namespace Algo { bool intersectXY(const Primitive* a, const Primitive* b) { float aminx, aminy, aminz, amaxx, amaxy, amaxz, bminx, bminy, bminz, bmaxx, bmaxy, bmaxz; a->getBoundingBox(aminx, aminy, aminz, amaxx, amaxy, amaxz); b->getBoundingBox(bminx, bminy, bminz, bmaxx, bmaxy, bmaxz); return (bmaxx >= aminx) && (amaxx >= bminx) && (bmaxy >= aminy) && (amaxy >= bminy); } bool intersectXYZ(const Primitive* a, const Primitive* b) { float aminx, aminy, aminz, amaxx, amaxy, amaxz, bminx, bminy, bminz, bmaxx, bmaxy, bmaxz; a->getBoundingBox(aminx, aminy, aminz, amaxx, amaxy, amaxz); b->getBoundingBox(bminx, bminy, bminz, bmaxx, bmaxy, bmaxz); return (bmaxx >= aminx) && (amaxx >= bminx) && (bmaxy >= aminy) && (amaxy >= bminy) && (bmaxz >= aminz) && (amaxz >= bminz); } bool containsXY(const Primitive* a, const Primitive* b) { float aminx, aminy, aminz, amaxx, amaxy, amaxz, bminx, bminy, bminz, bmaxx, bmaxy, bmaxz; a->getBoundingBox(aminx, aminy, aminz, amaxx, amaxy, amaxz); b->getBoundingBox(bminx, bminy, bminz, bmaxx, bmaxy, bmaxz); return (aminx >= bminx) && (amaxx <= bmaxx) && (aminy >= bminy) && (amaxy <= bmaxy); } unsigned int getConvexity(const std::vector& batch) { unsigned int convexity=1; for (std::vector::const_iterator itr = batch.begin(); itr != batch.end(); ++itr) { unsigned int val = (*itr)->getConvexity(); if (convexity < val) { convexity = val; } } return convexity; } } // namespace Algo namespace OpenGL { unsigned int calcMaxDepthComplexity(const std::vector& primitives, const PCArea& area) { glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glDisable(GL_DEPTH_TEST); glStencilMask(255); glEnable(GL_STENCIL_TEST); glStencilFunc(GL_ALWAYS, 0, 255); glStencilOp(GL_INCR, GL_INCR, GL_INCR); glEnable(GL_CULL_FACE); for (std::vector::const_iterator itr = primitives.begin(); itr != primitives.end(); ++itr) { glCullFace((*itr)->getOperation() == Intersection ? GL_BACK : GL_FRONT); (*itr)->render(); } glDisable(GL_CULL_FACE); glDisable(GL_STENCIL_TEST); glEnable(GL_DEPTH_TEST); int dx = area.maxx - area.minx; int dy = area.maxy - area.miny; std::size_t size = static_cast(dx) * dy; GLubyte * buf = new GLubyte[size]; glPixelStorei(GL_PACK_SWAP_BYTES, GL_FALSE); glPixelStorei(GL_PACK_ALIGNMENT, 1); glPixelStorei(GL_PACK_ROW_LENGTH, 0); glPixelStorei(GL_PACK_SKIP_ROWS, 0); glPixelStorei(GL_PACK_SKIP_PIXELS, 0); // This is pathologically slow on ATI HD4670 if not the complete viewport is read back. // So better always read the complete viewport or make this configurable? glReadPixels(area.minx, area.miny, dx, dy, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, buf); unsigned char m = *std::max_element(buf, buf+size); unsigned int max = m; delete[] buf; return max; } void renderLayer(unsigned int layer, const std::vector& primitives) { glStencilFunc(GL_EQUAL, layer, 255); glStencilOp(GL_INCR, GL_INCR, GL_INCR); glStencilMask(255); glEnable(GL_STENCIL_TEST); glEnable(GL_CULL_FACE); for (std::vector::const_iterator j = primitives.begin(); j != primitives.end(); ++j) { glCullFace((*j)->getOperation() == Intersection ? GL_BACK : GL_FRONT); (*j)->render(); } glDisable(GL_CULL_FACE); } } // namespace OpenGL } // namespace OpenCSG OpenCSG-1.8.2/src/context.cpp0000664000175000017500000001620215141675417015623 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2010-2026, Florian Kirsch // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // context.cpp // #include "opencsgConfig.h" #include "context.h" #include "offscreenBuffer.h" #include "frameBufferObject.h" #include "frameBufferObjectExt.h" #include "openglHelper.h" #include namespace OpenCSG { static int gContext = 0; /// redeclared from opencsg.h void setContext(int context) { gContext = context; } /// redeclared from opencsg.h int getContext() { return gContext; } /// redeclared from opencsg.h void freeResources() { OpenGL::freeResources(); } namespace OpenGL { struct ContextData { ContextData() : fARB(0), fEXT(0) {} FrameBufferObject* fARB; FrameBufferObjectExt* fEXT; std::map idFP; std::map idGLSL; }; static std::map gContextDataMap; void ensureFunctionPointers() { // In theory (and probably under Windows only), OpenGL function // pointers could be context specific. I.e., after changing to // a different context, it may be required to update the function // pointers again, or, to store them per context in the first place. // When changing from GLEW to glad, it turned out that this had // never been correctly considered. So I decided to ignore this // potential problem until I get concrete complaints. static bool sHaveOpenGLFunctions = false; if (!sHaveOpenGLFunctions) initExtensionLibrary(); sHaveOpenGLFunctions = true; } OffscreenBuffer* getOffscreenBuffer(OffscreenType type) { int context = getContext(); ContextData& contextData = gContextDataMap[context]; if (type == OpenCSG::FrameBufferObjectARB) { if (!contextData.fARB) contextData.fARB = new FrameBufferObject; return contextData.fARB; } else if (type == OpenCSG::FrameBufferObjectEXT) { if (!contextData.fEXT) contextData.fEXT = new FrameBufferObjectExt; return contextData.fEXT; } return 0; } static GLuint getARBProgram(GLenum target, const char* prog, int len) { int context = getContext(); ContextData& contextData = gContextDataMap[context]; std::map::iterator it = contextData.idFP.find(prog); if (it == contextData.idFP.end()) { GLuint id; glGenProgramsARB(1, &id); glBindProgramARB(target, id); glProgramStringARB(target, GL_PROGRAM_FORMAT_ASCII_ARB, len, prog); // GLint errorPos; // glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errorPos); // const char * error = (const char*)glGetString(GL_PROGRAM_ERROR_STRING_ARB); // printf("%s", error); it = contextData.idFP.insert(std::pair(prog, id)).first; } return it->second; } GLuint getARBVertexProgram(const char* prog, int len) { return getARBProgram(GL_VERTEX_PROGRAM_ARB, prog, len); } GLuint getARBFragmentProgram(const char* prog, int len) { return getARBProgram(GL_FRAGMENT_PROGRAM_ARB, prog, len); } static GLuint getGLSLShader(GLenum target, const char* prog) { GLuint id = glCreateShader(target); glShaderSource(id, 1, &prog, 0); glCompileShader(id); GLint success; char infoLog[512]; glGetShaderiv(id, GL_COMPILE_STATUS, &success); if (!success) { glGetShaderInfoLog(id, 512, NULL, infoLog); //std::cerr << "Vertex Shader Compilation Error: " << infoLog << std::endl; } return id; } GLuint getGLSLVertexShader(const char* prog) { return getGLSLShader(GL_VERTEX_SHADER, prog); } GLuint getGLSLFragmentShader(const char* prog) { return getGLSLShader(GL_FRAGMENT_SHADER, prog); } GLuint getGLSLProgram(const char* programId, const char* vertexProg, const char* fragmentProg) { int context = getContext(); ContextData& contextData = gContextDataMap[context]; std::map::iterator it = contextData.idGLSL.find(programId); if (it == contextData.idGLSL.end()) { GLuint vertexShader = getGLSLVertexShader(vertexProg); GLuint fragmentShader = getGLSLFragmentShader(fragmentProg); GLuint shaderProgram = glCreateProgram(); glAttachShader(shaderProgram, vertexShader); glAttachShader(shaderProgram, fragmentShader); glLinkProgram(shaderProgram); glDeleteShader(vertexShader); glDeleteShader(fragmentShader); it = contextData.idGLSL.insert(std::pair(programId, shaderProgram)).first; } return it->second; } void freeResources() { int context = getContext(); std::map::iterator itr = gContextDataMap.find(context); if (itr != gContextDataMap.end()) { delete itr->second.fARB; delete itr->second.fEXT; { std::map & idFP = itr->second.idFP; for (std::map::iterator it = idFP.begin(); it != idFP.end(); ++it) { glDeleteProgramsARB(1, &(it->second)); } } { std::map & idGLSL = itr->second.idGLSL; for (std::map::iterator it = idGLSL.begin(); it != idGLSL.end(); ++it) { glDeleteProgram(it->second); } } gContextDataMap.erase(itr); } } } // namespace OpenGL } // namespace OpenCSG OpenCSG-1.8.2/src/area.h0000664000175000017500000000370015141675417014513 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2004-2026, Florian Kirsch, // Hasso-Plattner-Institute at the University of Potsdam, Germany // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // area.h // // area structs // #ifndef __OpenCSG__area_h__ #define __OpenCSG__area_h__ #include "opencsgConfig.h" namespace OpenCSG { /// area in pixel coordinates struct PCArea { PCArea( int minxx = 0, int minyy = 0, int maxxx = 0, int maxyy = 0 ) : minx(minxx), miny(minyy), maxx(maxxx), maxy(maxyy) { } int minx, miny, maxx, maxy; }; /// 3d volume in normal device coordinates struct NDCVolume { NDCVolume( float minxx = 0.0f, float minyy = 0.0f, float minzz = 0.0f, float maxxx = 0.0f, float maxyy = 0.0f, float maxzz = 0.0f ) : minx(minxx), miny(minyy), minz(minzz), maxx(maxxx), maxy(maxyy), maxz(maxzz) { } operator PCArea() const; float minx, miny, minz, maxx, maxy, maxz; }; } // namespace OpenCSG #endif // __OpenCSG__area_h__ OpenCSG-1.8.2/src/settings.cpp0000664000175000017500000000575715141675417016014 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2006-2026, Florian Kirsch // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // settings.cpp // #include "opencsgConfig.h" #include #include #include #include #include namespace OpenCSG { // Stores constant strings of all vertex shaders that were ever provided to OpenCSG. // This would compile with std::set as well. But I expect very few shaders here, only. // Note that std::vector would be incorrect, because when resizing the vector, // the strings could be relocated. This must not happen, because the string pointers // are used as keys for the actual GLSL program IDs. typedef std::list VertexShaders; static VertexShaders gVertexShaders; static VertexShaders::iterator gCurrentVertexShader = gVertexShaders.end(); void setVertexShader(const std::string& vertexShader) { if (vertexShader.length() == 0) { gCurrentVertexShader = gVertexShaders.end(); return; } if (gCurrentVertexShader != gVertexShaders.end() && *gCurrentVertexShader == vertexShader) return; VertexShaders::iterator it = std::find(gVertexShaders.begin(), gVertexShaders.end(), vertexShader); if (it != gVertexShaders.end()) { gCurrentVertexShader = it; return; } gCurrentVertexShader = gVertexShaders.insert(it, vertexShader); } const char* getVertexShader() { if (gCurrentVertexShader == gVertexShaders.end()) return 0; return gCurrentVertexShader->c_str(); } static int* gSetting = 0; static void initIntOptions() { if (!gSetting) { gSetting = new int[OptionTypeUnused]; for (int i=0; i #include namespace OpenCSG { namespace OpenGL { class OffscreenBuffer; } class Primitive; enum Channel { NoChannel = 0, Alpha = 1, Red = 2, Green = 4, Blue = 8, AllChannels = 15 }; enum ProjTextureSetup { FixedFunction = 0, ARBShader = 1, GLSLProgram = 2 }; class ChannelManager { public: /// An offscreen buffer is used to collect CSG results in its four /// color channels. These resources are managed in a ChannelManager /// object. Since we use one offscreen buffer per OpenCSG context only, /// this class is a singleton in practice ChannelManager(); virtual ~ChannelManager(); /// initializes the ChannelManager object, i.e., creates the offscreen /// buffer. Returns false on failure. bool init(); /// returns a free channel, or NoChannel if nothings available Channel find() const; /// allocates a new channel for temporary calculation of visibility /// information. return NoChannel if no free channel was found. virtual Channel request(); /// returns the currently used channel for visibility calculation Channel current() const; /// returns channels that currently contain visibility information std::vector occupied() const; /// releases the offscreen buffer and invokes merge() to transfer /// the visibility information into the main canvas. void free(); /// transfers visibility information into the main canvas. /// implemented by subclasses SCSChannelManager and /// GoldfeatherChannelManager virtual void merge() = 0; /// activates or deactivates rendering into a channel void renderToChannel(bool on); /// Setups texture stuff that makes the size of the offscreen buffer /// and the size of the main canvas correspond. Activates texture /// containing the content of the offscreen buffer. The actual /// workings depends on whether the fixed function pipeline, an /// ARB shader, or a GLSL program is used. texSizeInv is the uniform /// location of a 2d-vector that is supposed to take the inverse of /// the texture size. For non-GLSL, texSizeInv is ignored. void setupProjectiveTexture(ProjTextureSetup setup, GLint texSizeInv = -1); /// undoes texture settings void resetProjectiveTexture(ProjTextureSetup setup); /// activate texenv settings such that information in channel is /// moved into alpha, to allow alpha testing of the channel. static void setupTexEnv(Channel channel); protected: bool isRectangularTexture() const; private: ChannelManager(const ChannelManager&); ChannelManager& operator=(const ChannelManager&); static bool gInUse; OpenGL::OffscreenBuffer* mOffscreenBuffer; bool mInOffscreenBuffer; protected: Channel mCurrentChannel; int mOccupiedChannels; }; class ChannelManagerForBatches : public ChannelManager { public: /// Remembers which color channel is used to store visibility /// information of a batch of primitives. ChannelManagerForBatches(); /// allows to remember which primitives are stored in which channel /// layer == -1: convex primitives /// layer == 0: frontmost surface /// etc ... void store(Channel channel, const std::vector& primitives, int layer); /// returns primitives for a channel const std::vector getPrimitives(Channel channel) const; /// returns layer for a channel int getLayer(Channel channel) const; /// clears information void clear(); private: ChannelManagerForBatches(const ChannelManagerForBatches&); ChannelManagerForBatches& operator=(const ChannelManagerForBatches&); std::vector, int> > mPrimitives; }; } // namespace OpenCSG #endif // __OpenCSG__channel_manager_h__ OpenCSG-1.8.2/src/opencsgConfig.h0000664000175000017500000000560615141675417016376 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2002-2026, Florian Kirsch, // Hasso-Plattner-Institute at the University of Potsdam, Germany // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // opencsgConfig.h // // compiler specific settings for OpenCSG // #ifndef __OpenCSG__opencsg_config_h__ #define __OpenCSG__opencsg_config_h__ // WINDOWS #ifdef WIN32 // blend out some compiler warnings #ifdef __INTEL_COMPILER // intel compiler # pragma warning(disable: 985) // identifier ... was truncated in debug information #elif _MSC_VER // microsoft visual studio compiler without intel compiler #if _MSC_VER < 1300 // MSVC++ <= 6.0 # pragma warning(disable: 4786) // identifier was truncated to X characters in the debug information #endif #endif // __INTEL_COMPILER || _MSC_VER #ifdef _MSC_VER // microsoft visual studio compiler and intel compiler #if _MSC_VER < 1300 // MSVC++ <= 6.0 // MSVC does not have std::min and std::max unless using .NET. (>=7.0) // for VC 6.0, we define those function templates in namespace std. // (actually copied from boost). // min / max macros in windows.h additionally circumvent a correct // use of std::min. To circumvent this macro expansion, in OpenCSG // all occurencies of std::min and std::max are put into brackets. // Hopefully, this will fix all compilation problems in the future. #ifdef min #undef min #endif #ifdef max #undef max #endif namespace std { template inline const T& min(const T& a, const T& b) { return b < a ? b : a; } template inline const T& max(const T& a, const T& b) { return a < b ? b : a; } template inline const T& min(const T& a, const T& b, Compare comp) { return comp(b, a) ? b : a; } template inline const T& max(const T& a, const T& b, Compare comp) { return comp(a, b) ? b : a; } typedef ::size_t size_t; // MSVC6 lacks std::size_t } // namespace std #endif // _MSC_VER < 1300, i.e., VS <= 6.0 #endif // _MSC_VER #endif // WIN32 #endif // __OpenCSG__opencsg_config_h__ OpenCSG-1.8.2/src/batch.cpp0000664000175000017500000001075715141675417015231 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2002-2026, Florian Kirsch // Hasso-Plattner-Institute at the University of Potsdam, Germany // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // batch.cpp // #include "opencsgConfig.h" #include #include "batch.h" #include "primitiveHelper.h" namespace OpenCSG { class FullscreenPrimitive : public Primitive { public: FullscreenPrimitive() : Primitive(OpenCSG::Intersection, 1) { } virtual void render() { } }; Batcher::Batcher(const std::vector& primitives) { FullscreenPrimitive fullscreen; const std::size_t numberOfPrimitives = primitives.size(); mBatches.reserve(numberOfPrimitives); std::vector batchCandidates; batchCandidates.reserve(numberOfPrimitives); for (std::vector::const_iterator itr = primitives.begin(); itr != primitives.end(); ++itr) { // primitive completely outside viewport, no need to process it any further if (!Algo::intersectXY(*itr, &fullscreen)) continue; // fullscreen is completely part of the primitive's bounding box, // no other primitive can be part of the same batch if (Algo::containsXY(&fullscreen, *itr)) { mBatches.push_back(Batch()); Batch& batch = mBatches.back(); batch.push_back(*itr); } else { std::vector::iterator batchItr = batchCandidates.begin(); std::vector::iterator batchEnd = batchCandidates.end(); for ( ; batchItr != batchEnd; ++batchItr) { Batch & batch = *batchItr; Batch::const_iterator batchPrimitives = batch.begin(); Batch::const_iterator batchPrimitivesEnd = batch.end(); // if the primitive does not intersect any of the primitives in // the current batch, we can add the primitive to that batch for ( ; batchPrimitives != batchPrimitivesEnd; ++batchPrimitives) { if (Algo::intersectXY(*itr, *batchPrimitives)) { break; } } if (batchPrimitives == batchPrimitivesEnd) { batch.push_back(*itr); break; } } // primitive could not added to any batch -> create a new batch if (batchItr == batchEnd) { batchCandidates.push_back(Batch()); Batch& batch = batchCandidates.back(); batch.push_back(*itr); } } } // Could do here the following. But since since batchCandidates is not needed anymore, // we can use the std::vector swap trick to avoid calling of the copy constructor. // std::copy(batchCandidates.begin(), batchCandidates.end(), std::back_inserter(mBatches)); std::vector::iterator batchItr = batchCandidates.begin(); std::vector::iterator batchEnd = batchCandidates.end(); for ( ; batchItr != batchEnd; ++batchItr) { mBatches.push_back(Batch()); Batch& batch = mBatches.back(); batch.swap(*batchItr); } } const std::vector& Batcher::batches() const { return mBatches; } std::vector::const_iterator Batcher::begin() const { return mBatches.begin(); } std::vector::const_iterator Batcher::end() const { return mBatches.end(); } std::size_t Batcher::size() const { return mBatches.size(); } } // namespace OpenCSG OpenCSG-1.8.2/src/context.h0000664000175000017500000000553415141675417015276 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2010-2026, Florian Kirsch // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // context.h // // OpenCSG context management // #ifndef __OpenCSG__context_h__ #define __OpenCSG__context_h__ #include "opencsgConfig.h" #include #include "openglExt.h" namespace OpenCSG { /// redeclared from opencsg.h void setContext(int context); /// redeclared from opencsg.h int getContext(); /// redeclared from opencsg.h void freeResources(); namespace OpenGL { class OffscreenBuffer; /// Retrieves the OpenGL function pointers, including the /// functions pointers of OpenGL extensions, from the /// OpenGL extension library (such as GLEW or glad). void ensureFunctionPointers(); /// Checks the OpenGL-extensions resp. the current settings /// and returns a concrete offscreen buffer, for the currently /// active context in OpenCSG. OffscreenBuffer* getOffscreenBuffer(OffscreenType type); /// Given a constant(!) ARB vertex program string and its length, /// returns a ARB vertex program object, for the currently /// active context in OpenCSG. GLuint getARBVertexProgram(const char* prog, int len); /// Given a constant(!) ARB fragment program string and its length, /// returns a ARB fragment program object, for the currently /// active context in OpenCSG. GLuint getARBFragmentProgram(const char* prog, int len); GLuint getGLSLVertexShader(const char* prog); GLuint getGLSLFragmentShader(const char* prog); /// Given a constant(!), null-terminated vertex and fragment /// program strings, returns a GLSL program object, for the /// currently active context in OpenCSG. GLuint getGLSLProgram(const char* programId, const char* vertexShader, const char* fragmentShader); /// Frees all resources (offscreen buffers, fragment programs...) /// allocated for the currently active context in OpenCSG. void freeResources(); } // namespace OpenGL } // namespace OpenCSG #endif // __OpenCSG__context_h__ OpenCSG-1.8.2/src/renderGoldfeather.cpp0000664000175000017500000005570015141675417017571 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2002-2026, Florian Kirsch, // Hasso-Plattner-Institute at the University of Potsdam, Germany // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // renderGoldfeather.cpp // // stuff specific for the Goldfeather algorithm // #include "opencsgConfig.h" #include #include "opencsgRender.h" #include "batch.h" #include "channelManager.h" #include "context.h" #include "occlusionQuery.h" #include "openglHelper.h" #include "primitiveHelper.h" #include "scissorMemo.h" #include "settings.h" #include #include namespace OpenCSG { namespace { ScissorMemo* scissor; class GoldfeatherChannelManager : public ChannelManagerForBatches { public: virtual void merge(); }; void GoldfeatherChannelManager::merge() { ProjTextureSetup setup = FixedFunction; setupProjectiveTexture(setup); glEnable(GL_ALPHA_TEST); glAlphaFunc(GL_GEQUAL, 0.5f); // accuracy issue with GL_EQUAL 1.0 on FX5600 glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glDepthMask(GL_TRUE); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); std::vector channels = occupied(); for (std::vector::const_iterator c = channels.begin(); c!=channels.end(); ++c) { const std::vector primitives = getPrimitives(*c); scissor->recall(*c); scissor->enableScissor(); setupTexEnv(*c); if (getLayer(*c) == -1) { glEnable(GL_CULL_FACE); for (Batch::const_iterator j = primitives.begin(); j != primitives.end(); ++j) { glCullFace((*j)->getOperation() == Intersection ? GL_BACK : GL_FRONT); (*j)->render(); } } else { // shapes of interest: we need to determine the appropriate layer of // the shapes, using stencil counting glClearStencil(0); glStencilMask(OpenGL::stencilMask); glClear(GL_STENCIL_BUFFER_BIT); OpenGL::renderLayer(getLayer(*c), primitives); glDisable(GL_STENCIL_TEST); } } glDisable(GL_ALPHA_TEST); glDisable(GL_CULL_FACE); glDepthFunc(GL_LEQUAL); scissor->disableScissor(); resetProjectiveTexture(setup); clear(); } class GoldfeatherChannelManagerGLSLProgram : public ChannelManagerForBatches { public: virtual void merge(); }; static const char mergeFragmentProgramRect[] = "#version 110\n" "#extension GL_ARB_texture_rectangle : enable\n" "uniform sampler2DRect texture0;\n" "uniform vec4 color;\n" "void main() {\n" " vec4 temp = texture2DRect(texture0, gl_FragCoord.xy);\n" " float d = dot(temp, color);\n" " if (d < 0.5)\n" " discard;\n" " gl_FragColor = color;\n" "}\n"; static const char mergeFragmentProgram2D[] = "#version 110\n" "uniform sampler2D texture0;\n" "uniform vec2 texSizeInv;\n" "uniform vec4 color;\n" "void main() {\n" " vec2 texCoord = vec2(gl_FragCoord.x * texSizeInv.x, gl_FragCoord.y * texSizeInv.y);\n" " vec4 temp = texture2D(texture0, texCoord);\n" " float d = dot(temp, color);\n" " if (d < 0.5)\n" " discard;\n" " gl_FragColor = color;\n" "}\n"; void GoldfeatherChannelManagerGLSLProgram::merge() { const int GFIdOffset = 0; const char* programID = getVertexShader() + (isRectangularTexture() ? 1 : 0) + GFIdOffset; GLuint glslProgram = isRectangularTexture() ? OpenGL::getGLSLProgram(programID, getVertexShader(), mergeFragmentProgramRect) : OpenGL::getGLSLProgram(programID, getVertexShader(), mergeFragmentProgram2D); GLint col = glGetUniformLocation(glslProgram, "color"); GLint texSizeInv = -1; if (!isRectangularTexture()) texSizeInv = glGetUniformLocation(glslProgram, "texSizeInv"); glUseProgram(glslProgram); ProjTextureSetup setup = GLSLProgram; setupProjectiveTexture(setup, texSizeInv); glDisable(GL_ALPHA_TEST); glEnable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glDepthMask(GL_TRUE); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); std::vector channels = occupied(); for (std::vector::const_iterator c = channels.begin(); c != channels.end(); ++c) { const std::vector primitives = getPrimitives(*c); scissor->recall(*c); scissor->enableScissor(); GLfloat refColor[4] = { 0.0f, 0.0f, 0.0f, 0.0f }; switch (*c) { case Alpha: refColor[3] = 1.0f; break; case Red: refColor[0] = 1.0f; break; case Green: refColor[1] = 1.0f; break; case Blue: refColor[2] = 1.0f; break; default: // should not happen! assert(0); } glUniform4fv(col, 1, refColor); if (getLayer(*c) == -1) { glEnable(GL_CULL_FACE); for (Batch::const_iterator j = primitives.begin(); j != primitives.end(); ++j) { glCullFace((*j)->getOperation() == Intersection ? GL_BACK : GL_FRONT); (*j)->render(); } } else { // shapes of interest: we need to determine the appropriate layer of // the shapes, using stencil counting glClearStencil(0); glStencilMask(OpenGL::stencilMask); glClear(GL_STENCIL_BUFFER_BIT); OpenGL::renderLayer(getLayer(*c), primitives); glDisable(GL_STENCIL_TEST); } } scissor->disableScissor(); glDisable(GL_CULL_FACE); glDepthFunc(GL_LEQUAL); glUseProgram(0); resetProjectiveTexture(setup); clear(); } ChannelManagerForBatches* channelMgr; void touchFragments(const Batch& batch) { glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); GLboolean origVertexArrayState = glIsEnabled(GL_VERTEX_ARRAY); if (!origVertexArrayState) { glEnableClientState(GL_VERTEX_ARRAY); } for (Batch::const_iterator j = batch.begin(); j != batch.end(); ++j) { float fminx, fminy, fminz, fmaxx, fmaxy, fmaxz; (*j)->getBoundingBox(fminx, fminy, fminz, fmaxx, fmaxy, fmaxz); const GLfloat v[8] = { fminx, fminy, fmaxx, fminy, fminx, fmaxy, fmaxx, fmaxy }; glVertexPointer(2, GL_FLOAT, 0, v); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); } if (!origVertexArrayState) { glDisableClientState(GL_VERTEX_ARRAY); } glMatrixMode(GL_PROJECTION); glPopMatrix(); glMatrixMode(GL_MODELVIEW); glPopMatrix(); } GLenum getParityDepthFunc() { int setting = getOption(CameraOutsideOptimization); if (setting == OptimizationOn || setting == OptimizationForceOn) return GL_LEQUAL; else return GL_GREATER; } void discardFragments(const Batch& batch, int parity, int mask) { glDepthFunc(GL_ALWAYS); glDepthMask(GL_TRUE); glDepthRange(1.0, 1.0); glStencilMask(mask); glStencilFunc(GL_NOTEQUAL, parity, mask); glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO); channelMgr->renderToChannel(true); glColor4ub(0, 0, 0, 0); touchFragments(batch); glDepthRange(0.0, 1.0); glDepthMask(GL_FALSE); glDepthFunc(getParityDepthFunc()); } void discardFragments(int parity, int mask) { glDepthFunc(GL_ALWAYS); glDepthMask(GL_TRUE); glDepthRange(1.0, 1.0); glStencilMask(mask); glStencilFunc(GL_NOTEQUAL, parity, mask); glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO); channelMgr->renderToChannel(true); glColor4ub(0, 0, 0, 0); OpenGL::drawQuad(); glDepthRange(0.0, 1.0); glDepthMask(GL_FALSE); glDepthFunc(getParityDepthFunc()); } void discardFragments( const Batch& batch, int parity, int mask, bool layered) { if (layered) { discardFragments(parity, mask); } else { if (scissor->isDepthBoundsTestEnabled()) glDisable(GL_DEPTH_BOUNDS_TEST_EXT); discardFragments(batch, parity, mask); if (scissor->isDepthBoundsTestEnabled()) glEnable(GL_DEPTH_BOUNDS_TEST_EXT); } } void parityTestAndDiscard( const Batch& shapesOfInterest, const std::vector& primitives, bool layered, unsigned int stencilMax) { glDepthMask(GL_FALSE); glDepthFunc(getParityDepthFunc()); glEnable(GL_STENCIL_TEST); unsigned int parityValue = 1; unsigned int allParityTestValues = 0; // for all shapes of the intersection, we conduct the parity test. // for fragments for which it fails, we mark them as not visible // (parity testing means to check whether the number of surfaces in front // of the current z-buffer is even or uneven. As all shapes are closed, // this is equivalent to check the number of surfaces behind the current // z-buffer. This is what we effectively do by default, because // that approach is more robust) for (std::vector::const_iterator itr = primitives.begin(); itr != primitives.end(); ++itr ) { if (!layered) { // substracted shapes that form a part of the shapes of interest // can not alter the visibility of the other shapes of interest. the reason: // for other substracted shapes: by definition // for other intersecting shapes: since the bounding boxes do no overlap // // for intersecting shapes, the above only is true if it is the only shape // in the list of shapes of interest Batch::const_iterator res = std::find(shapesOfInterest.begin(), shapesOfInterest.end(), *itr); bool isContained = (res != shapesOfInterest.end()); if (isContained && ((*itr)->getOperation() == Subtraction || shapesOfInterest.size() == 1)) { continue; } // for substracted shapes that don't touch the shapes of interest, // the parity test would always fail. thus, they are omited here. bool needParityTest = ((*itr)->getOperation() == Intersection); if (!needParityTest) { for (Batch::const_iterator k = shapesOfInterest.begin(); k != shapesOfInterest.end(); ++k) { if (Algo::intersectXYZ(*itr, *k)) { needParityTest = true; break; } } } if (!needParityTest) continue; } // we only need one bit in the stencil buffer for each parity test. // Thus we iterate over all bits, and only when all bits have been // used, we discard fragments marked invisible by the parity test, // and clear the stencil buffer. if (parityValue >= stencilMax) { discardFragments(shapesOfInterest, allParityTestValues, parityValue - 1, layered); parityValue = 1; allParityTestValues = 0; } // parity test: count surfaces behind (or, depending on setting, in front) // of shapes of interest, i.e., the current z-buffer. channelMgr->renderToChannel(false); glStencilFunc(GL_ALWAYS, 0, parityValue); glStencilMask(parityValue); glStencilOp(GL_KEEP, GL_KEEP, GL_INVERT); (*itr)->render(); // after the parity test, the reaction differs whether we have a // intersecting or a subtracted shape: // if #(surfaces) is even (stencilValue == 0): // if intersecting shapes -> shape do not intersect, set depth to max // if subtracting second shape -> first shape is visible, don't change depth // if #(surfaces) is uneven (stencilValue == parityValue): // if intersecting shapes -> shapes intersect, first shape is visible, don't change depth // if subtracting second shape -> front surface of first shape is subtracted, not visible. set depth to max if ((*itr)->getOperation() == Intersection) { allParityTestValues += parityValue; } parityValue <<= 1; } // discard fragments marked invisible the last parity tests (and clear the stencil buffer) if (parityValue != 1) { // that would mean no parity test had occured at all discardFragments(shapesOfInterest, allParityTestValues, parityValue - 1, layered); } glDisable(GL_STENCIL_TEST); } } // unnamed namespace static void renderGoldfeather(const std::vector& primitives) { scissor = new ScissorMemo; Batcher batches(primitives); scissor->setIntersected(primitives); for (std::vector::const_iterator itr = batches.begin(); itr != batches.end(); ++itr) { unsigned int maxConvexity = Algo::getConvexity(*itr); for (unsigned int currentLayer = 0; currentLayer < maxConvexity; ++currentLayer) { if (channelMgr->request() == NoChannel) { channelMgr->free(); channelMgr->request(); } channelMgr->renderToChannel(true); glColor4ub(255, 255, 255, 255); glStencilMask(OpenGL::stencilMask); glEnable(GL_STENCIL_TEST); glDepthFunc(GL_ALWAYS); glDepthMask(GL_TRUE); scissor->setCurrent(*itr); scissor->store(channelMgr->current()); scissor->enableScissor(); if (maxConvexity == 1) { // shapes of interest: we need to determine which parts of them are visible. // first assume they are fully visible glStencilFunc(GL_ALWAYS, 0, OpenGL::stencilMask); glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE); glEnable(GL_CULL_FACE); for (Batch::const_iterator j = itr->begin(); j != itr->end(); ++j) { glCullFace((*j)->getOperation() == Intersection ? GL_BACK : GL_FRONT); (*j)->render(); } glDisable(GL_CULL_FACE); } else { // shapes of interest: we need to determine the appropriate layer of // the shapes, using stencil counting glClear(GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); OpenGL::renderLayer(currentLayer, *itr); glClear(GL_STENCIL_BUFFER_BIT); } GLenum depthFunc = getParityDepthFunc(); if (depthFunc == GL_GREATER) scissor->enableDepthBoundsFront(); else if (depthFunc == GL_LEQUAL) scissor->enableDepthBoundsBack(); parityTestAndDiscard(*itr, primitives, false, OpenGL::stencilMask); scissor->disableDepthBounds(); scissor->disableScissor(); channelMgr->store(channelMgr->current(), *itr, maxConvexity == 1 ? -1 : static_cast(currentLayer)); } } channelMgr->free(); delete scissor; } static bool renderOcclusionQueryGoldfeather(const std::vector& primitives) { scissor = new ScissorMemo; unsigned int layer = 0; scissor->setIntersected(primitives); scissor->setCurrent(primitives); OpenGL::OcclusionQuery* occlusionTest = 0; bool retVal = true; while (true) { if (channelMgr->request() == NoChannel) { channelMgr->free(); channelMgr->request(); } scissor->store(channelMgr->current()); scissor->enableScissor(); if (!occlusionTest) { occlusionTest = OpenGL::getOcclusionQuery(false); if (!occlusionTest) { retVal = false; break; } } channelMgr->renderToChannel(true); glStencilMask(OpenGL::stencilMask); glClear(GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); glDepthFunc(GL_ALWAYS); glDepthMask(GL_TRUE); glColor4ub(255, 255, 255, 255); occlusionTest->beginQuery(); OpenGL::renderLayer(layer, primitives); occlusionTest->endQuery(); // the fragment count query could occur here, but benches show that // the algorithm is faster if the query is delayed. glClear(GL_STENCIL_BUFFER_BIT); parityTestAndDiscard(primitives, primitives, true, OpenGL::stencilMax); unsigned int anyFragmentRendered = occlusionTest->getQueryResult(); if (!anyFragmentRendered) { retVal = true; break; } channelMgr->store(channelMgr->current(), primitives, layer); scissor->disableScissor(); ++layer; // There are more layers than the stencil buffer allows us to // render. Return claiming success (which is cheating, since // we were not really successful) if (layer == OpenGL::stencilMax) { retVal = true; break; } } delete occlusionTest; channelMgr->free(); delete scissor; return retVal; } static void renderDepthComplexitySamplingGoldfeather(const std::vector& primitives) { scissor = new ScissorMemo; scissor->setIntersected(primitives); scissor->setCurrent(primitives); scissor->enableScissor(); unsigned int depthComplexity = OpenGL::calcMaxDepthComplexity(primitives, scissor->getIntersectedArea()); scissor->disableScissor(); for (unsigned int layer = 0; layer < depthComplexity; ++layer) { if (channelMgr->request() == NoChannel) { channelMgr->free(); channelMgr->request(); } scissor->store(channelMgr->current()); scissor->enableScissor(); channelMgr->renderToChannel(true); glStencilMask(OpenGL::stencilMask); glClear(GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); glDepthFunc(GL_ALWAYS); glDepthMask(GL_TRUE); glColor4ub(255, 255, 255, 255); OpenGL::renderLayer(layer, primitives); glClear(GL_STENCIL_BUFFER_BIT); parityTestAndDiscard(primitives, primitives, true, OpenGL::stencilMax); channelMgr->store(channelMgr->current(), primitives, layer); scissor->disableScissor(); } channelMgr->free(); delete scissor; } static ChannelManagerForBatches* getChannelManager() { if (GLAD_GL_VERSION_2_0) { bool useGLSL = getVertexShader() != 0; if (useGLSL) return new GoldfeatherChannelManagerGLSLProgram; } return new GoldfeatherChannelManager; } void renderGoldfeather(const std::vector& primitives, DepthComplexityAlgorithm algorithm) { channelMgr = getChannelManager(); if (channelMgr->init()) { switch (algorithm) { case OcclusionQuery: if (renderOcclusionQueryGoldfeather(primitives)) break; // success // coming here should not happen in practice due to the check // for extensions performed by the caller. Anyway, if it happens, // fall through case NoDepthComplexitySampling: renderGoldfeather(primitives); break; case DepthComplexitySampling: renderDepthComplexitySamplingGoldfeather(primitives); break; } } delete channelMgr; } } // namespace OpenCSG OpenCSG-1.8.2/src/offscreenBuffer.h0000664000175000017500000000701215141675417016707 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2006-2026, Florian Kirsch // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // offscreenBuffer.h // // offscreen buffer abstraction // #ifndef __OpenCSG__offscreen_buffer_h__ #define __OpenCSG__offscreen_buffer_h__ #include "opencsgConfig.h" #include namespace OpenCSG { struct Dimensions { Dimensions() : width(-1), height(1) { } Dimensions(int w, int h) : width(w), height(h) { } friend bool operator==(const Dimensions& me, const Dimensions& other) { return (me.width == other.width) && (me.height == other.height); } int width; int height; }; namespace OpenGL { class OffscreenBuffer { public: // abstract base class OffscreenBuffer() {}; virtual ~OffscreenBuffer() {}; /// Reads the current settings, such as the currently bound FBO. /// This should be called before every use of the offscreen buffer /// even if Initialize() or Resize() do not need to be called. virtual bool ReadCurrent() = 0; /// Call this once before use, to initialize the offscreen buffer /// with the intended width and height. virtual bool Initialize(Dimensions dims) = 0; /// checks whether Initialize has been called before or not virtual bool IsInitialized() const = 0; /// Change the size of the render texture. After this, Initialize /// must be called again. virtual bool Resize(Dimensions dims) = 0; /// Begin drawing to the texture. (i.e. use as "output" texture) virtual bool BeginCapture() = 0; /// End drawing to the texture. virtual bool EndCapture() = 0; /// Bind the texture to the active texture unit for use as an "input" texture virtual void Bind() const = 0; /// Enables the texture target appropriate for this render texture. virtual void EnableTextureTarget() const = 0; /// Disables the texture target appropriate for this render texture. virtual void DisableTextureTarget() const = 0; /// Returns the texture target this texture is bound to. virtual unsigned int GetTextureTarget() const = 0; /// Returns the width of the offscreen buffer. virtual int GetWidth() const = 0; /// Returns the width of the offscreen buffer. virtual int GetHeight() const = 0; private: OffscreenBuffer(const OffscreenBuffer&); OffscreenBuffer& operator=(const OffscreenBuffer&); }; } // namespace OpenGL } // namespace OpenCSG #endif // __OpenCSG__offscreen_buffer_h__ OpenCSG-1.8.2/src/frameBufferObjectExt.cpp0000664000175000017500000001242515141675417020176 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2010-2026, Florian Kirsch // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // frameBufferObjectExt.cpp // #include "opencsgConfig.h" #include "frameBufferObjectExt.h" namespace OpenCSG { namespace OpenGL { // ctor / dtor FrameBufferObjectExt::FrameBufferObjectExt() : textureTarget(GL_TEXTURE_2D), textureID(0), depthID(0), framebufferID(0), oldFramebufferID(0), initialized(false) { } FrameBufferObjectExt::~FrameBufferObjectExt() { Reset(); } bool FrameBufferObjectExt::ReadCurrent() { bool haveFBO = OPENCSG_HAS_EXT(EXT_framebuffer_object) != 0 && OPENCSG_HAS_EXT(EXT_packed_depth_stencil) != 0; if (haveFBO) glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &oldFramebufferID); return haveFBO; } bool FrameBufferObjectExt::Initialize(Dimensions dims) { bool haveFBO = OPENCSG_HAS_EXT(EXT_framebuffer_object) != 0 && OPENCSG_HAS_EXT(EXT_packed_depth_stencil) != 0; if (!haveFBO) return false; dimensions = dims; glGenFramebuffersEXT(1, &framebufferID); glGenRenderbuffersEXT(1, &depthID); glGenTextures(1, &textureID); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, framebufferID); GLenum target = GL_TEXTURE_2D; if ( !OPENCSG_HAS_EXT(ARB_texture_non_power_of_two) && ( OPENCSG_HAS_EXT(ARB_texture_rectangle) || OPENCSG_HAS_EXT(EXT_texture_rectangle) || OPENCSG_HAS_EXT(NV_texture_rectangle))) target = GL_TEXTURE_RECTANGLE_ARB; glBindTexture(target, textureID); glTexImage2D(target, 0, GL_RGBA8, GetWidth(), GetHeight(), 0, GL_RGBA, GL_INT, 0); glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, target, textureID, 0); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depthID); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_STENCIL_EXT, GetWidth(), GetHeight()); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depthID); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depthID); GLenum status; status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if (status == GL_FRAMEBUFFER_UNSUPPORTED_EXT) { Reset(); return false; } glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, oldFramebufferID); glBindTexture(target, 0); textureTarget = target; initialized = true; return true; } // Releases frame buffer objects bool FrameBufferObjectExt::Reset() { if (textureID) { glDeleteTextures(1, &textureID); textureID = 0; } if (depthID) { glDeleteRenderbuffersEXT(1, &depthID); depthID = 0; } if (framebufferID) { glDeleteFramebuffersEXT(1, &framebufferID); framebufferID = 0; } dimensions = Dimensions(); initialized = false; return true; } // If new requested size differs, regenerate FBO texture objects bool FrameBufferObjectExt::Resize(Dimensions dims) { if (dimensions == dims) { return true; } Reset(); return Initialize(dims); } // Binds the created frame buffer texture such we can render into it. bool FrameBufferObjectExt::BeginCapture() { glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, framebufferID); return true; } // Unbinds frame buffer texture. bool FrameBufferObjectExt::EndCapture() { glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, oldFramebufferID); return true; } // Sets the frame buffer texture as active texture object. void FrameBufferObjectExt::Bind() const { glBindTexture(textureTarget, textureID); } } // namespace OpenGL } // namespace OpenCSG OpenCSG-1.8.2/src/openglExt.h0000664000175000017500000000474615141675417015563 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2023-2026, Florian Kirsch // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // openglExt.h // // wrap libraries for extension checking, to ease switching between // #ifndef __OpenCSG__opengl_ext_h__ #define __OpenCSG__opengl_ext_h__ #if 0 // OpenGL extension checking via GLEW. This is // what was used up to OpenCSG 1.5.1 (without // this funny #define, of course). GLEW has its // problems. On Linux, it often links against // GLX which may be not available on Wayland systems. #include #define OPENCSG_HAS_EXT(name) GLEW_ ## name inline void initExtensionLibrary() { // implemented empty for historic reasons. In the past, it was // expected that glewInit() was called from the external // application. } #else // OpenGL extension checking with glad. // To avoid conflicts with other software // that maybe as well use glad, the generated // sources of glad are hacked here, such that // all symbols end up in the OpenCSG namespace. // The khronos includes several system includes. // Those must not be put into the OpenCSG namespace. #include "glad/include/KHR/khrplatform.h" namespace OpenCSG { // Keep the global namespace clean. Maybe should be even moved into the // sub-namespace OpenGL. // Unfortunately, this requires some manual editing of the // generated glad files: glad.cpp must include glad.h as well // while the OpenCSG namespace is open. Furthermore, the // C name mangling for the glad symbols must be disabled. #include "glad/include/glad/gl.h" #define OPENCSG_HAS_EXT(name) GLAD_GL_ ## name inline void initExtensionLibrary() { gladLoaderLoadGL(); } } // namespace OpenCSG #endif #endif // __OpenCSG__opengl_ext_h__ OpenCSG-1.8.2/src/opencsgRender.h0000664000175000017500000000275515141675417016412 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2002-2026, Florian Kirsch, // Hasso-Plattner-Institute at the University of Potsdam, Germany // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // opencsgRender.h // // dispatcher for CSG algorithms implemented in OpenCSG // #ifndef __OpenCSG__opencsg_render_h__ #define __OpenCSG__opencsg_render_h__ #include "opencsgConfig.h" #include #include namespace OpenCSG { /// SCS algorithm. Implemented in renderSCS.cpp void renderSCS(const std::vector& primitives, DepthComplexityAlgorithm); /// Goldfeather algorithm. Implemented in renderGoldfeather.cpp void renderGoldfeather(const std::vector& primitives, DepthComplexityAlgorithm); } // namespace OpenCSG #endif // __OpenCSG__opencsg_render_h__ OpenCSG-1.8.2/src/opencsgRender.cpp0000664000175000017500000000740215141675417016737 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2002-2026, Florian Kirsch, // Hasso-Plattner-Institute at the University of Potsdam, Germany // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // opencsgRender.cpp // #include "opencsgConfig.h" #include #include "context.h" #include "opencsgRender.h" #include "primitiveHelper.h" #include "settings.h" namespace OpenCSG { namespace { bool haveHardwareOcclusionQueries() { return OPENCSG_HAS_EXT(ARB_occlusion_query) || OPENCSG_HAS_EXT(NV_occlusion_query); } Algorithm chooseAlgorithm(const std::vector& primitives) { if (Algo::getConvexity(primitives) >= 2) { return Goldfeather; } return SCS; } DepthComplexityAlgorithm chooseDepthComplexityAlgorithm(const std::vector& primitives) { if (!haveHardwareOcclusionQueries() && primitives.size() > 40) { return DepthComplexitySampling; } if (haveHardwareOcclusionQueries() && primitives.size() > 20) { return OcclusionQuery; } return NoDepthComplexitySampling; } } // unnamed namespace static void renderDispatch(const std::vector& primitives, Algorithm algorithm, DepthComplexityAlgorithm depthComplexityAlgorithm) { if (primitives.empty()) { return; } bool hasIntersected = false; for (std::vector::const_iterator itr = primitives.begin(); itr != primitives.end(); ++itr) { Operation operation = (*itr)->getOperation(); if (operation == Intersection) { hasIntersected = true; break; } } if (!hasIntersected) { return; } if (algorithm == Automatic) { algorithm = chooseAlgorithm(primitives); depthComplexityAlgorithm = chooseDepthComplexityAlgorithm(primitives); } if (depthComplexityAlgorithm == OcclusionQuery && !haveHardwareOcclusionQueries()) { // hardware support is missing. issue a warning? depthComplexityAlgorithm = DepthComplexitySampling; } if (algorithm != Automatic) { switch (algorithm) { case Goldfeather: renderGoldfeather(primitives, depthComplexityAlgorithm); break; case SCS: renderSCS(primitives, depthComplexityAlgorithm); break; default: break; } } } void render(const std::vector& primitives) { OpenGL::ensureFunctionPointers(); Algorithm algorithm = (Algorithm)getOption(AlgorithmSetting); DepthComplexityAlgorithm depthComplexityAlgorithm = (DepthComplexityAlgorithm)getOption(DepthComplexitySetting); renderDispatch(primitives, algorithm, depthComplexityAlgorithm); } } // namespace OpenCSG OpenCSG-1.8.2/src/scissorMemo.cpp0000664000175000017500000001665215141675417016453 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2002-2026, Florian Kirsch, // Hasso-Plattner-Institute at the University of Potsdam, Germany // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // scissorMemo.cpp // #include "opencsgConfig.h" #include #include "openglExt.h" #include "openglHelper.h" #include "scissorMemo.h" #include namespace OpenCSG { ScissorMemo::ScissorMemo() : mIntersection(NDCVolume(-1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 1.0f)), mCurrent(NDCVolume(1.0f, 1.0f, 1.0f, -1.0f, -1.0f, 0.0f)), mArea(NDCVolume(-1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 1.0f)), mScissor(std::vector(AllChannels + 1)), mUseDepthBoundsTest(false) { int optimizationSetting = getOption(DepthBoundsOptimization); if (optimizationSetting == OptimizationForceOn) mUseDepthBoundsTest = true; else if ( optimizationSetting == OptimizationDefault || optimizationSetting == OptimizationOff) mUseDepthBoundsTest = false; else if (optimizationSetting == OptimizationOn) mUseDepthBoundsTest = (OPENCSG_HAS_EXT(EXT_depth_bounds_test) != 0); } void ScissorMemo::store(Channel ch) { mScissor[ch] = mArea; } void ScissorMemo::recall(Channel ch) { mArea = mScissor[ch]; } void ScissorMemo::enableScissor() const { OpenGL::scissor(mArea); } void ScissorMemo::disableScissor() const { glDisable(GL_SCISSOR_TEST); } bool ScissorMemo::isDepthBoundsTestEnabled() const { return mUseDepthBoundsTest; } void ScissorMemo::enableDepthBounds() const { if (!mUseDepthBoundsTest) return; glDepthBoundsEXT(mArea.minz, mArea.maxz); glEnable(GL_DEPTH_BOUNDS_TEST_EXT); } void ScissorMemo::enableDepthBoundsBack() const { if (!mUseDepthBoundsTest) return; glDepthBoundsEXT(0.0f, mCurrent.maxz); glEnable(GL_DEPTH_BOUNDS_TEST_EXT); } void ScissorMemo::enableDepthBoundsFront() const { if (!mUseDepthBoundsTest) return; glDepthBoundsEXT(mCurrent.minz, 1.0); glEnable(GL_DEPTH_BOUNDS_TEST_EXT); } void ScissorMemo::disableDepthBounds() const { if (!mUseDepthBoundsTest) return; glDisable(GL_DEPTH_BOUNDS_TEST_EXT); } void ScissorMemo::setIntersected(const std::vector& primitives) { float& minx = mIntersection.minx; float& miny = mIntersection.miny; float& minz = mIntersection.minz; float& maxx = mIntersection.maxx; float& maxy = mIntersection.maxy; float& maxz = mIntersection.maxz; // dont let intersected area exceed scissor region set by the application (outside OpenCSG) const int dx = OpenGL::canvasPos[2] - OpenGL::canvasPos[0]; const int dy = OpenGL::canvasPos[3] - OpenGL::canvasPos[1]; const float sx = 2.0f * (static_cast(OpenGL::scissorPos[0]) / static_cast(dx)) - 1.0f; const float sy = 2.0f * (static_cast(OpenGL::scissorPos[1]) / static_cast(dy)) - 1.0f; const float swx = 2.0f * (static_cast(OpenGL::scissorPos[2] + OpenGL::scissorPos[0]) / static_cast(dx)) - 1.0f; const float swy = 2.0f * (static_cast(OpenGL::scissorPos[3] + OpenGL::scissorPos[1]) / static_cast(dy)) - 1.0f; minx = sx; maxx = swx; miny = sy; maxy = swy; minz = 0.0f; maxz = 1.0f; // might read current depth value, but usefulness is unclear for (std::vector::const_iterator itr = primitives.begin(); itr != primitives.end(); ++itr) { if ((*itr)->getOperation() == Intersection) { float tminx, tminy, tminz, tmaxx, tmaxy, tmaxz; (*itr)->getBoundingBox(tminx, tminy, tminz, tmaxx, tmaxy, tmaxz); minx = (std::max)(minx, tminx); miny = (std::max)(miny, tminy); minz = (std::max)(minz, tminz); maxx = (std::min)(maxx, tmaxx); maxy = (std::min)(maxy, tmaxy); maxz = (std::min)(maxz, tmaxz); } } minx = (std::max)(-1.0f, minx); minx = (std::min)( 1.0f, minx); miny = (std::max)(-1.0f, miny); miny = (std::min)( 1.0f, miny); minz = (std::max)( 0.0f, minz); minz = (std::min)( 1.0f, minz); maxx = (std::max)(-1.0f, maxx); maxx = (std::min)( 1.0f, maxx); maxy = (std::max)(-1.0f, maxy); maxy = (std::min)( 1.0f, maxy); maxz = (std::max)( 0.0f, maxz); maxz = (std::min)( 1.0f, maxz); calculateArea(); } const NDCVolume& ScissorMemo::getIntersectedArea() const { return mIntersection; } const NDCVolume& ScissorMemo::getCurrentArea() const { return mArea; } void ScissorMemo::setCurrent(const std::vector& primitives) { float& minx = mCurrent.minx; float& miny = mCurrent.miny; float& minz = mCurrent.minz; float& maxx = mCurrent.maxx; float& maxy = mCurrent.maxy; float& maxz = mCurrent.maxz; minx = 1.0f; maxx = -1.0f; miny = 1.0f; maxy = -1.0f; minz = 1.0f; maxz = 0.0f; for (std::vector::const_iterator itr = primitives.begin(); itr != primitives.end(); ++itr) { float tminx, tminy, tminz, tmaxx, tmaxy, tmaxz; (*itr)->getBoundingBox(tminx, tminy, tminz, tmaxx, tmaxy, tmaxz); minx = (std::min)(minx, tminx); miny = (std::min)(miny, tminy); minz = (std::min)(minz, tminz); maxx = (std::max)(maxx, tmaxx); maxy = (std::max)(maxy, tmaxy); maxz = (std::max)(maxz, tmaxz); } minx = (std::max)(-1.0f, minx); minx = (std::min)( 1.0f, minx); miny = (std::max)(-1.0f, miny); miny = (std::min)( 1.0f, miny); minz = (std::max)( 0.0f, minz); minz = (std::min)( 1.0f, minz); maxx = (std::max)(-1.0f, maxx); maxx = (std::min)( 1.0f, maxx); maxy = (std::max)(-1.0f, maxy); maxy = (std::min)( 1.0f, maxy); maxz = (std::max)( 0.0f, maxz); maxz = (std::min)( 1.0f, maxz); calculateArea(); } void ScissorMemo::calculateArea() { mArea.minx = (std::max)(mCurrent.minx, mIntersection.minx); mArea.miny = (std::max)(mCurrent.miny, mIntersection.miny); mArea.minz = (std::max)(mCurrent.minz, mIntersection.minz); mArea.maxx = (std::min)(mCurrent.maxx, mIntersection.maxx); mArea.maxy = (std::min)(mCurrent.maxy, mIntersection.maxy); mArea.maxz = (std::min)(mCurrent.maxz, mIntersection.maxz); } } // namespace OpenCSG OpenCSG-1.8.2/src/primitive.cpp0000664000175000017500000000447415141675417016157 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2002-2026, Florian Kirsch, // Hasso-Plattner-Institute at the University of Potsdam, Germany // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // primitive.cpp // // implements Primitive interface (declared in opencsg.h) // #include "opencsgConfig.h" #include #include namespace OpenCSG { Primitive::Primitive(Operation o, unsigned int c) : mOperation(o), mConvexity(c), mMinx(-1.0f), mMiny(-1.0f), mMinz(-1.0f), mMaxx(1.0f), mMaxy(1.0f), mMaxz(1.0f) { } Primitive::~Primitive() { } void Primitive::setOperation(Operation o) { mOperation = o; } Operation Primitive::getOperation() const { return mOperation; } void Primitive::setConvexity(unsigned int c) { mConvexity = c; } unsigned int Primitive::getConvexity() const { return mConvexity; } void Primitive::setBoundingBox(float minx, float miny, float minz, float maxx, float maxy, float maxz) { assert(minx <= maxx); assert(miny <= maxy); assert(minz <= maxz); mMinx = minx; mMiny = miny; mMinz = minz; mMaxx = maxx; mMaxy = maxy; mMaxz = maxz; } void Primitive::getBoundingBox(float& minx, float& miny, float& minz, float& maxx, float& maxy, float& maxz) const { minx = mMinx; miny = mMiny; minz = mMinz; maxx = mMaxx; maxy = mMaxy; maxz = mMaxz; } } // namespace OpenCSG OpenCSG-1.8.2/src/sequencer.h0000664000175000017500000000716615141675417015607 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2025-2026, Florian Kirsch // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // sequencer.h // // algorithms to create short permutation embedding sequences. // c.f. https://oeis.org/A062714. Such sequences are used in the // SCS algorithm. // #ifndef __OpenCSG__sequencer_h__ #define __OpenCSG__sequencer_h__ #include "opencsgConfig.h" #include namespace OpenCSG { class Sequencer { public: virtual ~Sequencer() { } virtual size_t index(size_t position) const = 0; virtual size_t size() const = 0; virtual size_t sizeForDepthComplexity(size_t dc) const = 0; protected: Sequencer(size_t numElems) : n(numElems) { } size_t n; }; class SimpleSequencer : public Sequencer { public: SimpleSequencer(size_t numElems) : Sequencer(numElems) { } virtual size_t index(size_t position) const { return position % n; } virtual size_t size() const { return n * (n - 1) + 1; } virtual size_t sizeForDepthComplexity(size_t dc) const { return n * dc; } }; class BouncingSequencer : public Sequencer { public: BouncingSequencer(size_t numElems) : Sequencer(numElems) { } virtual size_t index(size_t position) const { if (n == 1) return 0; size_t wave = position % (n + n - 2); if (wave < n) return wave; else return (n + n - 2) - wave; } virtual size_t size() const { return n * (n - 1) + 1; } virtual size_t sizeForDepthComplexity(size_t dc) const { return (dc & 1) == 1 ? (dc - 1) * (n - 1) + n : dc * (n - 1) + 1; } }; class SchoenfieldSequencer : public Sequencer { public: SchoenfieldSequencer(size_t numElems) : Sequencer(numElems) { } virtual size_t index(size_t position) const { if (n == 1) return 0; if (n == 2) return position & 1; if (position < n) return position; else if ((position - 1) % (n - 1) == 0) return 0; else return (position * (n - 2) / (n - 1)) % (n - 1) + 1; } virtual size_t size() const { if (n == 1) return 1; if (n == 2) return 3; return n * n - 2 * n + 4; } virtual size_t sizeForDepthComplexity(size_t dc) const { return std::min(size(), n * dc); } }; } // namespace OpenCSG #endif // __OpenCSG__sequencer_h__ OpenCSG-1.8.2/src/openglHelper.cpp0000664000175000017500000000471615141675417016572 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2002-2026, Florian Kirsch, // Hasso-Plattner-Institute at the University of Potsdam, Germany // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // openglHelper.h // #include "opencsgConfig.h" #include "openglExt.h" #include "openglHelper.h" namespace OpenCSG { namespace OpenGL { GLfloat projection[16]; GLfloat modelview[16]; GLint canvasPos[4]; GLint stencilBits = 0; unsigned int stencilMax = 0; unsigned int stencilMask = 0; GLint scissorPos[4]; void scissor(const PCArea& area) { const int dx = area.maxx - area.minx; const int dy = area.maxy - area.miny; glScissor(area.minx, area.miny, dx, dy); glEnable(GL_SCISSOR_TEST); } void drawQuad() { glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); const GLfloat v[8] = { -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, 1.0f, 1.0f }; GLboolean origVertexArrayState = glIsEnabled(GL_VERTEX_ARRAY); if (!origVertexArrayState) { glEnableClientState(GL_VERTEX_ARRAY); } glVertexPointer(2, GL_FLOAT, 0, v); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); if (!origVertexArrayState) { glDisableClientState(GL_VERTEX_ARRAY); } glMatrixMode(GL_PROJECTION); glPopMatrix(); glMatrixMode(GL_MODELVIEW); glPopMatrix(); } } // namespace OpenGL } // namespace OpenCSG OpenCSG-1.8.2/src/frameBufferObject.h0000664000175000017500000000727415141675417017170 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2006-2026, Florian Kirsch // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // frameBufferObject.h // // frame buffer object class implementing the offscreen buffer interface // #ifndef __OpenCSG__frame_buffer_object_h__ #define __OpenCSG__frame_buffer_object_h__ #include "opencsgConfig.h" #include "offscreenBuffer.h" #include "openglExt.h" namespace OpenCSG { namespace OpenGL { class FrameBufferObject : public OffscreenBuffer { public: /// ctor / dtor FrameBufferObject(); virtual ~FrameBufferObject(); /// Reads the currently bound FBO. virtual bool ReadCurrent(); /// Initializes the frame buffer object with the intended width and height. /// The frame buffer object is created with RGBA and combined depth/stencil buffer. virtual bool Initialize(Dimensions dims); /// checks whether Initialize has been called before or not virtual bool IsInitialized() const { return initialized; } /// Change the size of the frame buffer object. virtual bool Resize(Dimensions dims); /// Begin drawing to the frame buffer object. (i.e. use as "output" texture) virtual bool BeginCapture(); /// End drawing to the frame buffer object. virtual bool EndCapture(); /// Bind the frame buffer object to the active texture unit for use as an "input" texture virtual void Bind() const; /// Enables the texture target appropriate for this frame buffer object. virtual void EnableTextureTarget() const { if (initialized) glEnable(textureTarget); } /// Disables the texture target appropriate for this frame buffer object. virtual void DisableTextureTarget() const { if (initialized) glDisable(textureTarget); } /// Returns the texture target this texture is bound to. virtual unsigned int GetTextureTarget() const { return textureTarget; } /// Returns the width of the frame buffer object. virtual int GetWidth() const { return dimensions.width; } /// Returns the width of the frame buffer object. virtual int GetHeight() const { return dimensions.height; } private: FrameBufferObject(const FrameBufferObject&); FrameBufferObject& operator=(const FrameBufferObject&); // Width and height of the frame buffer object Dimensions dimensions; /// Texture stuff GLenum textureTarget; unsigned int textureID; unsigned int depthID; unsigned int framebufferID; int oldFramebufferID; bool initialized; /// Removes the frame buffer object OpenGL resources. bool Reset(); }; } // namespace OpenGL } // namespace OpenCSG #endif // __OpenCSG__frame_buffer_object_h__ OpenCSG-1.8.2/src/CMakeLists.txt0000664000175000017500000000207015141675417016171 0ustar florianflorianadd_library(opencsg area.cpp area.h batch.cpp batch.h channelManager.cpp channelManager.h context.cpp context.h frameBufferObject.cpp frameBufferObject.h frameBufferObjectExt.cpp frameBufferObjectExt.h glad/include/KHR/khrplatform.h glad/include/glad/gl.h glad/src/gl.cpp occlusionQuery.cpp occlusionQuery.h offscreenBuffer.h opencsgConfig.h opencsgRender.cpp opencsgRender.h openglExt.h openglHelper.cpp openglHelper.h primitive.cpp primitiveHelper.cpp primitiveHelper.h renderGoldfeather.cpp renderSCS.cpp scissorMemo.cpp scissorMemo.h sequencer.h settings.cpp settings.h ) target_include_directories(opencsg PUBLIC "${CMAKE_SOURCE_DIR}/include" ) set_target_properties(opencsg PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION ${PROJECT_VERSION_MAJOR} PUBLIC_HEADER "${CMAKE_SOURCE_DIR}/include/opencsg.h" ) find_package(OpenGL REQUIRED) install(TARGETS opencsg LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} ) OpenCSG-1.8.2/src/glad/0000775000175000017500000000000015141675417014341 5ustar florianflorianOpenCSG-1.8.2/src/glad/src/0000775000175000017500000000000015141675417015130 5ustar florianflorianOpenCSG-1.8.2/src/glad/src/gl.cpp0000664000175000017500000032242115141675417016242 0ustar florianflorian/** * SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0 */ #include #include #include namespace OpenCSG { #include "../include/glad/gl.h" #ifndef GLAD_IMPL_UTIL_C_ #define GLAD_IMPL_UTIL_C_ #if _MSC_VER >= 1400 // VS >= 8.0 #define GLAD_IMPL_UTIL_SSCANF sscanf_s #else #define GLAD_IMPL_UTIL_SSCANF sscanf #endif #endif /* GLAD_IMPL_UTIL_C_ */ int GLAD_GL_VERSION_1_0 = 0; int GLAD_GL_VERSION_1_1 = 0; int GLAD_GL_VERSION_1_2 = 0; int GLAD_GL_VERSION_1_3 = 0; int GLAD_GL_VERSION_1_4 = 0; int GLAD_GL_VERSION_1_5 = 0; int GLAD_GL_VERSION_2_0 = 0; int GLAD_GL_ARB_depth_clamp = 0; int GLAD_GL_ARB_fragment_program = 0; int GLAD_GL_ARB_framebuffer_object = 0; int GLAD_GL_ARB_occlusion_query = 0; int GLAD_GL_ARB_occlusion_query2 = 0; int GLAD_GL_ARB_texture_cube_map = 0; int GLAD_GL_ARB_texture_env_dot3 = 0; int GLAD_GL_ARB_texture_non_power_of_two = 0; int GLAD_GL_ARB_texture_rectangle = 0; int GLAD_GL_ARB_vertex_program = 0; int GLAD_GL_EXT_depth_bounds_test = 0; int GLAD_GL_EXT_framebuffer_object = 0; int GLAD_GL_EXT_packed_depth_stencil = 0; int GLAD_GL_EXT_texture_cube_map = 0; int GLAD_GL_EXT_texture_env_dot3 = 0; int GLAD_GL_EXT_texture_rectangle = 0; int GLAD_GL_NV_depth_clamp = 0; int GLAD_GL_NV_fill_rectangle = 0; int GLAD_GL_NV_occlusion_query = 0; int GLAD_GL_NV_packed_depth_stencil = 0; int GLAD_GL_NV_texture_rectangle = 0; PFNGLACCUMPROC glad_glAccum = NULL; PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL; PFNGLALPHAFUNCPROC glad_glAlphaFunc = NULL; PFNGLARETEXTURESRESIDENTPROC glad_glAreTexturesResident = NULL; PFNGLARRAYELEMENTPROC glad_glArrayElement = NULL; PFNGLATTACHSHADERPROC glad_glAttachShader = NULL; PFNGLBEGINPROC glad_glBegin = NULL; PFNGLBEGINOCCLUSIONQUERYNVPROC glad_glBeginOcclusionQueryNV = NULL; PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL; PFNGLBEGINQUERYARBPROC glad_glBeginQueryARB = NULL; PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL; PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL; PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL; PFNGLBINDFRAMEBUFFEREXTPROC glad_glBindFramebufferEXT = NULL; PFNGLBINDPROGRAMARBPROC glad_glBindProgramARB = NULL; PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL; PFNGLBINDRENDERBUFFEREXTPROC glad_glBindRenderbufferEXT = NULL; PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL; PFNGLBITMAPPROC glad_glBitmap = NULL; PFNGLBLENDCOLORPROC glad_glBlendColor = NULL; PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL; PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL; PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL; PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL; PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer = NULL; PFNGLBUFFERDATAPROC glad_glBufferData = NULL; PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL; PFNGLCALLLISTPROC glad_glCallList = NULL; PFNGLCALLLISTSPROC glad_glCallLists = NULL; PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL; PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC glad_glCheckFramebufferStatusEXT = NULL; PFNGLCLEARPROC glad_glClear = NULL; PFNGLCLEARACCUMPROC glad_glClearAccum = NULL; PFNGLCLEARCOLORPROC glad_glClearColor = NULL; PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL; PFNGLCLEARINDEXPROC glad_glClearIndex = NULL; PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL; PFNGLCLIENTACTIVETEXTUREPROC glad_glClientActiveTexture = NULL; PFNGLCLIPPLANEPROC glad_glClipPlane = NULL; PFNGLCOLOR3BPROC glad_glColor3b = NULL; PFNGLCOLOR3BVPROC glad_glColor3bv = NULL; PFNGLCOLOR3DPROC glad_glColor3d = NULL; PFNGLCOLOR3DVPROC glad_glColor3dv = NULL; PFNGLCOLOR3FPROC glad_glColor3f = NULL; PFNGLCOLOR3FVPROC glad_glColor3fv = NULL; PFNGLCOLOR3IPROC glad_glColor3i = NULL; PFNGLCOLOR3IVPROC glad_glColor3iv = NULL; PFNGLCOLOR3SPROC glad_glColor3s = NULL; PFNGLCOLOR3SVPROC glad_glColor3sv = NULL; PFNGLCOLOR3UBPROC glad_glColor3ub = NULL; PFNGLCOLOR3UBVPROC glad_glColor3ubv = NULL; PFNGLCOLOR3UIPROC glad_glColor3ui = NULL; PFNGLCOLOR3UIVPROC glad_glColor3uiv = NULL; PFNGLCOLOR3USPROC glad_glColor3us = NULL; PFNGLCOLOR3USVPROC glad_glColor3usv = NULL; PFNGLCOLOR4BPROC glad_glColor4b = NULL; PFNGLCOLOR4BVPROC glad_glColor4bv = NULL; PFNGLCOLOR4DPROC glad_glColor4d = NULL; PFNGLCOLOR4DVPROC glad_glColor4dv = NULL; PFNGLCOLOR4FPROC glad_glColor4f = NULL; PFNGLCOLOR4FVPROC glad_glColor4fv = NULL; PFNGLCOLOR4IPROC glad_glColor4i = NULL; PFNGLCOLOR4IVPROC glad_glColor4iv = NULL; PFNGLCOLOR4SPROC glad_glColor4s = NULL; PFNGLCOLOR4SVPROC glad_glColor4sv = NULL; PFNGLCOLOR4UBPROC glad_glColor4ub = NULL; PFNGLCOLOR4UBVPROC glad_glColor4ubv = NULL; PFNGLCOLOR4UIPROC glad_glColor4ui = NULL; PFNGLCOLOR4UIVPROC glad_glColor4uiv = NULL; PFNGLCOLOR4USPROC glad_glColor4us = NULL; PFNGLCOLOR4USVPROC glad_glColor4usv = NULL; PFNGLCOLORMASKPROC glad_glColorMask = NULL; PFNGLCOLORMATERIALPROC glad_glColorMaterial = NULL; PFNGLCOLORPOINTERPROC glad_glColorPointer = NULL; PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL; PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL; PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL; PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL; PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL; PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL; PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL; PFNGLCOPYPIXELSPROC glad_glCopyPixels = NULL; PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL; PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL; PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL; PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL; PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL; PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL; PFNGLCREATESHADERPROC glad_glCreateShader = NULL; PFNGLCULLFACEPROC glad_glCullFace = NULL; PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL; PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL; PFNGLDELETEFRAMEBUFFERSEXTPROC glad_glDeleteFramebuffersEXT = NULL; PFNGLDELETELISTSPROC glad_glDeleteLists = NULL; PFNGLDELETEOCCLUSIONQUERIESNVPROC glad_glDeleteOcclusionQueriesNV = NULL; PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL; PFNGLDELETEPROGRAMSARBPROC glad_glDeleteProgramsARB = NULL; PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL; PFNGLDELETEQUERIESARBPROC glad_glDeleteQueriesARB = NULL; PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL; PFNGLDELETERENDERBUFFERSEXTPROC glad_glDeleteRenderbuffersEXT = NULL; PFNGLDELETESHADERPROC glad_glDeleteShader = NULL; PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL; PFNGLDEPTHBOUNDSEXTPROC glad_glDepthBoundsEXT = NULL; PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL; PFNGLDEPTHMASKPROC glad_glDepthMask = NULL; PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL; PFNGLDETACHSHADERPROC glad_glDetachShader = NULL; PFNGLDISABLEPROC glad_glDisable = NULL; PFNGLDISABLECLIENTSTATEPROC glad_glDisableClientState = NULL; PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL; PFNGLDISABLEVERTEXATTRIBARRAYARBPROC glad_glDisableVertexAttribArrayARB = NULL; PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL; PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL; PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL; PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL; PFNGLDRAWPIXELSPROC glad_glDrawPixels = NULL; PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL; PFNGLEDGEFLAGPROC glad_glEdgeFlag = NULL; PFNGLEDGEFLAGPOINTERPROC glad_glEdgeFlagPointer = NULL; PFNGLEDGEFLAGVPROC glad_glEdgeFlagv = NULL; PFNGLENABLEPROC glad_glEnable = NULL; PFNGLENABLECLIENTSTATEPROC glad_glEnableClientState = NULL; PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL; PFNGLENABLEVERTEXATTRIBARRAYARBPROC glad_glEnableVertexAttribArrayARB = NULL; PFNGLENDPROC glad_glEnd = NULL; PFNGLENDLISTPROC glad_glEndList = NULL; PFNGLENDOCCLUSIONQUERYNVPROC glad_glEndOcclusionQueryNV = NULL; PFNGLENDQUERYPROC glad_glEndQuery = NULL; PFNGLENDQUERYARBPROC glad_glEndQueryARB = NULL; PFNGLEVALCOORD1DPROC glad_glEvalCoord1d = NULL; PFNGLEVALCOORD1DVPROC glad_glEvalCoord1dv = NULL; PFNGLEVALCOORD1FPROC glad_glEvalCoord1f = NULL; PFNGLEVALCOORD1FVPROC glad_glEvalCoord1fv = NULL; PFNGLEVALCOORD2DPROC glad_glEvalCoord2d = NULL; PFNGLEVALCOORD2DVPROC glad_glEvalCoord2dv = NULL; PFNGLEVALCOORD2FPROC glad_glEvalCoord2f = NULL; PFNGLEVALCOORD2FVPROC glad_glEvalCoord2fv = NULL; PFNGLEVALMESH1PROC glad_glEvalMesh1 = NULL; PFNGLEVALMESH2PROC glad_glEvalMesh2 = NULL; PFNGLEVALPOINT1PROC glad_glEvalPoint1 = NULL; PFNGLEVALPOINT2PROC glad_glEvalPoint2 = NULL; PFNGLFEEDBACKBUFFERPROC glad_glFeedbackBuffer = NULL; PFNGLFINISHPROC glad_glFinish = NULL; PFNGLFLUSHPROC glad_glFlush = NULL; PFNGLFOGCOORDPOINTERPROC glad_glFogCoordPointer = NULL; PFNGLFOGCOORDDPROC glad_glFogCoordd = NULL; PFNGLFOGCOORDDVPROC glad_glFogCoorddv = NULL; PFNGLFOGCOORDFPROC glad_glFogCoordf = NULL; PFNGLFOGCOORDFVPROC glad_glFogCoordfv = NULL; PFNGLFOGFPROC glad_glFogf = NULL; PFNGLFOGFVPROC glad_glFogfv = NULL; PFNGLFOGIPROC glad_glFogi = NULL; PFNGLFOGIVPROC glad_glFogiv = NULL; PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL; PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC glad_glFramebufferRenderbufferEXT = NULL; PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D = NULL; PFNGLFRAMEBUFFERTEXTURE1DEXTPROC glad_glFramebufferTexture1DEXT = NULL; PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL; PFNGLFRAMEBUFFERTEXTURE2DEXTPROC glad_glFramebufferTexture2DEXT = NULL; PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D = NULL; PFNGLFRAMEBUFFERTEXTURE3DEXTPROC glad_glFramebufferTexture3DEXT = NULL; PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer = NULL; PFNGLFRONTFACEPROC glad_glFrontFace = NULL; PFNGLFRUSTUMPROC glad_glFrustum = NULL; PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL; PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL; PFNGLGENFRAMEBUFFERSEXTPROC glad_glGenFramebuffersEXT = NULL; PFNGLGENLISTSPROC glad_glGenLists = NULL; PFNGLGENOCCLUSIONQUERIESNVPROC glad_glGenOcclusionQueriesNV = NULL; PFNGLGENPROGRAMSARBPROC glad_glGenProgramsARB = NULL; PFNGLGENQUERIESPROC glad_glGenQueries = NULL; PFNGLGENQUERIESARBPROC glad_glGenQueriesARB = NULL; PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL; PFNGLGENRENDERBUFFERSEXTPROC glad_glGenRenderbuffersEXT = NULL; PFNGLGENTEXTURESPROC glad_glGenTextures = NULL; PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL; PFNGLGENERATEMIPMAPEXTPROC glad_glGenerateMipmapEXT = NULL; PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL; PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL; PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL; PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL; PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL; PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL; PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL; PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL; PFNGLGETCLIPPLANEPROC glad_glGetClipPlane = NULL; PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL; PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL; PFNGLGETERRORPROC glad_glGetError = NULL; PFNGLGETFLOATVPROC glad_glGetFloatv = NULL; PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL; PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC glad_glGetFramebufferAttachmentParameterivEXT = NULL; PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL; PFNGLGETLIGHTFVPROC glad_glGetLightfv = NULL; PFNGLGETLIGHTIVPROC glad_glGetLightiv = NULL; PFNGLGETMAPDVPROC glad_glGetMapdv = NULL; PFNGLGETMAPFVPROC glad_glGetMapfv = NULL; PFNGLGETMAPIVPROC glad_glGetMapiv = NULL; PFNGLGETMATERIALFVPROC glad_glGetMaterialfv = NULL; PFNGLGETMATERIALIVPROC glad_glGetMaterialiv = NULL; PFNGLGETOCCLUSIONQUERYIVNVPROC glad_glGetOcclusionQueryivNV = NULL; PFNGLGETOCCLUSIONQUERYUIVNVPROC glad_glGetOcclusionQueryuivNV = NULL; PFNGLGETPIXELMAPFVPROC glad_glGetPixelMapfv = NULL; PFNGLGETPIXELMAPUIVPROC glad_glGetPixelMapuiv = NULL; PFNGLGETPIXELMAPUSVPROC glad_glGetPixelMapusv = NULL; PFNGLGETPOINTERVPROC glad_glGetPointerv = NULL; PFNGLGETPOLYGONSTIPPLEPROC glad_glGetPolygonStipple = NULL; PFNGLGETPROGRAMENVPARAMETERDVARBPROC glad_glGetProgramEnvParameterdvARB = NULL; PFNGLGETPROGRAMENVPARAMETERFVARBPROC glad_glGetProgramEnvParameterfvARB = NULL; PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL; PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC glad_glGetProgramLocalParameterdvARB = NULL; PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC glad_glGetProgramLocalParameterfvARB = NULL; PFNGLGETPROGRAMSTRINGARBPROC glad_glGetProgramStringARB = NULL; PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL; PFNGLGETPROGRAMIVARBPROC glad_glGetProgramivARB = NULL; PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL; PFNGLGETQUERYOBJECTIVARBPROC glad_glGetQueryObjectivARB = NULL; PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL; PFNGLGETQUERYOBJECTUIVARBPROC glad_glGetQueryObjectuivARB = NULL; PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL; PFNGLGETQUERYIVARBPROC glad_glGetQueryivARB = NULL; PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL; PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC glad_glGetRenderbufferParameterivEXT = NULL; PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL; PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL; PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL; PFNGLGETSTRINGPROC glad_glGetString = NULL; PFNGLGETTEXENVFVPROC glad_glGetTexEnvfv = NULL; PFNGLGETTEXENVIVPROC glad_glGetTexEnviv = NULL; PFNGLGETTEXGENDVPROC glad_glGetTexGendv = NULL; PFNGLGETTEXGENFVPROC glad_glGetTexGenfv = NULL; PFNGLGETTEXGENIVPROC glad_glGetTexGeniv = NULL; PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL; PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL; PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL; PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL; PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL; PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL; PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL; PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL; PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL; PFNGLGETVERTEXATTRIBPOINTERVARBPROC glad_glGetVertexAttribPointervARB = NULL; PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL; PFNGLGETVERTEXATTRIBDVARBPROC glad_glGetVertexAttribdvARB = NULL; PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL; PFNGLGETVERTEXATTRIBFVARBPROC glad_glGetVertexAttribfvARB = NULL; PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL; PFNGLGETVERTEXATTRIBIVARBPROC glad_glGetVertexAttribivARB = NULL; PFNGLHINTPROC glad_glHint = NULL; PFNGLINDEXMASKPROC glad_glIndexMask = NULL; PFNGLINDEXPOINTERPROC glad_glIndexPointer = NULL; PFNGLINDEXDPROC glad_glIndexd = NULL; PFNGLINDEXDVPROC glad_glIndexdv = NULL; PFNGLINDEXFPROC glad_glIndexf = NULL; PFNGLINDEXFVPROC glad_glIndexfv = NULL; PFNGLINDEXIPROC glad_glIndexi = NULL; PFNGLINDEXIVPROC glad_glIndexiv = NULL; PFNGLINDEXSPROC glad_glIndexs = NULL; PFNGLINDEXSVPROC glad_glIndexsv = NULL; PFNGLINDEXUBPROC glad_glIndexub = NULL; PFNGLINDEXUBVPROC glad_glIndexubv = NULL; PFNGLINITNAMESPROC glad_glInitNames = NULL; PFNGLINTERLEAVEDARRAYSPROC glad_glInterleavedArrays = NULL; PFNGLISBUFFERPROC glad_glIsBuffer = NULL; PFNGLISENABLEDPROC glad_glIsEnabled = NULL; PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL; PFNGLISFRAMEBUFFEREXTPROC glad_glIsFramebufferEXT = NULL; PFNGLISLISTPROC glad_glIsList = NULL; PFNGLISOCCLUSIONQUERYNVPROC glad_glIsOcclusionQueryNV = NULL; PFNGLISPROGRAMPROC glad_glIsProgram = NULL; PFNGLISPROGRAMARBPROC glad_glIsProgramARB = NULL; PFNGLISQUERYPROC glad_glIsQuery = NULL; PFNGLISQUERYARBPROC glad_glIsQueryARB = NULL; PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL; PFNGLISRENDERBUFFEREXTPROC glad_glIsRenderbufferEXT = NULL; PFNGLISSHADERPROC glad_glIsShader = NULL; PFNGLISTEXTUREPROC glad_glIsTexture = NULL; PFNGLLIGHTMODELFPROC glad_glLightModelf = NULL; PFNGLLIGHTMODELFVPROC glad_glLightModelfv = NULL; PFNGLLIGHTMODELIPROC glad_glLightModeli = NULL; PFNGLLIGHTMODELIVPROC glad_glLightModeliv = NULL; PFNGLLIGHTFPROC glad_glLightf = NULL; PFNGLLIGHTFVPROC glad_glLightfv = NULL; PFNGLLIGHTIPROC glad_glLighti = NULL; PFNGLLIGHTIVPROC glad_glLightiv = NULL; PFNGLLINESTIPPLEPROC glad_glLineStipple = NULL; PFNGLLINEWIDTHPROC glad_glLineWidth = NULL; PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL; PFNGLLISTBASEPROC glad_glListBase = NULL; PFNGLLOADIDENTITYPROC glad_glLoadIdentity = NULL; PFNGLLOADMATRIXDPROC glad_glLoadMatrixd = NULL; PFNGLLOADMATRIXFPROC glad_glLoadMatrixf = NULL; PFNGLLOADNAMEPROC glad_glLoadName = NULL; PFNGLLOADTRANSPOSEMATRIXDPROC glad_glLoadTransposeMatrixd = NULL; PFNGLLOADTRANSPOSEMATRIXFPROC glad_glLoadTransposeMatrixf = NULL; PFNGLLOGICOPPROC glad_glLogicOp = NULL; PFNGLMAP1DPROC glad_glMap1d = NULL; PFNGLMAP1FPROC glad_glMap1f = NULL; PFNGLMAP2DPROC glad_glMap2d = NULL; PFNGLMAP2FPROC glad_glMap2f = NULL; PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL; PFNGLMAPGRID1DPROC glad_glMapGrid1d = NULL; PFNGLMAPGRID1FPROC glad_glMapGrid1f = NULL; PFNGLMAPGRID2DPROC glad_glMapGrid2d = NULL; PFNGLMAPGRID2FPROC glad_glMapGrid2f = NULL; PFNGLMATERIALFPROC glad_glMaterialf = NULL; PFNGLMATERIALFVPROC glad_glMaterialfv = NULL; PFNGLMATERIALIPROC glad_glMateriali = NULL; PFNGLMATERIALIVPROC glad_glMaterialiv = NULL; PFNGLMATRIXMODEPROC glad_glMatrixMode = NULL; PFNGLMULTMATRIXDPROC glad_glMultMatrixd = NULL; PFNGLMULTMATRIXFPROC glad_glMultMatrixf = NULL; PFNGLMULTTRANSPOSEMATRIXDPROC glad_glMultTransposeMatrixd = NULL; PFNGLMULTTRANSPOSEMATRIXFPROC glad_glMultTransposeMatrixf = NULL; PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL; PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL; PFNGLMULTITEXCOORD1DPROC glad_glMultiTexCoord1d = NULL; PFNGLMULTITEXCOORD1DVPROC glad_glMultiTexCoord1dv = NULL; PFNGLMULTITEXCOORD1FPROC glad_glMultiTexCoord1f = NULL; PFNGLMULTITEXCOORD1FVPROC glad_glMultiTexCoord1fv = NULL; PFNGLMULTITEXCOORD1IPROC glad_glMultiTexCoord1i = NULL; PFNGLMULTITEXCOORD1IVPROC glad_glMultiTexCoord1iv = NULL; PFNGLMULTITEXCOORD1SPROC glad_glMultiTexCoord1s = NULL; PFNGLMULTITEXCOORD1SVPROC glad_glMultiTexCoord1sv = NULL; PFNGLMULTITEXCOORD2DPROC glad_glMultiTexCoord2d = NULL; PFNGLMULTITEXCOORD2DVPROC glad_glMultiTexCoord2dv = NULL; PFNGLMULTITEXCOORD2FPROC glad_glMultiTexCoord2f = NULL; PFNGLMULTITEXCOORD2FVPROC glad_glMultiTexCoord2fv = NULL; PFNGLMULTITEXCOORD2IPROC glad_glMultiTexCoord2i = NULL; PFNGLMULTITEXCOORD2IVPROC glad_glMultiTexCoord2iv = NULL; PFNGLMULTITEXCOORD2SPROC glad_glMultiTexCoord2s = NULL; PFNGLMULTITEXCOORD2SVPROC glad_glMultiTexCoord2sv = NULL; PFNGLMULTITEXCOORD3DPROC glad_glMultiTexCoord3d = NULL; PFNGLMULTITEXCOORD3DVPROC glad_glMultiTexCoord3dv = NULL; PFNGLMULTITEXCOORD3FPROC glad_glMultiTexCoord3f = NULL; PFNGLMULTITEXCOORD3FVPROC glad_glMultiTexCoord3fv = NULL; PFNGLMULTITEXCOORD3IPROC glad_glMultiTexCoord3i = NULL; PFNGLMULTITEXCOORD3IVPROC glad_glMultiTexCoord3iv = NULL; PFNGLMULTITEXCOORD3SPROC glad_glMultiTexCoord3s = NULL; PFNGLMULTITEXCOORD3SVPROC glad_glMultiTexCoord3sv = NULL; PFNGLMULTITEXCOORD4DPROC glad_glMultiTexCoord4d = NULL; PFNGLMULTITEXCOORD4DVPROC glad_glMultiTexCoord4dv = NULL; PFNGLMULTITEXCOORD4FPROC glad_glMultiTexCoord4f = NULL; PFNGLMULTITEXCOORD4FVPROC glad_glMultiTexCoord4fv = NULL; PFNGLMULTITEXCOORD4IPROC glad_glMultiTexCoord4i = NULL; PFNGLMULTITEXCOORD4IVPROC glad_glMultiTexCoord4iv = NULL; PFNGLMULTITEXCOORD4SPROC glad_glMultiTexCoord4s = NULL; PFNGLMULTITEXCOORD4SVPROC glad_glMultiTexCoord4sv = NULL; PFNGLNEWLISTPROC glad_glNewList = NULL; PFNGLNORMAL3BPROC glad_glNormal3b = NULL; PFNGLNORMAL3BVPROC glad_glNormal3bv = NULL; PFNGLNORMAL3DPROC glad_glNormal3d = NULL; PFNGLNORMAL3DVPROC glad_glNormal3dv = NULL; PFNGLNORMAL3FPROC glad_glNormal3f = NULL; PFNGLNORMAL3FVPROC glad_glNormal3fv = NULL; PFNGLNORMAL3IPROC glad_glNormal3i = NULL; PFNGLNORMAL3IVPROC glad_glNormal3iv = NULL; PFNGLNORMAL3SPROC glad_glNormal3s = NULL; PFNGLNORMAL3SVPROC glad_glNormal3sv = NULL; PFNGLNORMALPOINTERPROC glad_glNormalPointer = NULL; PFNGLORTHOPROC glad_glOrtho = NULL; PFNGLPASSTHROUGHPROC glad_glPassThrough = NULL; PFNGLPIXELMAPFVPROC glad_glPixelMapfv = NULL; PFNGLPIXELMAPUIVPROC glad_glPixelMapuiv = NULL; PFNGLPIXELMAPUSVPROC glad_glPixelMapusv = NULL; PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL; PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL; PFNGLPIXELTRANSFERFPROC glad_glPixelTransferf = NULL; PFNGLPIXELTRANSFERIPROC glad_glPixelTransferi = NULL; PFNGLPIXELZOOMPROC glad_glPixelZoom = NULL; PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL; PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL; PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL; PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL; PFNGLPOINTSIZEPROC glad_glPointSize = NULL; PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL; PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL; PFNGLPOLYGONSTIPPLEPROC glad_glPolygonStipple = NULL; PFNGLPOPATTRIBPROC glad_glPopAttrib = NULL; PFNGLPOPCLIENTATTRIBPROC glad_glPopClientAttrib = NULL; PFNGLPOPMATRIXPROC glad_glPopMatrix = NULL; PFNGLPOPNAMEPROC glad_glPopName = NULL; PFNGLPRIORITIZETEXTURESPROC glad_glPrioritizeTextures = NULL; PFNGLPROGRAMENVPARAMETER4DARBPROC glad_glProgramEnvParameter4dARB = NULL; PFNGLPROGRAMENVPARAMETER4DVARBPROC glad_glProgramEnvParameter4dvARB = NULL; PFNGLPROGRAMENVPARAMETER4FARBPROC glad_glProgramEnvParameter4fARB = NULL; PFNGLPROGRAMENVPARAMETER4FVARBPROC glad_glProgramEnvParameter4fvARB = NULL; PFNGLPROGRAMLOCALPARAMETER4DARBPROC glad_glProgramLocalParameter4dARB = NULL; PFNGLPROGRAMLOCALPARAMETER4DVARBPROC glad_glProgramLocalParameter4dvARB = NULL; PFNGLPROGRAMLOCALPARAMETER4FARBPROC glad_glProgramLocalParameter4fARB = NULL; PFNGLPROGRAMLOCALPARAMETER4FVARBPROC glad_glProgramLocalParameter4fvARB = NULL; PFNGLPROGRAMSTRINGARBPROC glad_glProgramStringARB = NULL; PFNGLPUSHATTRIBPROC glad_glPushAttrib = NULL; PFNGLPUSHCLIENTATTRIBPROC glad_glPushClientAttrib = NULL; PFNGLPUSHMATRIXPROC glad_glPushMatrix = NULL; PFNGLPUSHNAMEPROC glad_glPushName = NULL; PFNGLRASTERPOS2DPROC glad_glRasterPos2d = NULL; PFNGLRASTERPOS2DVPROC glad_glRasterPos2dv = NULL; PFNGLRASTERPOS2FPROC glad_glRasterPos2f = NULL; PFNGLRASTERPOS2FVPROC glad_glRasterPos2fv = NULL; PFNGLRASTERPOS2IPROC glad_glRasterPos2i = NULL; PFNGLRASTERPOS2IVPROC glad_glRasterPos2iv = NULL; PFNGLRASTERPOS2SPROC glad_glRasterPos2s = NULL; PFNGLRASTERPOS2SVPROC glad_glRasterPos2sv = NULL; PFNGLRASTERPOS3DPROC glad_glRasterPos3d = NULL; PFNGLRASTERPOS3DVPROC glad_glRasterPos3dv = NULL; PFNGLRASTERPOS3FPROC glad_glRasterPos3f = NULL; PFNGLRASTERPOS3FVPROC glad_glRasterPos3fv = NULL; PFNGLRASTERPOS3IPROC glad_glRasterPos3i = NULL; PFNGLRASTERPOS3IVPROC glad_glRasterPos3iv = NULL; PFNGLRASTERPOS3SPROC glad_glRasterPos3s = NULL; PFNGLRASTERPOS3SVPROC glad_glRasterPos3sv = NULL; PFNGLRASTERPOS4DPROC glad_glRasterPos4d = NULL; PFNGLRASTERPOS4DVPROC glad_glRasterPos4dv = NULL; PFNGLRASTERPOS4FPROC glad_glRasterPos4f = NULL; PFNGLRASTERPOS4FVPROC glad_glRasterPos4fv = NULL; PFNGLRASTERPOS4IPROC glad_glRasterPos4i = NULL; PFNGLRASTERPOS4IVPROC glad_glRasterPos4iv = NULL; PFNGLRASTERPOS4SPROC glad_glRasterPos4s = NULL; PFNGLRASTERPOS4SVPROC glad_glRasterPos4sv = NULL; PFNGLREADBUFFERPROC glad_glReadBuffer = NULL; PFNGLREADPIXELSPROC glad_glReadPixels = NULL; PFNGLRECTDPROC glad_glRectd = NULL; PFNGLRECTDVPROC glad_glRectdv = NULL; PFNGLRECTFPROC glad_glRectf = NULL; PFNGLRECTFVPROC glad_glRectfv = NULL; PFNGLRECTIPROC glad_glRecti = NULL; PFNGLRECTIVPROC glad_glRectiv = NULL; PFNGLRECTSPROC glad_glRects = NULL; PFNGLRECTSVPROC glad_glRectsv = NULL; PFNGLRENDERMODEPROC glad_glRenderMode = NULL; PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL; PFNGLRENDERBUFFERSTORAGEEXTPROC glad_glRenderbufferStorageEXT = NULL; PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL; PFNGLROTATEDPROC glad_glRotated = NULL; PFNGLROTATEFPROC glad_glRotatef = NULL; PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL; PFNGLSCALEDPROC glad_glScaled = NULL; PFNGLSCALEFPROC glad_glScalef = NULL; PFNGLSCISSORPROC glad_glScissor = NULL; PFNGLSECONDARYCOLOR3BPROC glad_glSecondaryColor3b = NULL; PFNGLSECONDARYCOLOR3BVPROC glad_glSecondaryColor3bv = NULL; PFNGLSECONDARYCOLOR3DPROC glad_glSecondaryColor3d = NULL; PFNGLSECONDARYCOLOR3DVPROC glad_glSecondaryColor3dv = NULL; PFNGLSECONDARYCOLOR3FPROC glad_glSecondaryColor3f = NULL; PFNGLSECONDARYCOLOR3FVPROC glad_glSecondaryColor3fv = NULL; PFNGLSECONDARYCOLOR3IPROC glad_glSecondaryColor3i = NULL; PFNGLSECONDARYCOLOR3IVPROC glad_glSecondaryColor3iv = NULL; PFNGLSECONDARYCOLOR3SPROC glad_glSecondaryColor3s = NULL; PFNGLSECONDARYCOLOR3SVPROC glad_glSecondaryColor3sv = NULL; PFNGLSECONDARYCOLOR3UBPROC glad_glSecondaryColor3ub = NULL; PFNGLSECONDARYCOLOR3UBVPROC glad_glSecondaryColor3ubv = NULL; PFNGLSECONDARYCOLOR3UIPROC glad_glSecondaryColor3ui = NULL; PFNGLSECONDARYCOLOR3UIVPROC glad_glSecondaryColor3uiv = NULL; PFNGLSECONDARYCOLOR3USPROC glad_glSecondaryColor3us = NULL; PFNGLSECONDARYCOLOR3USVPROC glad_glSecondaryColor3usv = NULL; PFNGLSECONDARYCOLORPOINTERPROC glad_glSecondaryColorPointer = NULL; PFNGLSELECTBUFFERPROC glad_glSelectBuffer = NULL; PFNGLSHADEMODELPROC glad_glShadeModel = NULL; PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL; PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL; PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL; PFNGLSTENCILMASKPROC glad_glStencilMask = NULL; PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL; PFNGLSTENCILOPPROC glad_glStencilOp = NULL; PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL; PFNGLTEXCOORD1DPROC glad_glTexCoord1d = NULL; PFNGLTEXCOORD1DVPROC glad_glTexCoord1dv = NULL; PFNGLTEXCOORD1FPROC glad_glTexCoord1f = NULL; PFNGLTEXCOORD1FVPROC glad_glTexCoord1fv = NULL; PFNGLTEXCOORD1IPROC glad_glTexCoord1i = NULL; PFNGLTEXCOORD1IVPROC glad_glTexCoord1iv = NULL; PFNGLTEXCOORD1SPROC glad_glTexCoord1s = NULL; PFNGLTEXCOORD1SVPROC glad_glTexCoord1sv = NULL; PFNGLTEXCOORD2DPROC glad_glTexCoord2d = NULL; PFNGLTEXCOORD2DVPROC glad_glTexCoord2dv = NULL; PFNGLTEXCOORD2FPROC glad_glTexCoord2f = NULL; PFNGLTEXCOORD2FVPROC glad_glTexCoord2fv = NULL; PFNGLTEXCOORD2IPROC glad_glTexCoord2i = NULL; PFNGLTEXCOORD2IVPROC glad_glTexCoord2iv = NULL; PFNGLTEXCOORD2SPROC glad_glTexCoord2s = NULL; PFNGLTEXCOORD2SVPROC glad_glTexCoord2sv = NULL; PFNGLTEXCOORD3DPROC glad_glTexCoord3d = NULL; PFNGLTEXCOORD3DVPROC glad_glTexCoord3dv = NULL; PFNGLTEXCOORD3FPROC glad_glTexCoord3f = NULL; PFNGLTEXCOORD3FVPROC glad_glTexCoord3fv = NULL; PFNGLTEXCOORD3IPROC glad_glTexCoord3i = NULL; PFNGLTEXCOORD3IVPROC glad_glTexCoord3iv = NULL; PFNGLTEXCOORD3SPROC glad_glTexCoord3s = NULL; PFNGLTEXCOORD3SVPROC glad_glTexCoord3sv = NULL; PFNGLTEXCOORD4DPROC glad_glTexCoord4d = NULL; PFNGLTEXCOORD4DVPROC glad_glTexCoord4dv = NULL; PFNGLTEXCOORD4FPROC glad_glTexCoord4f = NULL; PFNGLTEXCOORD4FVPROC glad_glTexCoord4fv = NULL; PFNGLTEXCOORD4IPROC glad_glTexCoord4i = NULL; PFNGLTEXCOORD4IVPROC glad_glTexCoord4iv = NULL; PFNGLTEXCOORD4SPROC glad_glTexCoord4s = NULL; PFNGLTEXCOORD4SVPROC glad_glTexCoord4sv = NULL; PFNGLTEXCOORDPOINTERPROC glad_glTexCoordPointer = NULL; PFNGLTEXENVFPROC glad_glTexEnvf = NULL; PFNGLTEXENVFVPROC glad_glTexEnvfv = NULL; PFNGLTEXENVIPROC glad_glTexEnvi = NULL; PFNGLTEXENVIVPROC glad_glTexEnviv = NULL; PFNGLTEXGENDPROC glad_glTexGend = NULL; PFNGLTEXGENDVPROC glad_glTexGendv = NULL; PFNGLTEXGENFPROC glad_glTexGenf = NULL; PFNGLTEXGENFVPROC glad_glTexGenfv = NULL; PFNGLTEXGENIPROC glad_glTexGeni = NULL; PFNGLTEXGENIVPROC glad_glTexGeniv = NULL; PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL; PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL; PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL; PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL; PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL; PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL; PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL; PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL; PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL; PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL; PFNGLTRANSLATEDPROC glad_glTranslated = NULL; PFNGLTRANSLATEFPROC glad_glTranslatef = NULL; PFNGLUNIFORM1FPROC glad_glUniform1f = NULL; PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL; PFNGLUNIFORM1IPROC glad_glUniform1i = NULL; PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL; PFNGLUNIFORM2FPROC glad_glUniform2f = NULL; PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL; PFNGLUNIFORM2IPROC glad_glUniform2i = NULL; PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL; PFNGLUNIFORM3FPROC glad_glUniform3f = NULL; PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL; PFNGLUNIFORM3IPROC glad_glUniform3i = NULL; PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL; PFNGLUNIFORM4FPROC glad_glUniform4f = NULL; PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL; PFNGLUNIFORM4IPROC glad_glUniform4i = NULL; PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL; PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL; PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL; PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL; PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL; PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL; PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL; PFNGLVERTEX2DPROC glad_glVertex2d = NULL; PFNGLVERTEX2DVPROC glad_glVertex2dv = NULL; PFNGLVERTEX2FPROC glad_glVertex2f = NULL; PFNGLVERTEX2FVPROC glad_glVertex2fv = NULL; PFNGLVERTEX2IPROC glad_glVertex2i = NULL; PFNGLVERTEX2IVPROC glad_glVertex2iv = NULL; PFNGLVERTEX2SPROC glad_glVertex2s = NULL; PFNGLVERTEX2SVPROC glad_glVertex2sv = NULL; PFNGLVERTEX3DPROC glad_glVertex3d = NULL; PFNGLVERTEX3DVPROC glad_glVertex3dv = NULL; PFNGLVERTEX3FPROC glad_glVertex3f = NULL; PFNGLVERTEX3FVPROC glad_glVertex3fv = NULL; PFNGLVERTEX3IPROC glad_glVertex3i = NULL; PFNGLVERTEX3IVPROC glad_glVertex3iv = NULL; PFNGLVERTEX3SPROC glad_glVertex3s = NULL; PFNGLVERTEX3SVPROC glad_glVertex3sv = NULL; PFNGLVERTEX4DPROC glad_glVertex4d = NULL; PFNGLVERTEX4DVPROC glad_glVertex4dv = NULL; PFNGLVERTEX4FPROC glad_glVertex4f = NULL; PFNGLVERTEX4FVPROC glad_glVertex4fv = NULL; PFNGLVERTEX4IPROC glad_glVertex4i = NULL; PFNGLVERTEX4IVPROC glad_glVertex4iv = NULL; PFNGLVERTEX4SPROC glad_glVertex4s = NULL; PFNGLVERTEX4SVPROC glad_glVertex4sv = NULL; PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL; PFNGLVERTEXATTRIB1DARBPROC glad_glVertexAttrib1dARB = NULL; PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL; PFNGLVERTEXATTRIB1DVARBPROC glad_glVertexAttrib1dvARB = NULL; PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL; PFNGLVERTEXATTRIB1FARBPROC glad_glVertexAttrib1fARB = NULL; PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL; PFNGLVERTEXATTRIB1FVARBPROC glad_glVertexAttrib1fvARB = NULL; PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL; PFNGLVERTEXATTRIB1SARBPROC glad_glVertexAttrib1sARB = NULL; PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL; PFNGLVERTEXATTRIB1SVARBPROC glad_glVertexAttrib1svARB = NULL; PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL; PFNGLVERTEXATTRIB2DARBPROC glad_glVertexAttrib2dARB = NULL; PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL; PFNGLVERTEXATTRIB2DVARBPROC glad_glVertexAttrib2dvARB = NULL; PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL; PFNGLVERTEXATTRIB2FARBPROC glad_glVertexAttrib2fARB = NULL; PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL; PFNGLVERTEXATTRIB2FVARBPROC glad_glVertexAttrib2fvARB = NULL; PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL; PFNGLVERTEXATTRIB2SARBPROC glad_glVertexAttrib2sARB = NULL; PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL; PFNGLVERTEXATTRIB2SVARBPROC glad_glVertexAttrib2svARB = NULL; PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL; PFNGLVERTEXATTRIB3DARBPROC glad_glVertexAttrib3dARB = NULL; PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL; PFNGLVERTEXATTRIB3DVARBPROC glad_glVertexAttrib3dvARB = NULL; PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL; PFNGLVERTEXATTRIB3FARBPROC glad_glVertexAttrib3fARB = NULL; PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL; PFNGLVERTEXATTRIB3FVARBPROC glad_glVertexAttrib3fvARB = NULL; PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL; PFNGLVERTEXATTRIB3SARBPROC glad_glVertexAttrib3sARB = NULL; PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL; PFNGLVERTEXATTRIB3SVARBPROC glad_glVertexAttrib3svARB = NULL; PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL; PFNGLVERTEXATTRIB4NBVARBPROC glad_glVertexAttrib4NbvARB = NULL; PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL; PFNGLVERTEXATTRIB4NIVARBPROC glad_glVertexAttrib4NivARB = NULL; PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL; PFNGLVERTEXATTRIB4NSVARBPROC glad_glVertexAttrib4NsvARB = NULL; PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL; PFNGLVERTEXATTRIB4NUBARBPROC glad_glVertexAttrib4NubARB = NULL; PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL; PFNGLVERTEXATTRIB4NUBVARBPROC glad_glVertexAttrib4NubvARB = NULL; PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL; PFNGLVERTEXATTRIB4NUIVARBPROC glad_glVertexAttrib4NuivARB = NULL; PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL; PFNGLVERTEXATTRIB4NUSVARBPROC glad_glVertexAttrib4NusvARB = NULL; PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL; PFNGLVERTEXATTRIB4BVARBPROC glad_glVertexAttrib4bvARB = NULL; PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL; PFNGLVERTEXATTRIB4DARBPROC glad_glVertexAttrib4dARB = NULL; PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL; PFNGLVERTEXATTRIB4DVARBPROC glad_glVertexAttrib4dvARB = NULL; PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL; PFNGLVERTEXATTRIB4FARBPROC glad_glVertexAttrib4fARB = NULL; PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL; PFNGLVERTEXATTRIB4FVARBPROC glad_glVertexAttrib4fvARB = NULL; PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL; PFNGLVERTEXATTRIB4IVARBPROC glad_glVertexAttrib4ivARB = NULL; PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL; PFNGLVERTEXATTRIB4SARBPROC glad_glVertexAttrib4sARB = NULL; PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL; PFNGLVERTEXATTRIB4SVARBPROC glad_glVertexAttrib4svARB = NULL; PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL; PFNGLVERTEXATTRIB4UBVARBPROC glad_glVertexAttrib4ubvARB = NULL; PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL; PFNGLVERTEXATTRIB4UIVARBPROC glad_glVertexAttrib4uivARB = NULL; PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL; PFNGLVERTEXATTRIB4USVARBPROC glad_glVertexAttrib4usvARB = NULL; PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL; PFNGLVERTEXATTRIBPOINTERARBPROC glad_glVertexAttribPointerARB = NULL; PFNGLVERTEXPOINTERPROC glad_glVertexPointer = NULL; PFNGLVIEWPORTPROC glad_glViewport = NULL; PFNGLWINDOWPOS2DPROC glad_glWindowPos2d = NULL; PFNGLWINDOWPOS2DVPROC glad_glWindowPos2dv = NULL; PFNGLWINDOWPOS2FPROC glad_glWindowPos2f = NULL; PFNGLWINDOWPOS2FVPROC glad_glWindowPos2fv = NULL; PFNGLWINDOWPOS2IPROC glad_glWindowPos2i = NULL; PFNGLWINDOWPOS2IVPROC glad_glWindowPos2iv = NULL; PFNGLWINDOWPOS2SPROC glad_glWindowPos2s = NULL; PFNGLWINDOWPOS2SVPROC glad_glWindowPos2sv = NULL; PFNGLWINDOWPOS3DPROC glad_glWindowPos3d = NULL; PFNGLWINDOWPOS3DVPROC glad_glWindowPos3dv = NULL; PFNGLWINDOWPOS3FPROC glad_glWindowPos3f = NULL; PFNGLWINDOWPOS3FVPROC glad_glWindowPos3fv = NULL; PFNGLWINDOWPOS3IPROC glad_glWindowPos3i = NULL; PFNGLWINDOWPOS3IVPROC glad_glWindowPos3iv = NULL; PFNGLWINDOWPOS3SPROC glad_glWindowPos3s = NULL; PFNGLWINDOWPOS3SVPROC glad_glWindowPos3sv = NULL; static void glad_gl_load_GL_VERSION_1_0( GLADuserptrloadfunc load, void* userptr) { if(!GLAD_GL_VERSION_1_0) return; glad_glAccum = (PFNGLACCUMPROC) load(userptr, "glAccum"); glad_glAlphaFunc = (PFNGLALPHAFUNCPROC) load(userptr, "glAlphaFunc"); glad_glBegin = (PFNGLBEGINPROC) load(userptr, "glBegin"); glad_glBitmap = (PFNGLBITMAPPROC) load(userptr, "glBitmap"); glad_glBlendFunc = (PFNGLBLENDFUNCPROC) load(userptr, "glBlendFunc"); glad_glCallList = (PFNGLCALLLISTPROC) load(userptr, "glCallList"); glad_glCallLists = (PFNGLCALLLISTSPROC) load(userptr, "glCallLists"); glad_glClear = (PFNGLCLEARPROC) load(userptr, "glClear"); glad_glClearAccum = (PFNGLCLEARACCUMPROC) load(userptr, "glClearAccum"); glad_glClearColor = (PFNGLCLEARCOLORPROC) load(userptr, "glClearColor"); glad_glClearDepth = (PFNGLCLEARDEPTHPROC) load(userptr, "glClearDepth"); glad_glClearIndex = (PFNGLCLEARINDEXPROC) load(userptr, "glClearIndex"); glad_glClearStencil = (PFNGLCLEARSTENCILPROC) load(userptr, "glClearStencil"); glad_glClipPlane = (PFNGLCLIPPLANEPROC) load(userptr, "glClipPlane"); glad_glColor3b = (PFNGLCOLOR3BPROC) load(userptr, "glColor3b"); glad_glColor3bv = (PFNGLCOLOR3BVPROC) load(userptr, "glColor3bv"); glad_glColor3d = (PFNGLCOLOR3DPROC) load(userptr, "glColor3d"); glad_glColor3dv = (PFNGLCOLOR3DVPROC) load(userptr, "glColor3dv"); glad_glColor3f = (PFNGLCOLOR3FPROC) load(userptr, "glColor3f"); glad_glColor3fv = (PFNGLCOLOR3FVPROC) load(userptr, "glColor3fv"); glad_glColor3i = (PFNGLCOLOR3IPROC) load(userptr, "glColor3i"); glad_glColor3iv = (PFNGLCOLOR3IVPROC) load(userptr, "glColor3iv"); glad_glColor3s = (PFNGLCOLOR3SPROC) load(userptr, "glColor3s"); glad_glColor3sv = (PFNGLCOLOR3SVPROC) load(userptr, "glColor3sv"); glad_glColor3ub = (PFNGLCOLOR3UBPROC) load(userptr, "glColor3ub"); glad_glColor3ubv = (PFNGLCOLOR3UBVPROC) load(userptr, "glColor3ubv"); glad_glColor3ui = (PFNGLCOLOR3UIPROC) load(userptr, "glColor3ui"); glad_glColor3uiv = (PFNGLCOLOR3UIVPROC) load(userptr, "glColor3uiv"); glad_glColor3us = (PFNGLCOLOR3USPROC) load(userptr, "glColor3us"); glad_glColor3usv = (PFNGLCOLOR3USVPROC) load(userptr, "glColor3usv"); glad_glColor4b = (PFNGLCOLOR4BPROC) load(userptr, "glColor4b"); glad_glColor4bv = (PFNGLCOLOR4BVPROC) load(userptr, "glColor4bv"); glad_glColor4d = (PFNGLCOLOR4DPROC) load(userptr, "glColor4d"); glad_glColor4dv = (PFNGLCOLOR4DVPROC) load(userptr, "glColor4dv"); glad_glColor4f = (PFNGLCOLOR4FPROC) load(userptr, "glColor4f"); glad_glColor4fv = (PFNGLCOLOR4FVPROC) load(userptr, "glColor4fv"); glad_glColor4i = (PFNGLCOLOR4IPROC) load(userptr, "glColor4i"); glad_glColor4iv = (PFNGLCOLOR4IVPROC) load(userptr, "glColor4iv"); glad_glColor4s = (PFNGLCOLOR4SPROC) load(userptr, "glColor4s"); glad_glColor4sv = (PFNGLCOLOR4SVPROC) load(userptr, "glColor4sv"); glad_glColor4ub = (PFNGLCOLOR4UBPROC) load(userptr, "glColor4ub"); glad_glColor4ubv = (PFNGLCOLOR4UBVPROC) load(userptr, "glColor4ubv"); glad_glColor4ui = (PFNGLCOLOR4UIPROC) load(userptr, "glColor4ui"); glad_glColor4uiv = (PFNGLCOLOR4UIVPROC) load(userptr, "glColor4uiv"); glad_glColor4us = (PFNGLCOLOR4USPROC) load(userptr, "glColor4us"); glad_glColor4usv = (PFNGLCOLOR4USVPROC) load(userptr, "glColor4usv"); glad_glColorMask = (PFNGLCOLORMASKPROC) load(userptr, "glColorMask"); glad_glColorMaterial = (PFNGLCOLORMATERIALPROC) load(userptr, "glColorMaterial"); glad_glCopyPixels = (PFNGLCOPYPIXELSPROC) load(userptr, "glCopyPixels"); glad_glCullFace = (PFNGLCULLFACEPROC) load(userptr, "glCullFace"); glad_glDeleteLists = (PFNGLDELETELISTSPROC) load(userptr, "glDeleteLists"); glad_glDepthFunc = (PFNGLDEPTHFUNCPROC) load(userptr, "glDepthFunc"); glad_glDepthMask = (PFNGLDEPTHMASKPROC) load(userptr, "glDepthMask"); glad_glDepthRange = (PFNGLDEPTHRANGEPROC) load(userptr, "glDepthRange"); glad_glDisable = (PFNGLDISABLEPROC) load(userptr, "glDisable"); glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC) load(userptr, "glDrawBuffer"); glad_glDrawPixels = (PFNGLDRAWPIXELSPROC) load(userptr, "glDrawPixels"); glad_glEdgeFlag = (PFNGLEDGEFLAGPROC) load(userptr, "glEdgeFlag"); glad_glEdgeFlagv = (PFNGLEDGEFLAGVPROC) load(userptr, "glEdgeFlagv"); glad_glEnable = (PFNGLENABLEPROC) load(userptr, "glEnable"); glad_glEnd = (PFNGLENDPROC) load(userptr, "glEnd"); glad_glEndList = (PFNGLENDLISTPROC) load(userptr, "glEndList"); glad_glEvalCoord1d = (PFNGLEVALCOORD1DPROC) load(userptr, "glEvalCoord1d"); glad_glEvalCoord1dv = (PFNGLEVALCOORD1DVPROC) load(userptr, "glEvalCoord1dv"); glad_glEvalCoord1f = (PFNGLEVALCOORD1FPROC) load(userptr, "glEvalCoord1f"); glad_glEvalCoord1fv = (PFNGLEVALCOORD1FVPROC) load(userptr, "glEvalCoord1fv"); glad_glEvalCoord2d = (PFNGLEVALCOORD2DPROC) load(userptr, "glEvalCoord2d"); glad_glEvalCoord2dv = (PFNGLEVALCOORD2DVPROC) load(userptr, "glEvalCoord2dv"); glad_glEvalCoord2f = (PFNGLEVALCOORD2FPROC) load(userptr, "glEvalCoord2f"); glad_glEvalCoord2fv = (PFNGLEVALCOORD2FVPROC) load(userptr, "glEvalCoord2fv"); glad_glEvalMesh1 = (PFNGLEVALMESH1PROC) load(userptr, "glEvalMesh1"); glad_glEvalMesh2 = (PFNGLEVALMESH2PROC) load(userptr, "glEvalMesh2"); glad_glEvalPoint1 = (PFNGLEVALPOINT1PROC) load(userptr, "glEvalPoint1"); glad_glEvalPoint2 = (PFNGLEVALPOINT2PROC) load(userptr, "glEvalPoint2"); glad_glFeedbackBuffer = (PFNGLFEEDBACKBUFFERPROC) load(userptr, "glFeedbackBuffer"); glad_glFinish = (PFNGLFINISHPROC) load(userptr, "glFinish"); glad_glFlush = (PFNGLFLUSHPROC) load(userptr, "glFlush"); glad_glFogf = (PFNGLFOGFPROC) load(userptr, "glFogf"); glad_glFogfv = (PFNGLFOGFVPROC) load(userptr, "glFogfv"); glad_glFogi = (PFNGLFOGIPROC) load(userptr, "glFogi"); glad_glFogiv = (PFNGLFOGIVPROC) load(userptr, "glFogiv"); glad_glFrontFace = (PFNGLFRONTFACEPROC) load(userptr, "glFrontFace"); glad_glFrustum = (PFNGLFRUSTUMPROC) load(userptr, "glFrustum"); glad_glGenLists = (PFNGLGENLISTSPROC) load(userptr, "glGenLists"); glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC) load(userptr, "glGetBooleanv"); glad_glGetClipPlane = (PFNGLGETCLIPPLANEPROC) load(userptr, "glGetClipPlane"); glad_glGetDoublev = (PFNGLGETDOUBLEVPROC) load(userptr, "glGetDoublev"); glad_glGetError = (PFNGLGETERRORPROC) load(userptr, "glGetError"); glad_glGetFloatv = (PFNGLGETFLOATVPROC) load(userptr, "glGetFloatv"); glad_glGetIntegerv = (PFNGLGETINTEGERVPROC) load(userptr, "glGetIntegerv"); glad_glGetLightfv = (PFNGLGETLIGHTFVPROC) load(userptr, "glGetLightfv"); glad_glGetLightiv = (PFNGLGETLIGHTIVPROC) load(userptr, "glGetLightiv"); glad_glGetMapdv = (PFNGLGETMAPDVPROC) load(userptr, "glGetMapdv"); glad_glGetMapfv = (PFNGLGETMAPFVPROC) load(userptr, "glGetMapfv"); glad_glGetMapiv = (PFNGLGETMAPIVPROC) load(userptr, "glGetMapiv"); glad_glGetMaterialfv = (PFNGLGETMATERIALFVPROC) load(userptr, "glGetMaterialfv"); glad_glGetMaterialiv = (PFNGLGETMATERIALIVPROC) load(userptr, "glGetMaterialiv"); glad_glGetPixelMapfv = (PFNGLGETPIXELMAPFVPROC) load(userptr, "glGetPixelMapfv"); glad_glGetPixelMapuiv = (PFNGLGETPIXELMAPUIVPROC) load(userptr, "glGetPixelMapuiv"); glad_glGetPixelMapusv = (PFNGLGETPIXELMAPUSVPROC) load(userptr, "glGetPixelMapusv"); glad_glGetPolygonStipple = (PFNGLGETPOLYGONSTIPPLEPROC) load(userptr, "glGetPolygonStipple"); glad_glGetString = (PFNGLGETSTRINGPROC) load(userptr, "glGetString"); glad_glGetTexEnvfv = (PFNGLGETTEXENVFVPROC) load(userptr, "glGetTexEnvfv"); glad_glGetTexEnviv = (PFNGLGETTEXENVIVPROC) load(userptr, "glGetTexEnviv"); glad_glGetTexGendv = (PFNGLGETTEXGENDVPROC) load(userptr, "glGetTexGendv"); glad_glGetTexGenfv = (PFNGLGETTEXGENFVPROC) load(userptr, "glGetTexGenfv"); glad_glGetTexGeniv = (PFNGLGETTEXGENIVPROC) load(userptr, "glGetTexGeniv"); glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC) load(userptr, "glGetTexImage"); glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC) load(userptr, "glGetTexLevelParameterfv"); glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC) load(userptr, "glGetTexLevelParameteriv"); glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC) load(userptr, "glGetTexParameterfv"); glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC) load(userptr, "glGetTexParameteriv"); glad_glHint = (PFNGLHINTPROC) load(userptr, "glHint"); glad_glIndexMask = (PFNGLINDEXMASKPROC) load(userptr, "glIndexMask"); glad_glIndexd = (PFNGLINDEXDPROC) load(userptr, "glIndexd"); glad_glIndexdv = (PFNGLINDEXDVPROC) load(userptr, "glIndexdv"); glad_glIndexf = (PFNGLINDEXFPROC) load(userptr, "glIndexf"); glad_glIndexfv = (PFNGLINDEXFVPROC) load(userptr, "glIndexfv"); glad_glIndexi = (PFNGLINDEXIPROC) load(userptr, "glIndexi"); glad_glIndexiv = (PFNGLINDEXIVPROC) load(userptr, "glIndexiv"); glad_glIndexs = (PFNGLINDEXSPROC) load(userptr, "glIndexs"); glad_glIndexsv = (PFNGLINDEXSVPROC) load(userptr, "glIndexsv"); glad_glInitNames = (PFNGLINITNAMESPROC) load(userptr, "glInitNames"); glad_glIsEnabled = (PFNGLISENABLEDPROC) load(userptr, "glIsEnabled"); glad_glIsList = (PFNGLISLISTPROC) load(userptr, "glIsList"); glad_glLightModelf = (PFNGLLIGHTMODELFPROC) load(userptr, "glLightModelf"); glad_glLightModelfv = (PFNGLLIGHTMODELFVPROC) load(userptr, "glLightModelfv"); glad_glLightModeli = (PFNGLLIGHTMODELIPROC) load(userptr, "glLightModeli"); glad_glLightModeliv = (PFNGLLIGHTMODELIVPROC) load(userptr, "glLightModeliv"); glad_glLightf = (PFNGLLIGHTFPROC) load(userptr, "glLightf"); glad_glLightfv = (PFNGLLIGHTFVPROC) load(userptr, "glLightfv"); glad_glLighti = (PFNGLLIGHTIPROC) load(userptr, "glLighti"); glad_glLightiv = (PFNGLLIGHTIVPROC) load(userptr, "glLightiv"); glad_glLineStipple = (PFNGLLINESTIPPLEPROC) load(userptr, "glLineStipple"); glad_glLineWidth = (PFNGLLINEWIDTHPROC) load(userptr, "glLineWidth"); glad_glListBase = (PFNGLLISTBASEPROC) load(userptr, "glListBase"); glad_glLoadIdentity = (PFNGLLOADIDENTITYPROC) load(userptr, "glLoadIdentity"); glad_glLoadMatrixd = (PFNGLLOADMATRIXDPROC) load(userptr, "glLoadMatrixd"); glad_glLoadMatrixf = (PFNGLLOADMATRIXFPROC) load(userptr, "glLoadMatrixf"); glad_glLoadName = (PFNGLLOADNAMEPROC) load(userptr, "glLoadName"); glad_glLogicOp = (PFNGLLOGICOPPROC) load(userptr, "glLogicOp"); glad_glMap1d = (PFNGLMAP1DPROC) load(userptr, "glMap1d"); glad_glMap1f = (PFNGLMAP1FPROC) load(userptr, "glMap1f"); glad_glMap2d = (PFNGLMAP2DPROC) load(userptr, "glMap2d"); glad_glMap2f = (PFNGLMAP2FPROC) load(userptr, "glMap2f"); glad_glMapGrid1d = (PFNGLMAPGRID1DPROC) load(userptr, "glMapGrid1d"); glad_glMapGrid1f = (PFNGLMAPGRID1FPROC) load(userptr, "glMapGrid1f"); glad_glMapGrid2d = (PFNGLMAPGRID2DPROC) load(userptr, "glMapGrid2d"); glad_glMapGrid2f = (PFNGLMAPGRID2FPROC) load(userptr, "glMapGrid2f"); glad_glMaterialf = (PFNGLMATERIALFPROC) load(userptr, "glMaterialf"); glad_glMaterialfv = (PFNGLMATERIALFVPROC) load(userptr, "glMaterialfv"); glad_glMateriali = (PFNGLMATERIALIPROC) load(userptr, "glMateriali"); glad_glMaterialiv = (PFNGLMATERIALIVPROC) load(userptr, "glMaterialiv"); glad_glMatrixMode = (PFNGLMATRIXMODEPROC) load(userptr, "glMatrixMode"); glad_glMultMatrixd = (PFNGLMULTMATRIXDPROC) load(userptr, "glMultMatrixd"); glad_glMultMatrixf = (PFNGLMULTMATRIXFPROC) load(userptr, "glMultMatrixf"); glad_glNewList = (PFNGLNEWLISTPROC) load(userptr, "glNewList"); glad_glNormal3b = (PFNGLNORMAL3BPROC) load(userptr, "glNormal3b"); glad_glNormal3bv = (PFNGLNORMAL3BVPROC) load(userptr, "glNormal3bv"); glad_glNormal3d = (PFNGLNORMAL3DPROC) load(userptr, "glNormal3d"); glad_glNormal3dv = (PFNGLNORMAL3DVPROC) load(userptr, "glNormal3dv"); glad_glNormal3f = (PFNGLNORMAL3FPROC) load(userptr, "glNormal3f"); glad_glNormal3fv = (PFNGLNORMAL3FVPROC) load(userptr, "glNormal3fv"); glad_glNormal3i = (PFNGLNORMAL3IPROC) load(userptr, "glNormal3i"); glad_glNormal3iv = (PFNGLNORMAL3IVPROC) load(userptr, "glNormal3iv"); glad_glNormal3s = (PFNGLNORMAL3SPROC) load(userptr, "glNormal3s"); glad_glNormal3sv = (PFNGLNORMAL3SVPROC) load(userptr, "glNormal3sv"); glad_glOrtho = (PFNGLORTHOPROC) load(userptr, "glOrtho"); glad_glPassThrough = (PFNGLPASSTHROUGHPROC) load(userptr, "glPassThrough"); glad_glPixelMapfv = (PFNGLPIXELMAPFVPROC) load(userptr, "glPixelMapfv"); glad_glPixelMapuiv = (PFNGLPIXELMAPUIVPROC) load(userptr, "glPixelMapuiv"); glad_glPixelMapusv = (PFNGLPIXELMAPUSVPROC) load(userptr, "glPixelMapusv"); glad_glPixelStoref = (PFNGLPIXELSTOREFPROC) load(userptr, "glPixelStoref"); glad_glPixelStorei = (PFNGLPIXELSTOREIPROC) load(userptr, "glPixelStorei"); glad_glPixelTransferf = (PFNGLPIXELTRANSFERFPROC) load(userptr, "glPixelTransferf"); glad_glPixelTransferi = (PFNGLPIXELTRANSFERIPROC) load(userptr, "glPixelTransferi"); glad_glPixelZoom = (PFNGLPIXELZOOMPROC) load(userptr, "glPixelZoom"); glad_glPointSize = (PFNGLPOINTSIZEPROC) load(userptr, "glPointSize"); glad_glPolygonMode = (PFNGLPOLYGONMODEPROC) load(userptr, "glPolygonMode"); glad_glPolygonStipple = (PFNGLPOLYGONSTIPPLEPROC) load(userptr, "glPolygonStipple"); glad_glPopAttrib = (PFNGLPOPATTRIBPROC) load(userptr, "glPopAttrib"); glad_glPopMatrix = (PFNGLPOPMATRIXPROC) load(userptr, "glPopMatrix"); glad_glPopName = (PFNGLPOPNAMEPROC) load(userptr, "glPopName"); glad_glPushAttrib = (PFNGLPUSHATTRIBPROC) load(userptr, "glPushAttrib"); glad_glPushMatrix = (PFNGLPUSHMATRIXPROC) load(userptr, "glPushMatrix"); glad_glPushName = (PFNGLPUSHNAMEPROC) load(userptr, "glPushName"); glad_glRasterPos2d = (PFNGLRASTERPOS2DPROC) load(userptr, "glRasterPos2d"); glad_glRasterPos2dv = (PFNGLRASTERPOS2DVPROC) load(userptr, "glRasterPos2dv"); glad_glRasterPos2f = (PFNGLRASTERPOS2FPROC) load(userptr, "glRasterPos2f"); glad_glRasterPos2fv = (PFNGLRASTERPOS2FVPROC) load(userptr, "glRasterPos2fv"); glad_glRasterPos2i = (PFNGLRASTERPOS2IPROC) load(userptr, "glRasterPos2i"); glad_glRasterPos2iv = (PFNGLRASTERPOS2IVPROC) load(userptr, "glRasterPos2iv"); glad_glRasterPos2s = (PFNGLRASTERPOS2SPROC) load(userptr, "glRasterPos2s"); glad_glRasterPos2sv = (PFNGLRASTERPOS2SVPROC) load(userptr, "glRasterPos2sv"); glad_glRasterPos3d = (PFNGLRASTERPOS3DPROC) load(userptr, "glRasterPos3d"); glad_glRasterPos3dv = (PFNGLRASTERPOS3DVPROC) load(userptr, "glRasterPos3dv"); glad_glRasterPos3f = (PFNGLRASTERPOS3FPROC) load(userptr, "glRasterPos3f"); glad_glRasterPos3fv = (PFNGLRASTERPOS3FVPROC) load(userptr, "glRasterPos3fv"); glad_glRasterPos3i = (PFNGLRASTERPOS3IPROC) load(userptr, "glRasterPos3i"); glad_glRasterPos3iv = (PFNGLRASTERPOS3IVPROC) load(userptr, "glRasterPos3iv"); glad_glRasterPos3s = (PFNGLRASTERPOS3SPROC) load(userptr, "glRasterPos3s"); glad_glRasterPos3sv = (PFNGLRASTERPOS3SVPROC) load(userptr, "glRasterPos3sv"); glad_glRasterPos4d = (PFNGLRASTERPOS4DPROC) load(userptr, "glRasterPos4d"); glad_glRasterPos4dv = (PFNGLRASTERPOS4DVPROC) load(userptr, "glRasterPos4dv"); glad_glRasterPos4f = (PFNGLRASTERPOS4FPROC) load(userptr, "glRasterPos4f"); glad_glRasterPos4fv = (PFNGLRASTERPOS4FVPROC) load(userptr, "glRasterPos4fv"); glad_glRasterPos4i = (PFNGLRASTERPOS4IPROC) load(userptr, "glRasterPos4i"); glad_glRasterPos4iv = (PFNGLRASTERPOS4IVPROC) load(userptr, "glRasterPos4iv"); glad_glRasterPos4s = (PFNGLRASTERPOS4SPROC) load(userptr, "glRasterPos4s"); glad_glRasterPos4sv = (PFNGLRASTERPOS4SVPROC) load(userptr, "glRasterPos4sv"); glad_glReadBuffer = (PFNGLREADBUFFERPROC) load(userptr, "glReadBuffer"); glad_glReadPixels = (PFNGLREADPIXELSPROC) load(userptr, "glReadPixels"); glad_glRectd = (PFNGLRECTDPROC) load(userptr, "glRectd"); glad_glRectdv = (PFNGLRECTDVPROC) load(userptr, "glRectdv"); glad_glRectf = (PFNGLRECTFPROC) load(userptr, "glRectf"); glad_glRectfv = (PFNGLRECTFVPROC) load(userptr, "glRectfv"); glad_glRecti = (PFNGLRECTIPROC) load(userptr, "glRecti"); glad_glRectiv = (PFNGLRECTIVPROC) load(userptr, "glRectiv"); glad_glRects = (PFNGLRECTSPROC) load(userptr, "glRects"); glad_glRectsv = (PFNGLRECTSVPROC) load(userptr, "glRectsv"); glad_glRenderMode = (PFNGLRENDERMODEPROC) load(userptr, "glRenderMode"); glad_glRotated = (PFNGLROTATEDPROC) load(userptr, "glRotated"); glad_glRotatef = (PFNGLROTATEFPROC) load(userptr, "glRotatef"); glad_glScaled = (PFNGLSCALEDPROC) load(userptr, "glScaled"); glad_glScalef = (PFNGLSCALEFPROC) load(userptr, "glScalef"); glad_glScissor = (PFNGLSCISSORPROC) load(userptr, "glScissor"); glad_glSelectBuffer = (PFNGLSELECTBUFFERPROC) load(userptr, "glSelectBuffer"); glad_glShadeModel = (PFNGLSHADEMODELPROC) load(userptr, "glShadeModel"); glad_glStencilFunc = (PFNGLSTENCILFUNCPROC) load(userptr, "glStencilFunc"); glad_glStencilMask = (PFNGLSTENCILMASKPROC) load(userptr, "glStencilMask"); glad_glStencilOp = (PFNGLSTENCILOPPROC) load(userptr, "glStencilOp"); glad_glTexCoord1d = (PFNGLTEXCOORD1DPROC) load(userptr, "glTexCoord1d"); glad_glTexCoord1dv = (PFNGLTEXCOORD1DVPROC) load(userptr, "glTexCoord1dv"); glad_glTexCoord1f = (PFNGLTEXCOORD1FPROC) load(userptr, "glTexCoord1f"); glad_glTexCoord1fv = (PFNGLTEXCOORD1FVPROC) load(userptr, "glTexCoord1fv"); glad_glTexCoord1i = (PFNGLTEXCOORD1IPROC) load(userptr, "glTexCoord1i"); glad_glTexCoord1iv = (PFNGLTEXCOORD1IVPROC) load(userptr, "glTexCoord1iv"); glad_glTexCoord1s = (PFNGLTEXCOORD1SPROC) load(userptr, "glTexCoord1s"); glad_glTexCoord1sv = (PFNGLTEXCOORD1SVPROC) load(userptr, "glTexCoord1sv"); glad_glTexCoord2d = (PFNGLTEXCOORD2DPROC) load(userptr, "glTexCoord2d"); glad_glTexCoord2dv = (PFNGLTEXCOORD2DVPROC) load(userptr, "glTexCoord2dv"); glad_glTexCoord2f = (PFNGLTEXCOORD2FPROC) load(userptr, "glTexCoord2f"); glad_glTexCoord2fv = (PFNGLTEXCOORD2FVPROC) load(userptr, "glTexCoord2fv"); glad_glTexCoord2i = (PFNGLTEXCOORD2IPROC) load(userptr, "glTexCoord2i"); glad_glTexCoord2iv = (PFNGLTEXCOORD2IVPROC) load(userptr, "glTexCoord2iv"); glad_glTexCoord2s = (PFNGLTEXCOORD2SPROC) load(userptr, "glTexCoord2s"); glad_glTexCoord2sv = (PFNGLTEXCOORD2SVPROC) load(userptr, "glTexCoord2sv"); glad_glTexCoord3d = (PFNGLTEXCOORD3DPROC) load(userptr, "glTexCoord3d"); glad_glTexCoord3dv = (PFNGLTEXCOORD3DVPROC) load(userptr, "glTexCoord3dv"); glad_glTexCoord3f = (PFNGLTEXCOORD3FPROC) load(userptr, "glTexCoord3f"); glad_glTexCoord3fv = (PFNGLTEXCOORD3FVPROC) load(userptr, "glTexCoord3fv"); glad_glTexCoord3i = (PFNGLTEXCOORD3IPROC) load(userptr, "glTexCoord3i"); glad_glTexCoord3iv = (PFNGLTEXCOORD3IVPROC) load(userptr, "glTexCoord3iv"); glad_glTexCoord3s = (PFNGLTEXCOORD3SPROC) load(userptr, "glTexCoord3s"); glad_glTexCoord3sv = (PFNGLTEXCOORD3SVPROC) load(userptr, "glTexCoord3sv"); glad_glTexCoord4d = (PFNGLTEXCOORD4DPROC) load(userptr, "glTexCoord4d"); glad_glTexCoord4dv = (PFNGLTEXCOORD4DVPROC) load(userptr, "glTexCoord4dv"); glad_glTexCoord4f = (PFNGLTEXCOORD4FPROC) load(userptr, "glTexCoord4f"); glad_glTexCoord4fv = (PFNGLTEXCOORD4FVPROC) load(userptr, "glTexCoord4fv"); glad_glTexCoord4i = (PFNGLTEXCOORD4IPROC) load(userptr, "glTexCoord4i"); glad_glTexCoord4iv = (PFNGLTEXCOORD4IVPROC) load(userptr, "glTexCoord4iv"); glad_glTexCoord4s = (PFNGLTEXCOORD4SPROC) load(userptr, "glTexCoord4s"); glad_glTexCoord4sv = (PFNGLTEXCOORD4SVPROC) load(userptr, "glTexCoord4sv"); glad_glTexEnvf = (PFNGLTEXENVFPROC) load(userptr, "glTexEnvf"); glad_glTexEnvfv = (PFNGLTEXENVFVPROC) load(userptr, "glTexEnvfv"); glad_glTexEnvi = (PFNGLTEXENVIPROC) load(userptr, "glTexEnvi"); glad_glTexEnviv = (PFNGLTEXENVIVPROC) load(userptr, "glTexEnviv"); glad_glTexGend = (PFNGLTEXGENDPROC) load(userptr, "glTexGend"); glad_glTexGendv = (PFNGLTEXGENDVPROC) load(userptr, "glTexGendv"); glad_glTexGenf = (PFNGLTEXGENFPROC) load(userptr, "glTexGenf"); glad_glTexGenfv = (PFNGLTEXGENFVPROC) load(userptr, "glTexGenfv"); glad_glTexGeni = (PFNGLTEXGENIPROC) load(userptr, "glTexGeni"); glad_glTexGeniv = (PFNGLTEXGENIVPROC) load(userptr, "glTexGeniv"); glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC) load(userptr, "glTexImage1D"); glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC) load(userptr, "glTexImage2D"); glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC) load(userptr, "glTexParameterf"); glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC) load(userptr, "glTexParameterfv"); glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC) load(userptr, "glTexParameteri"); glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC) load(userptr, "glTexParameteriv"); glad_glTranslated = (PFNGLTRANSLATEDPROC) load(userptr, "glTranslated"); glad_glTranslatef = (PFNGLTRANSLATEFPROC) load(userptr, "glTranslatef"); glad_glVertex2d = (PFNGLVERTEX2DPROC) load(userptr, "glVertex2d"); glad_glVertex2dv = (PFNGLVERTEX2DVPROC) load(userptr, "glVertex2dv"); glad_glVertex2f = (PFNGLVERTEX2FPROC) load(userptr, "glVertex2f"); glad_glVertex2fv = (PFNGLVERTEX2FVPROC) load(userptr, "glVertex2fv"); glad_glVertex2i = (PFNGLVERTEX2IPROC) load(userptr, "glVertex2i"); glad_glVertex2iv = (PFNGLVERTEX2IVPROC) load(userptr, "glVertex2iv"); glad_glVertex2s = (PFNGLVERTEX2SPROC) load(userptr, "glVertex2s"); glad_glVertex2sv = (PFNGLVERTEX2SVPROC) load(userptr, "glVertex2sv"); glad_glVertex3d = (PFNGLVERTEX3DPROC) load(userptr, "glVertex3d"); glad_glVertex3dv = (PFNGLVERTEX3DVPROC) load(userptr, "glVertex3dv"); glad_glVertex3f = (PFNGLVERTEX3FPROC) load(userptr, "glVertex3f"); glad_glVertex3fv = (PFNGLVERTEX3FVPROC) load(userptr, "glVertex3fv"); glad_glVertex3i = (PFNGLVERTEX3IPROC) load(userptr, "glVertex3i"); glad_glVertex3iv = (PFNGLVERTEX3IVPROC) load(userptr, "glVertex3iv"); glad_glVertex3s = (PFNGLVERTEX3SPROC) load(userptr, "glVertex3s"); glad_glVertex3sv = (PFNGLVERTEX3SVPROC) load(userptr, "glVertex3sv"); glad_glVertex4d = (PFNGLVERTEX4DPROC) load(userptr, "glVertex4d"); glad_glVertex4dv = (PFNGLVERTEX4DVPROC) load(userptr, "glVertex4dv"); glad_glVertex4f = (PFNGLVERTEX4FPROC) load(userptr, "glVertex4f"); glad_glVertex4fv = (PFNGLVERTEX4FVPROC) load(userptr, "glVertex4fv"); glad_glVertex4i = (PFNGLVERTEX4IPROC) load(userptr, "glVertex4i"); glad_glVertex4iv = (PFNGLVERTEX4IVPROC) load(userptr, "glVertex4iv"); glad_glVertex4s = (PFNGLVERTEX4SPROC) load(userptr, "glVertex4s"); glad_glVertex4sv = (PFNGLVERTEX4SVPROC) load(userptr, "glVertex4sv"); glad_glViewport = (PFNGLVIEWPORTPROC) load(userptr, "glViewport"); } static void glad_gl_load_GL_VERSION_1_1( GLADuserptrloadfunc load, void* userptr) { if(!GLAD_GL_VERSION_1_1) return; glad_glAreTexturesResident = (PFNGLARETEXTURESRESIDENTPROC) load(userptr, "glAreTexturesResident"); glad_glArrayElement = (PFNGLARRAYELEMENTPROC) load(userptr, "glArrayElement"); glad_glBindTexture = (PFNGLBINDTEXTUREPROC) load(userptr, "glBindTexture"); glad_glColorPointer = (PFNGLCOLORPOINTERPROC) load(userptr, "glColorPointer"); glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC) load(userptr, "glCopyTexImage1D"); glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC) load(userptr, "glCopyTexImage2D"); glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC) load(userptr, "glCopyTexSubImage1D"); glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC) load(userptr, "glCopyTexSubImage2D"); glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC) load(userptr, "glDeleteTextures"); glad_glDisableClientState = (PFNGLDISABLECLIENTSTATEPROC) load(userptr, "glDisableClientState"); glad_glDrawArrays = (PFNGLDRAWARRAYSPROC) load(userptr, "glDrawArrays"); glad_glDrawElements = (PFNGLDRAWELEMENTSPROC) load(userptr, "glDrawElements"); glad_glEdgeFlagPointer = (PFNGLEDGEFLAGPOINTERPROC) load(userptr, "glEdgeFlagPointer"); glad_glEnableClientState = (PFNGLENABLECLIENTSTATEPROC) load(userptr, "glEnableClientState"); glad_glGenTextures = (PFNGLGENTEXTURESPROC) load(userptr, "glGenTextures"); glad_glGetPointerv = (PFNGLGETPOINTERVPROC) load(userptr, "glGetPointerv"); glad_glIndexPointer = (PFNGLINDEXPOINTERPROC) load(userptr, "glIndexPointer"); glad_glIndexub = (PFNGLINDEXUBPROC) load(userptr, "glIndexub"); glad_glIndexubv = (PFNGLINDEXUBVPROC) load(userptr, "glIndexubv"); glad_glInterleavedArrays = (PFNGLINTERLEAVEDARRAYSPROC) load(userptr, "glInterleavedArrays"); glad_glIsTexture = (PFNGLISTEXTUREPROC) load(userptr, "glIsTexture"); glad_glNormalPointer = (PFNGLNORMALPOINTERPROC) load(userptr, "glNormalPointer"); glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC) load(userptr, "glPolygonOffset"); glad_glPopClientAttrib = (PFNGLPOPCLIENTATTRIBPROC) load(userptr, "glPopClientAttrib"); glad_glPrioritizeTextures = (PFNGLPRIORITIZETEXTURESPROC) load(userptr, "glPrioritizeTextures"); glad_glPushClientAttrib = (PFNGLPUSHCLIENTATTRIBPROC) load(userptr, "glPushClientAttrib"); glad_glTexCoordPointer = (PFNGLTEXCOORDPOINTERPROC) load(userptr, "glTexCoordPointer"); glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC) load(userptr, "glTexSubImage1D"); glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC) load(userptr, "glTexSubImage2D"); glad_glVertexPointer = (PFNGLVERTEXPOINTERPROC) load(userptr, "glVertexPointer"); } static void glad_gl_load_GL_VERSION_1_2( GLADuserptrloadfunc load, void* userptr) { if(!GLAD_GL_VERSION_1_2) return; glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC) load(userptr, "glCopyTexSubImage3D"); glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC) load(userptr, "glDrawRangeElements"); glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC) load(userptr, "glTexImage3D"); glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC) load(userptr, "glTexSubImage3D"); } static void glad_gl_load_GL_VERSION_1_3( GLADuserptrloadfunc load, void* userptr) { if(!GLAD_GL_VERSION_1_3) return; glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC) load(userptr, "glActiveTexture"); glad_glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC) load(userptr, "glClientActiveTexture"); glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC) load(userptr, "glCompressedTexImage1D"); glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC) load(userptr, "glCompressedTexImage2D"); glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC) load(userptr, "glCompressedTexImage3D"); glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC) load(userptr, "glCompressedTexSubImage1D"); glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) load(userptr, "glCompressedTexSubImage2D"); glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC) load(userptr, "glCompressedTexSubImage3D"); glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC) load(userptr, "glGetCompressedTexImage"); glad_glLoadTransposeMatrixd = (PFNGLLOADTRANSPOSEMATRIXDPROC) load(userptr, "glLoadTransposeMatrixd"); glad_glLoadTransposeMatrixf = (PFNGLLOADTRANSPOSEMATRIXFPROC) load(userptr, "glLoadTransposeMatrixf"); glad_glMultTransposeMatrixd = (PFNGLMULTTRANSPOSEMATRIXDPROC) load(userptr, "glMultTransposeMatrixd"); glad_glMultTransposeMatrixf = (PFNGLMULTTRANSPOSEMATRIXFPROC) load(userptr, "glMultTransposeMatrixf"); glad_glMultiTexCoord1d = (PFNGLMULTITEXCOORD1DPROC) load(userptr, "glMultiTexCoord1d"); glad_glMultiTexCoord1dv = (PFNGLMULTITEXCOORD1DVPROC) load(userptr, "glMultiTexCoord1dv"); glad_glMultiTexCoord1f = (PFNGLMULTITEXCOORD1FPROC) load(userptr, "glMultiTexCoord1f"); glad_glMultiTexCoord1fv = (PFNGLMULTITEXCOORD1FVPROC) load(userptr, "glMultiTexCoord1fv"); glad_glMultiTexCoord1i = (PFNGLMULTITEXCOORD1IPROC) load(userptr, "glMultiTexCoord1i"); glad_glMultiTexCoord1iv = (PFNGLMULTITEXCOORD1IVPROC) load(userptr, "glMultiTexCoord1iv"); glad_glMultiTexCoord1s = (PFNGLMULTITEXCOORD1SPROC) load(userptr, "glMultiTexCoord1s"); glad_glMultiTexCoord1sv = (PFNGLMULTITEXCOORD1SVPROC) load(userptr, "glMultiTexCoord1sv"); glad_glMultiTexCoord2d = (PFNGLMULTITEXCOORD2DPROC) load(userptr, "glMultiTexCoord2d"); glad_glMultiTexCoord2dv = (PFNGLMULTITEXCOORD2DVPROC) load(userptr, "glMultiTexCoord2dv"); glad_glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC) load(userptr, "glMultiTexCoord2f"); glad_glMultiTexCoord2fv = (PFNGLMULTITEXCOORD2FVPROC) load(userptr, "glMultiTexCoord2fv"); glad_glMultiTexCoord2i = (PFNGLMULTITEXCOORD2IPROC) load(userptr, "glMultiTexCoord2i"); glad_glMultiTexCoord2iv = (PFNGLMULTITEXCOORD2IVPROC) load(userptr, "glMultiTexCoord2iv"); glad_glMultiTexCoord2s = (PFNGLMULTITEXCOORD2SPROC) load(userptr, "glMultiTexCoord2s"); glad_glMultiTexCoord2sv = (PFNGLMULTITEXCOORD2SVPROC) load(userptr, "glMultiTexCoord2sv"); glad_glMultiTexCoord3d = (PFNGLMULTITEXCOORD3DPROC) load(userptr, "glMultiTexCoord3d"); glad_glMultiTexCoord3dv = (PFNGLMULTITEXCOORD3DVPROC) load(userptr, "glMultiTexCoord3dv"); glad_glMultiTexCoord3f = (PFNGLMULTITEXCOORD3FPROC) load(userptr, "glMultiTexCoord3f"); glad_glMultiTexCoord3fv = (PFNGLMULTITEXCOORD3FVPROC) load(userptr, "glMultiTexCoord3fv"); glad_glMultiTexCoord3i = (PFNGLMULTITEXCOORD3IPROC) load(userptr, "glMultiTexCoord3i"); glad_glMultiTexCoord3iv = (PFNGLMULTITEXCOORD3IVPROC) load(userptr, "glMultiTexCoord3iv"); glad_glMultiTexCoord3s = (PFNGLMULTITEXCOORD3SPROC) load(userptr, "glMultiTexCoord3s"); glad_glMultiTexCoord3sv = (PFNGLMULTITEXCOORD3SVPROC) load(userptr, "glMultiTexCoord3sv"); glad_glMultiTexCoord4d = (PFNGLMULTITEXCOORD4DPROC) load(userptr, "glMultiTexCoord4d"); glad_glMultiTexCoord4dv = (PFNGLMULTITEXCOORD4DVPROC) load(userptr, "glMultiTexCoord4dv"); glad_glMultiTexCoord4f = (PFNGLMULTITEXCOORD4FPROC) load(userptr, "glMultiTexCoord4f"); glad_glMultiTexCoord4fv = (PFNGLMULTITEXCOORD4FVPROC) load(userptr, "glMultiTexCoord4fv"); glad_glMultiTexCoord4i = (PFNGLMULTITEXCOORD4IPROC) load(userptr, "glMultiTexCoord4i"); glad_glMultiTexCoord4iv = (PFNGLMULTITEXCOORD4IVPROC) load(userptr, "glMultiTexCoord4iv"); glad_glMultiTexCoord4s = (PFNGLMULTITEXCOORD4SPROC) load(userptr, "glMultiTexCoord4s"); glad_glMultiTexCoord4sv = (PFNGLMULTITEXCOORD4SVPROC) load(userptr, "glMultiTexCoord4sv"); glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC) load(userptr, "glSampleCoverage"); } static void glad_gl_load_GL_VERSION_1_4( GLADuserptrloadfunc load, void* userptr) { if(!GLAD_GL_VERSION_1_4) return; glad_glBlendColor = (PFNGLBLENDCOLORPROC) load(userptr, "glBlendColor"); glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC) load(userptr, "glBlendEquation"); glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC) load(userptr, "glBlendFuncSeparate"); glad_glFogCoordPointer = (PFNGLFOGCOORDPOINTERPROC) load(userptr, "glFogCoordPointer"); glad_glFogCoordd = (PFNGLFOGCOORDDPROC) load(userptr, "glFogCoordd"); glad_glFogCoorddv = (PFNGLFOGCOORDDVPROC) load(userptr, "glFogCoorddv"); glad_glFogCoordf = (PFNGLFOGCOORDFPROC) load(userptr, "glFogCoordf"); glad_glFogCoordfv = (PFNGLFOGCOORDFVPROC) load(userptr, "glFogCoordfv"); glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC) load(userptr, "glMultiDrawArrays"); glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC) load(userptr, "glMultiDrawElements"); glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC) load(userptr, "glPointParameterf"); glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC) load(userptr, "glPointParameterfv"); glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC) load(userptr, "glPointParameteri"); glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC) load(userptr, "glPointParameteriv"); glad_glSecondaryColor3b = (PFNGLSECONDARYCOLOR3BPROC) load(userptr, "glSecondaryColor3b"); glad_glSecondaryColor3bv = (PFNGLSECONDARYCOLOR3BVPROC) load(userptr, "glSecondaryColor3bv"); glad_glSecondaryColor3d = (PFNGLSECONDARYCOLOR3DPROC) load(userptr, "glSecondaryColor3d"); glad_glSecondaryColor3dv = (PFNGLSECONDARYCOLOR3DVPROC) load(userptr, "glSecondaryColor3dv"); glad_glSecondaryColor3f = (PFNGLSECONDARYCOLOR3FPROC) load(userptr, "glSecondaryColor3f"); glad_glSecondaryColor3fv = (PFNGLSECONDARYCOLOR3FVPROC) load(userptr, "glSecondaryColor3fv"); glad_glSecondaryColor3i = (PFNGLSECONDARYCOLOR3IPROC) load(userptr, "glSecondaryColor3i"); glad_glSecondaryColor3iv = (PFNGLSECONDARYCOLOR3IVPROC) load(userptr, "glSecondaryColor3iv"); glad_glSecondaryColor3s = (PFNGLSECONDARYCOLOR3SPROC) load(userptr, "glSecondaryColor3s"); glad_glSecondaryColor3sv = (PFNGLSECONDARYCOLOR3SVPROC) load(userptr, "glSecondaryColor3sv"); glad_glSecondaryColor3ub = (PFNGLSECONDARYCOLOR3UBPROC) load(userptr, "glSecondaryColor3ub"); glad_glSecondaryColor3ubv = (PFNGLSECONDARYCOLOR3UBVPROC) load(userptr, "glSecondaryColor3ubv"); glad_glSecondaryColor3ui = (PFNGLSECONDARYCOLOR3UIPROC) load(userptr, "glSecondaryColor3ui"); glad_glSecondaryColor3uiv = (PFNGLSECONDARYCOLOR3UIVPROC) load(userptr, "glSecondaryColor3uiv"); glad_glSecondaryColor3us = (PFNGLSECONDARYCOLOR3USPROC) load(userptr, "glSecondaryColor3us"); glad_glSecondaryColor3usv = (PFNGLSECONDARYCOLOR3USVPROC) load(userptr, "glSecondaryColor3usv"); glad_glSecondaryColorPointer = (PFNGLSECONDARYCOLORPOINTERPROC) load(userptr, "glSecondaryColorPointer"); glad_glWindowPos2d = (PFNGLWINDOWPOS2DPROC) load(userptr, "glWindowPos2d"); glad_glWindowPos2dv = (PFNGLWINDOWPOS2DVPROC) load(userptr, "glWindowPos2dv"); glad_glWindowPos2f = (PFNGLWINDOWPOS2FPROC) load(userptr, "glWindowPos2f"); glad_glWindowPos2fv = (PFNGLWINDOWPOS2FVPROC) load(userptr, "glWindowPos2fv"); glad_glWindowPos2i = (PFNGLWINDOWPOS2IPROC) load(userptr, "glWindowPos2i"); glad_glWindowPos2iv = (PFNGLWINDOWPOS2IVPROC) load(userptr, "glWindowPos2iv"); glad_glWindowPos2s = (PFNGLWINDOWPOS2SPROC) load(userptr, "glWindowPos2s"); glad_glWindowPos2sv = (PFNGLWINDOWPOS2SVPROC) load(userptr, "glWindowPos2sv"); glad_glWindowPos3d = (PFNGLWINDOWPOS3DPROC) load(userptr, "glWindowPos3d"); glad_glWindowPos3dv = (PFNGLWINDOWPOS3DVPROC) load(userptr, "glWindowPos3dv"); glad_glWindowPos3f = (PFNGLWINDOWPOS3FPROC) load(userptr, "glWindowPos3f"); glad_glWindowPos3fv = (PFNGLWINDOWPOS3FVPROC) load(userptr, "glWindowPos3fv"); glad_glWindowPos3i = (PFNGLWINDOWPOS3IPROC) load(userptr, "glWindowPos3i"); glad_glWindowPos3iv = (PFNGLWINDOWPOS3IVPROC) load(userptr, "glWindowPos3iv"); glad_glWindowPos3s = (PFNGLWINDOWPOS3SPROC) load(userptr, "glWindowPos3s"); glad_glWindowPos3sv = (PFNGLWINDOWPOS3SVPROC) load(userptr, "glWindowPos3sv"); } static void glad_gl_load_GL_VERSION_1_5( GLADuserptrloadfunc load, void* userptr) { if(!GLAD_GL_VERSION_1_5) return; glad_glBeginQuery = (PFNGLBEGINQUERYPROC) load(userptr, "glBeginQuery"); glad_glBindBuffer = (PFNGLBINDBUFFERPROC) load(userptr, "glBindBuffer"); glad_glBufferData = (PFNGLBUFFERDATAPROC) load(userptr, "glBufferData"); glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC) load(userptr, "glBufferSubData"); glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC) load(userptr, "glDeleteBuffers"); glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC) load(userptr, "glDeleteQueries"); glad_glEndQuery = (PFNGLENDQUERYPROC) load(userptr, "glEndQuery"); glad_glGenBuffers = (PFNGLGENBUFFERSPROC) load(userptr, "glGenBuffers"); glad_glGenQueries = (PFNGLGENQUERIESPROC) load(userptr, "glGenQueries"); glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC) load(userptr, "glGetBufferParameteriv"); glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC) load(userptr, "glGetBufferPointerv"); glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC) load(userptr, "glGetBufferSubData"); glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC) load(userptr, "glGetQueryObjectiv"); glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC) load(userptr, "glGetQueryObjectuiv"); glad_glGetQueryiv = (PFNGLGETQUERYIVPROC) load(userptr, "glGetQueryiv"); glad_glIsBuffer = (PFNGLISBUFFERPROC) load(userptr, "glIsBuffer"); glad_glIsQuery = (PFNGLISQUERYPROC) load(userptr, "glIsQuery"); glad_glMapBuffer = (PFNGLMAPBUFFERPROC) load(userptr, "glMapBuffer"); glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC) load(userptr, "glUnmapBuffer"); } static void glad_gl_load_GL_VERSION_2_0( GLADuserptrloadfunc load, void* userptr) { if(!GLAD_GL_VERSION_2_0) return; glad_glAttachShader = (PFNGLATTACHSHADERPROC) load(userptr, "glAttachShader"); glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC) load(userptr, "glBindAttribLocation"); glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC) load(userptr, "glBlendEquationSeparate"); glad_glCompileShader = (PFNGLCOMPILESHADERPROC) load(userptr, "glCompileShader"); glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC) load(userptr, "glCreateProgram"); glad_glCreateShader = (PFNGLCREATESHADERPROC) load(userptr, "glCreateShader"); glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC) load(userptr, "glDeleteProgram"); glad_glDeleteShader = (PFNGLDELETESHADERPROC) load(userptr, "glDeleteShader"); glad_glDetachShader = (PFNGLDETACHSHADERPROC) load(userptr, "glDetachShader"); glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC) load(userptr, "glDisableVertexAttribArray"); glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC) load(userptr, "glDrawBuffers"); glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC) load(userptr, "glEnableVertexAttribArray"); glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC) load(userptr, "glGetActiveAttrib"); glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC) load(userptr, "glGetActiveUniform"); glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC) load(userptr, "glGetAttachedShaders"); glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC) load(userptr, "glGetAttribLocation"); glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC) load(userptr, "glGetProgramInfoLog"); glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC) load(userptr, "glGetProgramiv"); glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC) load(userptr, "glGetShaderInfoLog"); glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC) load(userptr, "glGetShaderSource"); glad_glGetShaderiv = (PFNGLGETSHADERIVPROC) load(userptr, "glGetShaderiv"); glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC) load(userptr, "glGetUniformLocation"); glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC) load(userptr, "glGetUniformfv"); glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC) load(userptr, "glGetUniformiv"); glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC) load(userptr, "glGetVertexAttribPointerv"); glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC) load(userptr, "glGetVertexAttribdv"); glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC) load(userptr, "glGetVertexAttribfv"); glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC) load(userptr, "glGetVertexAttribiv"); glad_glIsProgram = (PFNGLISPROGRAMPROC) load(userptr, "glIsProgram"); glad_glIsShader = (PFNGLISSHADERPROC) load(userptr, "glIsShader"); glad_glLinkProgram = (PFNGLLINKPROGRAMPROC) load(userptr, "glLinkProgram"); glad_glShaderSource = (PFNGLSHADERSOURCEPROC) load(userptr, "glShaderSource"); glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC) load(userptr, "glStencilFuncSeparate"); glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC) load(userptr, "glStencilMaskSeparate"); glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC) load(userptr, "glStencilOpSeparate"); glad_glUniform1f = (PFNGLUNIFORM1FPROC) load(userptr, "glUniform1f"); glad_glUniform1fv = (PFNGLUNIFORM1FVPROC) load(userptr, "glUniform1fv"); glad_glUniform1i = (PFNGLUNIFORM1IPROC) load(userptr, "glUniform1i"); glad_glUniform1iv = (PFNGLUNIFORM1IVPROC) load(userptr, "glUniform1iv"); glad_glUniform2f = (PFNGLUNIFORM2FPROC) load(userptr, "glUniform2f"); glad_glUniform2fv = (PFNGLUNIFORM2FVPROC) load(userptr, "glUniform2fv"); glad_glUniform2i = (PFNGLUNIFORM2IPROC) load(userptr, "glUniform2i"); glad_glUniform2iv = (PFNGLUNIFORM2IVPROC) load(userptr, "glUniform2iv"); glad_glUniform3f = (PFNGLUNIFORM3FPROC) load(userptr, "glUniform3f"); glad_glUniform3fv = (PFNGLUNIFORM3FVPROC) load(userptr, "glUniform3fv"); glad_glUniform3i = (PFNGLUNIFORM3IPROC) load(userptr, "glUniform3i"); glad_glUniform3iv = (PFNGLUNIFORM3IVPROC) load(userptr, "glUniform3iv"); glad_glUniform4f = (PFNGLUNIFORM4FPROC) load(userptr, "glUniform4f"); glad_glUniform4fv = (PFNGLUNIFORM4FVPROC) load(userptr, "glUniform4fv"); glad_glUniform4i = (PFNGLUNIFORM4IPROC) load(userptr, "glUniform4i"); glad_glUniform4iv = (PFNGLUNIFORM4IVPROC) load(userptr, "glUniform4iv"); glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC) load(userptr, "glUniformMatrix2fv"); glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC) load(userptr, "glUniformMatrix3fv"); glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC) load(userptr, "glUniformMatrix4fv"); glad_glUseProgram = (PFNGLUSEPROGRAMPROC) load(userptr, "glUseProgram"); glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC) load(userptr, "glValidateProgram"); glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC) load(userptr, "glVertexAttrib1d"); glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC) load(userptr, "glVertexAttrib1dv"); glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC) load(userptr, "glVertexAttrib1f"); glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC) load(userptr, "glVertexAttrib1fv"); glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC) load(userptr, "glVertexAttrib1s"); glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC) load(userptr, "glVertexAttrib1sv"); glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC) load(userptr, "glVertexAttrib2d"); glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC) load(userptr, "glVertexAttrib2dv"); glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC) load(userptr, "glVertexAttrib2f"); glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC) load(userptr, "glVertexAttrib2fv"); glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC) load(userptr, "glVertexAttrib2s"); glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC) load(userptr, "glVertexAttrib2sv"); glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC) load(userptr, "glVertexAttrib3d"); glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC) load(userptr, "glVertexAttrib3dv"); glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC) load(userptr, "glVertexAttrib3f"); glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC) load(userptr, "glVertexAttrib3fv"); glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC) load(userptr, "glVertexAttrib3s"); glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC) load(userptr, "glVertexAttrib3sv"); glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC) load(userptr, "glVertexAttrib4Nbv"); glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC) load(userptr, "glVertexAttrib4Niv"); glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC) load(userptr, "glVertexAttrib4Nsv"); glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC) load(userptr, "glVertexAttrib4Nub"); glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC) load(userptr, "glVertexAttrib4Nubv"); glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC) load(userptr, "glVertexAttrib4Nuiv"); glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC) load(userptr, "glVertexAttrib4Nusv"); glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC) load(userptr, "glVertexAttrib4bv"); glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC) load(userptr, "glVertexAttrib4d"); glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC) load(userptr, "glVertexAttrib4dv"); glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC) load(userptr, "glVertexAttrib4f"); glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC) load(userptr, "glVertexAttrib4fv"); glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC) load(userptr, "glVertexAttrib4iv"); glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC) load(userptr, "glVertexAttrib4s"); glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC) load(userptr, "glVertexAttrib4sv"); glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC) load(userptr, "glVertexAttrib4ubv"); glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC) load(userptr, "glVertexAttrib4uiv"); glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC) load(userptr, "glVertexAttrib4usv"); glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC) load(userptr, "glVertexAttribPointer"); } static void glad_gl_load_GL_ARB_fragment_program( GLADuserptrloadfunc load, void* userptr) { if(!GLAD_GL_ARB_fragment_program) return; glad_glBindProgramARB = (PFNGLBINDPROGRAMARBPROC) load(userptr, "glBindProgramARB"); glad_glDeleteProgramsARB = (PFNGLDELETEPROGRAMSARBPROC) load(userptr, "glDeleteProgramsARB"); glad_glGenProgramsARB = (PFNGLGENPROGRAMSARBPROC) load(userptr, "glGenProgramsARB"); glad_glGetProgramEnvParameterdvARB = (PFNGLGETPROGRAMENVPARAMETERDVARBPROC) load(userptr, "glGetProgramEnvParameterdvARB"); glad_glGetProgramEnvParameterfvARB = (PFNGLGETPROGRAMENVPARAMETERFVARBPROC) load(userptr, "glGetProgramEnvParameterfvARB"); glad_glGetProgramLocalParameterdvARB = (PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) load(userptr, "glGetProgramLocalParameterdvARB"); glad_glGetProgramLocalParameterfvARB = (PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) load(userptr, "glGetProgramLocalParameterfvARB"); glad_glGetProgramStringARB = (PFNGLGETPROGRAMSTRINGARBPROC) load(userptr, "glGetProgramStringARB"); glad_glGetProgramivARB = (PFNGLGETPROGRAMIVARBPROC) load(userptr, "glGetProgramivARB"); glad_glIsProgramARB = (PFNGLISPROGRAMARBPROC) load(userptr, "glIsProgramARB"); glad_glProgramEnvParameter4dARB = (PFNGLPROGRAMENVPARAMETER4DARBPROC) load(userptr, "glProgramEnvParameter4dARB"); glad_glProgramEnvParameter4dvARB = (PFNGLPROGRAMENVPARAMETER4DVARBPROC) load(userptr, "glProgramEnvParameter4dvARB"); glad_glProgramEnvParameter4fARB = (PFNGLPROGRAMENVPARAMETER4FARBPROC) load(userptr, "glProgramEnvParameter4fARB"); glad_glProgramEnvParameter4fvARB = (PFNGLPROGRAMENVPARAMETER4FVARBPROC) load(userptr, "glProgramEnvParameter4fvARB"); glad_glProgramLocalParameter4dARB = (PFNGLPROGRAMLOCALPARAMETER4DARBPROC) load(userptr, "glProgramLocalParameter4dARB"); glad_glProgramLocalParameter4dvARB = (PFNGLPROGRAMLOCALPARAMETER4DVARBPROC) load(userptr, "glProgramLocalParameter4dvARB"); glad_glProgramLocalParameter4fARB = (PFNGLPROGRAMLOCALPARAMETER4FARBPROC) load(userptr, "glProgramLocalParameter4fARB"); glad_glProgramLocalParameter4fvARB = (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC) load(userptr, "glProgramLocalParameter4fvARB"); glad_glProgramStringARB = (PFNGLPROGRAMSTRINGARBPROC) load(userptr, "glProgramStringARB"); } static void glad_gl_load_GL_ARB_framebuffer_object( GLADuserptrloadfunc load, void* userptr) { if(!GLAD_GL_ARB_framebuffer_object) return; glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC) load(userptr, "glBindFramebuffer"); glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC) load(userptr, "glBindRenderbuffer"); glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC) load(userptr, "glBlitFramebuffer"); glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC) load(userptr, "glCheckFramebufferStatus"); glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC) load(userptr, "glDeleteFramebuffers"); glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC) load(userptr, "glDeleteRenderbuffers"); glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC) load(userptr, "glFramebufferRenderbuffer"); glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC) load(userptr, "glFramebufferTexture1D"); glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC) load(userptr, "glFramebufferTexture2D"); glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC) load(userptr, "glFramebufferTexture3D"); glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC) load(userptr, "glFramebufferTextureLayer"); glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC) load(userptr, "glGenFramebuffers"); glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC) load(userptr, "glGenRenderbuffers"); glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC) load(userptr, "glGenerateMipmap"); glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC) load(userptr, "glGetFramebufferAttachmentParameteriv"); glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC) load(userptr, "glGetRenderbufferParameteriv"); glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC) load(userptr, "glIsFramebuffer"); glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC) load(userptr, "glIsRenderbuffer"); glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC) load(userptr, "glRenderbufferStorage"); glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC) load(userptr, "glRenderbufferStorageMultisample"); } static void glad_gl_load_GL_ARB_occlusion_query( GLADuserptrloadfunc load, void* userptr) { if(!GLAD_GL_ARB_occlusion_query) return; glad_glBeginQueryARB = (PFNGLBEGINQUERYARBPROC) load(userptr, "glBeginQueryARB"); glad_glDeleteQueriesARB = (PFNGLDELETEQUERIESARBPROC) load(userptr, "glDeleteQueriesARB"); glad_glEndQueryARB = (PFNGLENDQUERYARBPROC) load(userptr, "glEndQueryARB"); glad_glGenQueriesARB = (PFNGLGENQUERIESARBPROC) load(userptr, "glGenQueriesARB"); glad_glGetQueryObjectivARB = (PFNGLGETQUERYOBJECTIVARBPROC) load(userptr, "glGetQueryObjectivARB"); glad_glGetQueryObjectuivARB = (PFNGLGETQUERYOBJECTUIVARBPROC) load(userptr, "glGetQueryObjectuivARB"); glad_glGetQueryivARB = (PFNGLGETQUERYIVARBPROC) load(userptr, "glGetQueryivARB"); glad_glIsQueryARB = (PFNGLISQUERYARBPROC) load(userptr, "glIsQueryARB"); } static void glad_gl_load_GL_ARB_vertex_program( GLADuserptrloadfunc load, void* userptr) { if(!GLAD_GL_ARB_vertex_program) return; glad_glBindProgramARB = (PFNGLBINDPROGRAMARBPROC) load(userptr, "glBindProgramARB"); glad_glDeleteProgramsARB = (PFNGLDELETEPROGRAMSARBPROC) load(userptr, "glDeleteProgramsARB"); glad_glDisableVertexAttribArrayARB = (PFNGLDISABLEVERTEXATTRIBARRAYARBPROC) load(userptr, "glDisableVertexAttribArrayARB"); glad_glEnableVertexAttribArrayARB = (PFNGLENABLEVERTEXATTRIBARRAYARBPROC) load(userptr, "glEnableVertexAttribArrayARB"); glad_glGenProgramsARB = (PFNGLGENPROGRAMSARBPROC) load(userptr, "glGenProgramsARB"); glad_glGetProgramEnvParameterdvARB = (PFNGLGETPROGRAMENVPARAMETERDVARBPROC) load(userptr, "glGetProgramEnvParameterdvARB"); glad_glGetProgramEnvParameterfvARB = (PFNGLGETPROGRAMENVPARAMETERFVARBPROC) load(userptr, "glGetProgramEnvParameterfvARB"); glad_glGetProgramLocalParameterdvARB = (PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) load(userptr, "glGetProgramLocalParameterdvARB"); glad_glGetProgramLocalParameterfvARB = (PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) load(userptr, "glGetProgramLocalParameterfvARB"); glad_glGetProgramStringARB = (PFNGLGETPROGRAMSTRINGARBPROC) load(userptr, "glGetProgramStringARB"); glad_glGetProgramivARB = (PFNGLGETPROGRAMIVARBPROC) load(userptr, "glGetProgramivARB"); glad_glGetVertexAttribPointervARB = (PFNGLGETVERTEXATTRIBPOINTERVARBPROC) load(userptr, "glGetVertexAttribPointervARB"); glad_glGetVertexAttribdvARB = (PFNGLGETVERTEXATTRIBDVARBPROC) load(userptr, "glGetVertexAttribdvARB"); glad_glGetVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) load(userptr, "glGetVertexAttribfvARB"); glad_glGetVertexAttribivARB = (PFNGLGETVERTEXATTRIBIVARBPROC) load(userptr, "glGetVertexAttribivARB"); glad_glIsProgramARB = (PFNGLISPROGRAMARBPROC) load(userptr, "glIsProgramARB"); glad_glProgramEnvParameter4dARB = (PFNGLPROGRAMENVPARAMETER4DARBPROC) load(userptr, "glProgramEnvParameter4dARB"); glad_glProgramEnvParameter4dvARB = (PFNGLPROGRAMENVPARAMETER4DVARBPROC) load(userptr, "glProgramEnvParameter4dvARB"); glad_glProgramEnvParameter4fARB = (PFNGLPROGRAMENVPARAMETER4FARBPROC) load(userptr, "glProgramEnvParameter4fARB"); glad_glProgramEnvParameter4fvARB = (PFNGLPROGRAMENVPARAMETER4FVARBPROC) load(userptr, "glProgramEnvParameter4fvARB"); glad_glProgramLocalParameter4dARB = (PFNGLPROGRAMLOCALPARAMETER4DARBPROC) load(userptr, "glProgramLocalParameter4dARB"); glad_glProgramLocalParameter4dvARB = (PFNGLPROGRAMLOCALPARAMETER4DVARBPROC) load(userptr, "glProgramLocalParameter4dvARB"); glad_glProgramLocalParameter4fARB = (PFNGLPROGRAMLOCALPARAMETER4FARBPROC) load(userptr, "glProgramLocalParameter4fARB"); glad_glProgramLocalParameter4fvARB = (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC) load(userptr, "glProgramLocalParameter4fvARB"); glad_glProgramStringARB = (PFNGLPROGRAMSTRINGARBPROC) load(userptr, "glProgramStringARB"); glad_glVertexAttrib1dARB = (PFNGLVERTEXATTRIB1DARBPROC) load(userptr, "glVertexAttrib1dARB"); glad_glVertexAttrib1dvARB = (PFNGLVERTEXATTRIB1DVARBPROC) load(userptr, "glVertexAttrib1dvARB"); glad_glVertexAttrib1fARB = (PFNGLVERTEXATTRIB1FARBPROC) load(userptr, "glVertexAttrib1fARB"); glad_glVertexAttrib1fvARB = (PFNGLVERTEXATTRIB1FVARBPROC) load(userptr, "glVertexAttrib1fvARB"); glad_glVertexAttrib1sARB = (PFNGLVERTEXATTRIB1SARBPROC) load(userptr, "glVertexAttrib1sARB"); glad_glVertexAttrib1svARB = (PFNGLVERTEXATTRIB1SVARBPROC) load(userptr, "glVertexAttrib1svARB"); glad_glVertexAttrib2dARB = (PFNGLVERTEXATTRIB2DARBPROC) load(userptr, "glVertexAttrib2dARB"); glad_glVertexAttrib2dvARB = (PFNGLVERTEXATTRIB2DVARBPROC) load(userptr, "glVertexAttrib2dvARB"); glad_glVertexAttrib2fARB = (PFNGLVERTEXATTRIB2FARBPROC) load(userptr, "glVertexAttrib2fARB"); glad_glVertexAttrib2fvARB = (PFNGLVERTEXATTRIB2FVARBPROC) load(userptr, "glVertexAttrib2fvARB"); glad_glVertexAttrib2sARB = (PFNGLVERTEXATTRIB2SARBPROC) load(userptr, "glVertexAttrib2sARB"); glad_glVertexAttrib2svARB = (PFNGLVERTEXATTRIB2SVARBPROC) load(userptr, "glVertexAttrib2svARB"); glad_glVertexAttrib3dARB = (PFNGLVERTEXATTRIB3DARBPROC) load(userptr, "glVertexAttrib3dARB"); glad_glVertexAttrib3dvARB = (PFNGLVERTEXATTRIB3DVARBPROC) load(userptr, "glVertexAttrib3dvARB"); glad_glVertexAttrib3fARB = (PFNGLVERTEXATTRIB3FARBPROC) load(userptr, "glVertexAttrib3fARB"); glad_glVertexAttrib3fvARB = (PFNGLVERTEXATTRIB3FVARBPROC) load(userptr, "glVertexAttrib3fvARB"); glad_glVertexAttrib3sARB = (PFNGLVERTEXATTRIB3SARBPROC) load(userptr, "glVertexAttrib3sARB"); glad_glVertexAttrib3svARB = (PFNGLVERTEXATTRIB3SVARBPROC) load(userptr, "glVertexAttrib3svARB"); glad_glVertexAttrib4NbvARB = (PFNGLVERTEXATTRIB4NBVARBPROC) load(userptr, "glVertexAttrib4NbvARB"); glad_glVertexAttrib4NivARB = (PFNGLVERTEXATTRIB4NIVARBPROC) load(userptr, "glVertexAttrib4NivARB"); glad_glVertexAttrib4NsvARB = (PFNGLVERTEXATTRIB4NSVARBPROC) load(userptr, "glVertexAttrib4NsvARB"); glad_glVertexAttrib4NubARB = (PFNGLVERTEXATTRIB4NUBARBPROC) load(userptr, "glVertexAttrib4NubARB"); glad_glVertexAttrib4NubvARB = (PFNGLVERTEXATTRIB4NUBVARBPROC) load(userptr, "glVertexAttrib4NubvARB"); glad_glVertexAttrib4NuivARB = (PFNGLVERTEXATTRIB4NUIVARBPROC) load(userptr, "glVertexAttrib4NuivARB"); glad_glVertexAttrib4NusvARB = (PFNGLVERTEXATTRIB4NUSVARBPROC) load(userptr, "glVertexAttrib4NusvARB"); glad_glVertexAttrib4bvARB = (PFNGLVERTEXATTRIB4BVARBPROC) load(userptr, "glVertexAttrib4bvARB"); glad_glVertexAttrib4dARB = (PFNGLVERTEXATTRIB4DARBPROC) load(userptr, "glVertexAttrib4dARB"); glad_glVertexAttrib4dvARB = (PFNGLVERTEXATTRIB4DVARBPROC) load(userptr, "glVertexAttrib4dvARB"); glad_glVertexAttrib4fARB = (PFNGLVERTEXATTRIB4FARBPROC) load(userptr, "glVertexAttrib4fARB"); glad_glVertexAttrib4fvARB = (PFNGLVERTEXATTRIB4FVARBPROC) load(userptr, "glVertexAttrib4fvARB"); glad_glVertexAttrib4ivARB = (PFNGLVERTEXATTRIB4IVARBPROC) load(userptr, "glVertexAttrib4ivARB"); glad_glVertexAttrib4sARB = (PFNGLVERTEXATTRIB4SARBPROC) load(userptr, "glVertexAttrib4sARB"); glad_glVertexAttrib4svARB = (PFNGLVERTEXATTRIB4SVARBPROC) load(userptr, "glVertexAttrib4svARB"); glad_glVertexAttrib4ubvARB = (PFNGLVERTEXATTRIB4UBVARBPROC) load(userptr, "glVertexAttrib4ubvARB"); glad_glVertexAttrib4uivARB = (PFNGLVERTEXATTRIB4UIVARBPROC) load(userptr, "glVertexAttrib4uivARB"); glad_glVertexAttrib4usvARB = (PFNGLVERTEXATTRIB4USVARBPROC) load(userptr, "glVertexAttrib4usvARB"); glad_glVertexAttribPointerARB = (PFNGLVERTEXATTRIBPOINTERARBPROC) load(userptr, "glVertexAttribPointerARB"); } static void glad_gl_load_GL_EXT_depth_bounds_test( GLADuserptrloadfunc load, void* userptr) { if(!GLAD_GL_EXT_depth_bounds_test) return; glad_glDepthBoundsEXT = (PFNGLDEPTHBOUNDSEXTPROC) load(userptr, "glDepthBoundsEXT"); } static void glad_gl_load_GL_EXT_framebuffer_object( GLADuserptrloadfunc load, void* userptr) { if(!GLAD_GL_EXT_framebuffer_object) return; glad_glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC) load(userptr, "glBindFramebufferEXT"); glad_glBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC) load(userptr, "glBindRenderbufferEXT"); glad_glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC) load(userptr, "glCheckFramebufferStatusEXT"); glad_glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC) load(userptr, "glDeleteFramebuffersEXT"); glad_glDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC) load(userptr, "glDeleteRenderbuffersEXT"); glad_glFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC) load(userptr, "glFramebufferRenderbufferEXT"); glad_glFramebufferTexture1DEXT = (PFNGLFRAMEBUFFERTEXTURE1DEXTPROC) load(userptr, "glFramebufferTexture1DEXT"); glad_glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC) load(userptr, "glFramebufferTexture2DEXT"); glad_glFramebufferTexture3DEXT = (PFNGLFRAMEBUFFERTEXTURE3DEXTPROC) load(userptr, "glFramebufferTexture3DEXT"); glad_glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC) load(userptr, "glGenFramebuffersEXT"); glad_glGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC) load(userptr, "glGenRenderbuffersEXT"); glad_glGenerateMipmapEXT = (PFNGLGENERATEMIPMAPEXTPROC) load(userptr, "glGenerateMipmapEXT"); glad_glGetFramebufferAttachmentParameterivEXT = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) load(userptr, "glGetFramebufferAttachmentParameterivEXT"); glad_glGetRenderbufferParameterivEXT = (PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC) load(userptr, "glGetRenderbufferParameterivEXT"); glad_glIsFramebufferEXT = (PFNGLISFRAMEBUFFEREXTPROC) load(userptr, "glIsFramebufferEXT"); glad_glIsRenderbufferEXT = (PFNGLISRENDERBUFFEREXTPROC) load(userptr, "glIsRenderbufferEXT"); glad_glRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC) load(userptr, "glRenderbufferStorageEXT"); } static void glad_gl_load_GL_NV_occlusion_query( GLADuserptrloadfunc load, void* userptr) { if(!GLAD_GL_NV_occlusion_query) return; glad_glBeginOcclusionQueryNV = (PFNGLBEGINOCCLUSIONQUERYNVPROC) load(userptr, "glBeginOcclusionQueryNV"); glad_glDeleteOcclusionQueriesNV = (PFNGLDELETEOCCLUSIONQUERIESNVPROC) load(userptr, "glDeleteOcclusionQueriesNV"); glad_glEndOcclusionQueryNV = (PFNGLENDOCCLUSIONQUERYNVPROC) load(userptr, "glEndOcclusionQueryNV"); glad_glGenOcclusionQueriesNV = (PFNGLGENOCCLUSIONQUERIESNVPROC) load(userptr, "glGenOcclusionQueriesNV"); glad_glGetOcclusionQueryivNV = (PFNGLGETOCCLUSIONQUERYIVNVPROC) load(userptr, "glGetOcclusionQueryivNV"); glad_glGetOcclusionQueryuivNV = (PFNGLGETOCCLUSIONQUERYUIVNVPROC) load(userptr, "glGetOcclusionQueryuivNV"); glad_glIsOcclusionQueryNV = (PFNGLISOCCLUSIONQUERYNVPROC) load(userptr, "glIsOcclusionQueryNV"); } static void glad_gl_free_extensions(char **exts_i) { if (exts_i != NULL) { unsigned int index; for(index = 0; exts_i[index]; index++) { free((void *) (exts_i[index])); } free((void *)exts_i); exts_i = NULL; } } static int glad_gl_get_extensions( const char **out_exts, char ***out_exts_i) { #if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0) if (glad_glGetStringi != NULL && glad_glGetIntegerv != NULL) { unsigned int index = 0; unsigned int num_exts_i = 0; char **exts_i = NULL; glad_glGetIntegerv(GL_NUM_EXTENSIONS, (int*) &num_exts_i); exts_i = (char **) malloc((num_exts_i + 1) * (sizeof *exts_i)); if (exts_i == NULL) { return 0; } for(index = 0; index < num_exts_i; index++) { const char *gl_str_tmp = (const char*) glad_glGetStringi(GL_EXTENSIONS, index); size_t len = strlen(gl_str_tmp) + 1; char *local_str = (char*) malloc(len * sizeof(char)); if(local_str == NULL) { exts_i[index] = NULL; glad_gl_free_extensions(exts_i); return 0; } memcpy(local_str, gl_str_tmp, len * sizeof(char)); exts_i[index] = local_str; } exts_i[index] = NULL; *out_exts_i = exts_i; return 1; } #else GLAD_UNUSED(out_exts_i); #endif if (glad_glGetString == NULL) { return 0; } *out_exts = (const char *)glad_glGetString(GL_EXTENSIONS); return 1; } static int glad_gl_has_extension(const char *exts, char **exts_i, const char *ext) { if(exts_i) { unsigned int index; for(index = 0; exts_i[index]; index++) { const char *e = exts_i[index]; if(strcmp(e, ext) == 0) { return 1; } } } else { const char *extensions; const char *loc; const char *terminator; extensions = exts; if(extensions == NULL || ext == NULL) { return 0; } while(1) { loc = strstr(extensions, ext); if(loc == NULL) { return 0; } terminator = loc + strlen(ext); if((loc == extensions || *(loc - 1) == ' ') && (*terminator == ' ' || *terminator == '\0')) { return 1; } extensions = terminator; } } return 0; } static GLADapiproc glad_gl_get_proc_from_userptr(void *userptr, const char* name) { return (GLAD_GNUC_EXTENSION (GLADapiproc (*)(const char *name)) userptr)(name); } static int glad_gl_find_extensions_gl(void) { const char *exts = NULL; char **exts_i = NULL; if (!glad_gl_get_extensions(&exts, &exts_i)) return 0; GLAD_GL_ARB_depth_clamp = glad_gl_has_extension(exts, exts_i, "GL_ARB_depth_clamp"); GLAD_GL_ARB_fragment_program = glad_gl_has_extension(exts, exts_i, "GL_ARB_fragment_program"); GLAD_GL_ARB_framebuffer_object = glad_gl_has_extension(exts, exts_i, "GL_ARB_framebuffer_object"); GLAD_GL_ARB_occlusion_query = glad_gl_has_extension(exts, exts_i, "GL_ARB_occlusion_query"); GLAD_GL_ARB_occlusion_query2 = glad_gl_has_extension(exts, exts_i, "GL_ARB_occlusion_query2"); GLAD_GL_ARB_texture_cube_map = glad_gl_has_extension(exts, exts_i, "GL_ARB_texture_cube_map"); GLAD_GL_ARB_texture_env_dot3 = glad_gl_has_extension(exts, exts_i, "GL_ARB_texture_env_dot3"); GLAD_GL_ARB_texture_non_power_of_two = glad_gl_has_extension(exts, exts_i, "GL_ARB_texture_non_power_of_two"); GLAD_GL_ARB_texture_rectangle = glad_gl_has_extension(exts, exts_i, "GL_ARB_texture_rectangle"); GLAD_GL_ARB_vertex_program = glad_gl_has_extension(exts, exts_i, "GL_ARB_vertex_program"); GLAD_GL_EXT_depth_bounds_test = glad_gl_has_extension(exts, exts_i, "GL_EXT_depth_bounds_test"); GLAD_GL_EXT_framebuffer_object = glad_gl_has_extension(exts, exts_i, "GL_EXT_framebuffer_object"); GLAD_GL_EXT_packed_depth_stencil = glad_gl_has_extension(exts, exts_i, "GL_EXT_packed_depth_stencil"); GLAD_GL_EXT_texture_cube_map = glad_gl_has_extension(exts, exts_i, "GL_EXT_texture_cube_map"); GLAD_GL_EXT_texture_env_dot3 = glad_gl_has_extension(exts, exts_i, "GL_EXT_texture_env_dot3"); GLAD_GL_NV_depth_clamp = glad_gl_has_extension(exts, exts_i, "GL_NV_depth_clamp"); GLAD_GL_NV_fill_rectangle = glad_gl_has_extension(exts, exts_i, "GL_NV_fill_rectangle"); GLAD_GL_NV_occlusion_query = glad_gl_has_extension(exts, exts_i, "GL_NV_occlusion_query"); GLAD_GL_NV_packed_depth_stencil = glad_gl_has_extension(exts, exts_i, "GL_NV_packed_depth_stencil"); GLAD_GL_NV_texture_rectangle = glad_gl_has_extension(exts, exts_i, "GL_NV_texture_rectangle"); glad_gl_free_extensions(exts_i); return 1; } static int glad_gl_find_core_gl(void) { int i; const char* version; const char* prefixes[] = { "OpenGL ES-CM ", "OpenGL ES-CL ", "OpenGL ES ", "OpenGL SC ", NULL }; int major = 0; int minor = 0; version = (const char*) glad_glGetString(GL_VERSION); if (!version) return 0; for (i = 0; prefixes[i]; i++) { const size_t length = strlen(prefixes[i]); if (strncmp(version, prefixes[i], length) == 0) { version += length; break; } } GLAD_IMPL_UTIL_SSCANF(version, "%d.%d", &major, &minor); GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1; GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1; GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1; GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1; GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1; GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2; return GLAD_MAKE_VERSION(major, minor); } int gladLoadGLUserPtr( GLADuserptrloadfunc load, void *userptr) { int version; glad_glGetString = (PFNGLGETSTRINGPROC) load(userptr, "glGetString"); if(glad_glGetString == NULL) return 0; version = glad_gl_find_core_gl(); glad_gl_load_GL_VERSION_1_0(load, userptr); glad_gl_load_GL_VERSION_1_1(load, userptr); glad_gl_load_GL_VERSION_1_2(load, userptr); glad_gl_load_GL_VERSION_1_3(load, userptr); glad_gl_load_GL_VERSION_1_4(load, userptr); glad_gl_load_GL_VERSION_1_5(load, userptr); glad_gl_load_GL_VERSION_2_0(load, userptr); if (!glad_gl_find_extensions_gl()) return 0; glad_gl_load_GL_ARB_fragment_program(load, userptr); glad_gl_load_GL_ARB_framebuffer_object(load, userptr); glad_gl_load_GL_ARB_occlusion_query(load, userptr); glad_gl_load_GL_ARB_vertex_program(load, userptr); glad_gl_load_GL_EXT_depth_bounds_test(load, userptr); glad_gl_load_GL_EXT_framebuffer_object(load, userptr); glad_gl_load_GL_NV_occlusion_query(load, userptr); return version; } int gladLoadGL( GLADloadfunc load) { return gladLoadGLUserPtr( glad_gl_get_proc_from_userptr, GLAD_GNUC_EXTENSION (void*) load); } #ifdef GLAD_GL #ifndef GLAD_LOADER_LIBRARY_C_ #define GLAD_LOADER_LIBRARY_C_ #include #include #if GLAD_PLATFORM_WIN32 #include #else #include #endif static void* glad_get_dlopen_handle(const char *lib_names[], int length) { void *handle = NULL; int i; for (i = 0; i < length; ++i) { #if GLAD_PLATFORM_WIN32 #if GLAD_PLATFORM_UWP size_t buffer_size = (strlen(lib_names[i]) + 1) * sizeof(WCHAR); LPWSTR buffer = (LPWSTR) malloc(buffer_size); if (buffer != NULL) { int ret = MultiByteToWideChar(CP_ACP, 0, lib_names[i], -1, buffer, buffer_size); if (ret != 0) { handle = (void*) LoadPackagedLibrary(buffer, 0); } free((void*) buffer); } #else handle = (void*) LoadLibraryA(lib_names[i]); #endif #else handle = dlopen(lib_names[i], RTLD_LAZY | RTLD_LOCAL); #endif if (handle != NULL) { return handle; } } return NULL; } static void glad_close_dlopen_handle(void* handle) { if (handle != NULL) { #if GLAD_PLATFORM_WIN32 FreeLibrary((HMODULE) handle); #else dlclose(handle); #endif } } static GLADapiproc glad_dlsym_handle(void* handle, const char *name) { if (handle == NULL) { return NULL; } #if GLAD_PLATFORM_WIN32 return (GLADapiproc) GetProcAddress((HMODULE) handle, name); #else return GLAD_GNUC_EXTENSION (GLADapiproc) dlsym(handle, name); #endif } #endif /* GLAD_LOADER_LIBRARY_C_ */ typedef void* (GLAD_API_PTR *GLADglprocaddrfunc)(const char*); struct _glad_gl_userptr { void *handle; GLADglprocaddrfunc gl_get_proc_address_ptr; }; static GLADapiproc glad_gl_get_proc(void *vuserptr, const char *name) { struct _glad_gl_userptr userptr = *(struct _glad_gl_userptr*) vuserptr; GLADapiproc result = NULL; if(userptr.gl_get_proc_address_ptr != NULL) { result = GLAD_GNUC_EXTENSION (GLADapiproc) userptr.gl_get_proc_address_ptr(name); } if(result == NULL) { result = glad_dlsym_handle(userptr.handle, name); } return result; } static void* _glad_GL_loader_handle = NULL; static void* glad_gl_dlopen_handle(void) { #if GLAD_PLATFORM_APPLE static const char *NAMES[] = { "../Frameworks/OpenGL.framework/OpenGL", "/Library/Frameworks/OpenGL.framework/OpenGL", "/System/Library/Frameworks/OpenGL.framework/OpenGL", "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL" }; #elif GLAD_PLATFORM_WIN32 static const char *NAMES[] = {"opengl32.dll"}; #else static const char *NAMES[] = { #if defined(__CYGWIN__) "libGL-1.so", #endif "libGL.so.1", "libGL.so" }; #endif if (_glad_GL_loader_handle == NULL) { _glad_GL_loader_handle = glad_get_dlopen_handle(NAMES, sizeof(NAMES) / sizeof(NAMES[0])); } return _glad_GL_loader_handle; } static struct _glad_gl_userptr glad_gl_build_userptr(void *handle) { struct _glad_gl_userptr userptr; userptr.handle = handle; #if GLAD_PLATFORM_APPLE || defined(__HAIKU__) userptr.gl_get_proc_address_ptr = NULL; #elif GLAD_PLATFORM_WIN32 userptr.gl_get_proc_address_ptr = (GLADglprocaddrfunc) glad_dlsym_handle(handle, "wglGetProcAddress"); #else userptr.gl_get_proc_address_ptr = (GLADglprocaddrfunc) glad_dlsym_handle(handle, "glXGetProcAddressARB"); #endif return userptr; } int gladLoaderLoadGL(void) { int version = 0; void *handle; int did_load = 0; struct _glad_gl_userptr userptr; did_load = _glad_GL_loader_handle == NULL; handle = glad_gl_dlopen_handle(); if (handle) { userptr = glad_gl_build_userptr(handle); version = gladLoadGLUserPtr(glad_gl_get_proc, &userptr); if (did_load) { gladLoaderUnloadGL(); } } return version; } void gladLoaderUnloadGL(void) { if (_glad_GL_loader_handle != NULL) { glad_close_dlopen_handle(_glad_GL_loader_handle); _glad_GL_loader_handle = NULL; } } #endif /* GLAD_GL */ } OpenCSG-1.8.2/src/glad/include/0000775000175000017500000000000015141675417015764 5ustar florianflorianOpenCSG-1.8.2/src/glad/include/KHR/0000775000175000017500000000000015141675417016410 5ustar florianflorianOpenCSG-1.8.2/src/glad/include/KHR/khrplatform.h0000664000175000017500000002557315141675417021126 0ustar florianflorian#ifndef __khrplatform_h_ #define __khrplatform_h_ /* ** Copyright (c) 2008-2018 The Khronos Group Inc. ** ** Permission is hereby granted, free of charge, to any person obtaining a ** copy of this software and/or associated documentation files (the ** "Materials"), to deal in the Materials without restriction, including ** without limitation the rights to use, copy, modify, merge, publish, ** distribute, sublicense, and/or sell copies of the Materials, and to ** permit persons to whom the Materials are furnished to do so, subject to ** the following conditions: ** ** The above copyright notice and this permission notice shall be included ** in all copies or substantial portions of the Materials. ** ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. */ /* Khronos platform-specific types and definitions. * * The master copy of khrplatform.h is maintained in the Khronos EGL * Registry repository at https://github.com/KhronosGroup/EGL-Registry * The last semantic modification to khrplatform.h was at commit ID: * 67a3e0864c2d75ea5287b9f3d2eb74a745936692 * * Adopters may modify this file to suit their platform. Adopters are * encouraged to submit platform specific modifications to the Khronos * group so that they can be included in future versions of this file. * Please submit changes by filing pull requests or issues on * the EGL Registry repository linked above. * * * See the Implementer's Guidelines for information about where this file * should be located on your system and for more details of its use: * http://www.khronos.org/registry/implementers_guide.pdf * * This file should be included as * #include * by Khronos client API header files that use its types and defines. * * The types in khrplatform.h should only be used to define API-specific types. * * Types defined in khrplatform.h: * khronos_int8_t signed 8 bit * khronos_uint8_t unsigned 8 bit * khronos_int16_t signed 16 bit * khronos_uint16_t unsigned 16 bit * khronos_int32_t signed 32 bit * khronos_uint32_t unsigned 32 bit * khronos_int64_t signed 64 bit * khronos_uint64_t unsigned 64 bit * khronos_intptr_t signed same number of bits as a pointer * khronos_uintptr_t unsigned same number of bits as a pointer * khronos_ssize_t signed size * khronos_usize_t unsigned size * khronos_float_t signed 32 bit floating point * khronos_time_ns_t unsigned 64 bit time in nanoseconds * khronos_utime_nanoseconds_t unsigned time interval or absolute time in * nanoseconds * khronos_stime_nanoseconds_t signed time interval in nanoseconds * khronos_boolean_enum_t enumerated boolean type. This should * only be used as a base type when a client API's boolean type is * an enum. Client APIs which use an integer or other type for * booleans cannot use this as the base type for their boolean. * * Tokens defined in khrplatform.h: * * KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values. * * KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0. * KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0. * * Calling convention macros defined in this file: * KHRONOS_APICALL * KHRONOS_APIENTRY * KHRONOS_APIATTRIBUTES * * These may be used in function prototypes as: * * KHRONOS_APICALL void KHRONOS_APIENTRY funcname( * int arg1, * int arg2) KHRONOS_APIATTRIBUTES; */ #if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC) # define KHRONOS_STATIC 1 #endif /*------------------------------------------------------------------------- * Definition of KHRONOS_APICALL *------------------------------------------------------------------------- * This precedes the return type of the function in the function prototype. */ #if defined(KHRONOS_STATIC) /* If the preprocessor constant KHRONOS_STATIC is defined, make the * header compatible with static linking. */ # define KHRONOS_APICALL #elif defined(_WIN32) # define KHRONOS_APICALL __declspec(dllimport) #elif defined (__SYMBIAN32__) # define KHRONOS_APICALL IMPORT_C #elif defined(__ANDROID__) # define KHRONOS_APICALL __attribute__((visibility("default"))) #else # define KHRONOS_APICALL #endif /*------------------------------------------------------------------------- * Definition of KHRONOS_APIENTRY *------------------------------------------------------------------------- * This follows the return type of the function and precedes the function * name in the function prototype. */ #if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__) /* Win32 but not WinCE */ # define KHRONOS_APIENTRY __stdcall #else # define KHRONOS_APIENTRY #endif /*------------------------------------------------------------------------- * Definition of KHRONOS_APIATTRIBUTES *------------------------------------------------------------------------- * This follows the closing parenthesis of the function prototype arguments. */ #if defined (__ARMCC_2__) #define KHRONOS_APIATTRIBUTES __softfp #else #define KHRONOS_APIATTRIBUTES #endif /*------------------------------------------------------------------------- * basic type definitions *-----------------------------------------------------------------------*/ #if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__) /* * Using */ #include typedef int32_t khronos_int32_t; typedef uint32_t khronos_uint32_t; typedef int64_t khronos_int64_t; typedef uint64_t khronos_uint64_t; #define KHRONOS_SUPPORT_INT64 1 #define KHRONOS_SUPPORT_FLOAT 1 /* * To support platform where unsigned long cannot be used interchangeably with * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t. * Ideally, we could just use (u)intptr_t everywhere, but this could result in * ABI breakage if khronos_uintptr_t is changed from unsigned long to * unsigned long long or similar (this results in different C++ name mangling). * To avoid changes for existing platforms, we restrict usage of intptr_t to * platforms where the size of a pointer is larger than the size of long. */ #if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__) #if __SIZEOF_POINTER__ > __SIZEOF_LONG__ #define KHRONOS_USE_INTPTR_T #endif #endif #elif defined(__VMS ) || defined(__sgi) /* * Using */ #include typedef int32_t khronos_int32_t; typedef uint32_t khronos_uint32_t; typedef int64_t khronos_int64_t; typedef uint64_t khronos_uint64_t; #define KHRONOS_SUPPORT_INT64 1 #define KHRONOS_SUPPORT_FLOAT 1 #elif defined(_WIN32) && !defined(__SCITECH_SNAP__) /* * Win32 */ typedef __int32 khronos_int32_t; typedef unsigned __int32 khronos_uint32_t; typedef __int64 khronos_int64_t; typedef unsigned __int64 khronos_uint64_t; #define KHRONOS_SUPPORT_INT64 1 #define KHRONOS_SUPPORT_FLOAT 1 #elif defined(__sun__) || defined(__digital__) /* * Sun or Digital */ typedef int khronos_int32_t; typedef unsigned int khronos_uint32_t; #if defined(__arch64__) || defined(_LP64) typedef long int khronos_int64_t; typedef unsigned long int khronos_uint64_t; #else typedef long long int khronos_int64_t; typedef unsigned long long int khronos_uint64_t; #endif /* __arch64__ */ #define KHRONOS_SUPPORT_INT64 1 #define KHRONOS_SUPPORT_FLOAT 1 #elif 0 /* * Hypothetical platform with no float or int64 support */ typedef int khronos_int32_t; typedef unsigned int khronos_uint32_t; #define KHRONOS_SUPPORT_INT64 0 #define KHRONOS_SUPPORT_FLOAT 0 #else /* * Generic fallback */ #include typedef int32_t khronos_int32_t; typedef uint32_t khronos_uint32_t; typedef int64_t khronos_int64_t; typedef uint64_t khronos_uint64_t; #define KHRONOS_SUPPORT_INT64 1 #define KHRONOS_SUPPORT_FLOAT 1 #endif /* * Types that are (so far) the same on all platforms */ typedef signed char khronos_int8_t; typedef unsigned char khronos_uint8_t; typedef signed short int khronos_int16_t; typedef unsigned short int khronos_uint16_t; /* * Types that differ between LLP64 and LP64 architectures - in LLP64, * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears * to be the only LLP64 architecture in current use. */ #ifdef KHRONOS_USE_INTPTR_T typedef intptr_t khronos_intptr_t; typedef uintptr_t khronos_uintptr_t; #elif defined(_WIN64) typedef signed long long int khronos_intptr_t; typedef unsigned long long int khronos_uintptr_t; #else typedef signed long int khronos_intptr_t; typedef unsigned long int khronos_uintptr_t; #endif #if defined(_WIN64) typedef signed long long int khronos_ssize_t; typedef unsigned long long int khronos_usize_t; #else typedef signed long int khronos_ssize_t; typedef unsigned long int khronos_usize_t; #endif #if KHRONOS_SUPPORT_FLOAT /* * Float type */ typedef float khronos_float_t; #endif #if KHRONOS_SUPPORT_INT64 /* Time types * * These types can be used to represent a time interval in nanoseconds or * an absolute Unadjusted System Time. Unadjusted System Time is the number * of nanoseconds since some arbitrary system event (e.g. since the last * time the system booted). The Unadjusted System Time is an unsigned * 64 bit value that wraps back to 0 every 584 years. Time intervals * may be either signed or unsigned. */ typedef khronos_uint64_t khronos_utime_nanoseconds_t; typedef khronos_int64_t khronos_stime_nanoseconds_t; #endif /* * Dummy value used to pad enum types to 32 bits. */ #ifndef KHRONOS_MAX_ENUM #define KHRONOS_MAX_ENUM 0x7FFFFFFF #endif /* * Enumerated boolean type * * Values other than zero should be considered to be true. Therefore * comparisons should not be made against KHRONOS_TRUE. */ typedef enum { KHRONOS_FALSE = 0, KHRONOS_TRUE = 1, KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM } khronos_boolean_enum_t; #endif /* __khrplatform_h_ */ OpenCSG-1.8.2/src/glad/include/glad/0000775000175000017500000000000015141675417016673 5ustar florianflorianOpenCSG-1.8.2/src/glad/include/glad/gl.h0000664000175000017500000053513415141675417017461 0ustar florianflorian/** * Loader generated by glad 2.0.8 on Sun Dec 29 16:46:30 2024 * * SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0 * * Generator: C/C++ * Specification: gl * Extensions: 20 * * APIs: * - gl:compatibility=2.0 * * Options: * - ALIAS = False * - DEBUG = False * - HEADER_ONLY = False * - LOADER = True * - MX = False * - ON_DEMAND = False * * Commandline: * --api='gl:compatibility=2.0' --extensions='GL_ARB_depth_clamp,GL_ARB_fragment_program,GL_ARB_framebuffer_object,GL_ARB_occlusion_query,GL_ARB_occlusion_query2,GL_ARB_texture_cube_map,GL_ARB_texture_env_dot3,GL_ARB_texture_non_power_of_two,GL_ARB_texture_rectangle,GL_ARB_vertex_program,GL_EXT_depth_bounds_test,GL_EXT_framebuffer_object,GL_EXT_packed_depth_stencil,GL_EXT_texture_cube_map,GL_EXT_texture_env_dot3,GL_NV_depth_clamp,GL_NV_fill_rectangle,GL_NV_occlusion_query,GL_NV_packed_depth_stencil,GL_NV_texture_rectangle' c --loader * * Online: * http://glad.sh/#api=gl%3Acompatibility%3D2.0&extensions=GL_ARB_depth_clamp%2CGL_ARB_fragment_program%2CGL_ARB_framebuffer_object%2CGL_ARB_occlusion_query%2CGL_ARB_occlusion_query2%2CGL_ARB_texture_cube_map%2CGL_ARB_texture_env_dot3%2CGL_ARB_texture_non_power_of_two%2CGL_ARB_texture_rectangle%2CGL_ARB_vertex_program%2CGL_EXT_depth_bounds_test%2CGL_EXT_framebuffer_object%2CGL_EXT_packed_depth_stencil%2CGL_EXT_texture_cube_map%2CGL_EXT_texture_env_dot3%2CGL_NV_depth_clamp%2CGL_NV_fill_rectangle%2CGL_NV_occlusion_query%2CGL_NV_packed_depth_stencil%2CGL_NV_texture_rectangle&generator=c&options=LOADER * */ #ifndef GLAD_GL_H_ #define GLAD_GL_H_ #ifdef __clang__ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wreserved-id-macro" #endif #ifdef __gl_h_ #error OpenGL (gl.h) header already included (API: gl), remove previous include! #endif #define __gl_h_ 1 #ifdef __gl3_h_ #error OpenGL (gl3.h) header already included (API: gl), remove previous include! #endif #define __gl3_h_ 1 #ifdef __glext_h_ #error OpenGL (glext.h) header already included (API: gl), remove previous include! #endif #define __glext_h_ 1 #ifdef __gl3ext_h_ #error OpenGL (gl3ext.h) header already included (API: gl), remove previous include! #endif #define __gl3ext_h_ 1 #ifdef __clang__ #pragma clang diagnostic pop #endif #define GLAD_GL #define GLAD_OPTION_GL_LOADER #ifndef GLAD_PLATFORM_H_ #define GLAD_PLATFORM_H_ #ifndef GLAD_PLATFORM_WIN32 #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__MINGW32__) #define GLAD_PLATFORM_WIN32 1 #else #define GLAD_PLATFORM_WIN32 0 #endif #endif #ifndef GLAD_PLATFORM_APPLE #ifdef __APPLE__ #define GLAD_PLATFORM_APPLE 1 #else #define GLAD_PLATFORM_APPLE 0 #endif #endif #ifndef GLAD_PLATFORM_EMSCRIPTEN #ifdef __EMSCRIPTEN__ #define GLAD_PLATFORM_EMSCRIPTEN 1 #else #define GLAD_PLATFORM_EMSCRIPTEN 0 #endif #endif #ifndef GLAD_PLATFORM_UWP #if defined(_MSC_VER) && !defined(GLAD_INTERNAL_HAVE_WINAPIFAMILY) #ifdef __has_include #if __has_include() #define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1 #endif #elif _MSC_VER >= 1700 && !_USING_V110_SDK71_ #define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1 #endif #endif #ifdef GLAD_INTERNAL_HAVE_WINAPIFAMILY #include #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) #define GLAD_PLATFORM_UWP 1 #endif #endif #ifndef GLAD_PLATFORM_UWP #define GLAD_PLATFORM_UWP 0 #endif #endif #ifdef __GNUC__ #define GLAD_GNUC_EXTENSION __extension__ #else #define GLAD_GNUC_EXTENSION #endif #define GLAD_UNUSED(x) (void)(x) #ifndef GLAD_API_CALL #if defined(GLAD_API_CALL_EXPORT) #if GLAD_PLATFORM_WIN32 || defined(__CYGWIN__) #if defined(GLAD_API_CALL_EXPORT_BUILD) #if defined(__GNUC__) #define GLAD_API_CALL __attribute__ ((dllexport)) extern #else #define GLAD_API_CALL __declspec(dllexport) extern #endif #else #if defined(__GNUC__) #define GLAD_API_CALL __attribute__ ((dllimport)) extern #else #define GLAD_API_CALL __declspec(dllimport) extern #endif #endif #elif defined(__GNUC__) && defined(GLAD_API_CALL_EXPORT_BUILD) #define GLAD_API_CALL __attribute__ ((visibility ("default"))) extern #else #define GLAD_API_CALL extern #endif #else #define GLAD_API_CALL extern #endif #endif #ifdef APIENTRY #define GLAD_API_PTR APIENTRY #elif GLAD_PLATFORM_WIN32 #define GLAD_API_PTR __stdcall #else #define GLAD_API_PTR #endif #ifndef GLAPI #define GLAPI GLAD_API_CALL #endif #ifndef GLAPIENTRY #define GLAPIENTRY GLAD_API_PTR #endif #define GLAD_MAKE_VERSION(major, minor) (major * 10000 + minor) #define GLAD_VERSION_MAJOR(version) (version / 10000) #define GLAD_VERSION_MINOR(version) (version % 10000) #define GLAD_GENERATOR_VERSION "2.0.8" typedef void (*GLADapiproc)(void); typedef GLADapiproc (*GLADloadfunc)(const char *name); typedef GLADapiproc (*GLADuserptrloadfunc)(void *userptr, const char *name); typedef void (*GLADprecallback)(const char *name, GLADapiproc apiproc, int len_args, ...); typedef void (*GLADpostcallback)(void *ret, const char *name, GLADapiproc apiproc, int len_args, ...); #endif /* GLAD_PLATFORM_H_ */ #define GL_2D 0x0600 #define GL_2_BYTES 0x1407 #define GL_3D 0x0601 #define GL_3D_COLOR 0x0602 #define GL_3D_COLOR_TEXTURE 0x0603 #define GL_3_BYTES 0x1408 #define GL_4D_COLOR_TEXTURE 0x0604 #define GL_4_BYTES 0x1409 #define GL_ACCUM 0x0100 #define GL_ACCUM_ALPHA_BITS 0x0D5B #define GL_ACCUM_BLUE_BITS 0x0D5A #define GL_ACCUM_BUFFER_BIT 0x00000200 #define GL_ACCUM_CLEAR_VALUE 0x0B80 #define GL_ACCUM_GREEN_BITS 0x0D59 #define GL_ACCUM_RED_BITS 0x0D58 #define GL_ACTIVE_ATTRIBUTES 0x8B89 #define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A #define GL_ACTIVE_TEXTURE 0x84E0 #define GL_ACTIVE_UNIFORMS 0x8B86 #define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 #define GL_ADD 0x0104 #define GL_ADD_SIGNED 0x8574 #define GL_ALIASED_LINE_WIDTH_RANGE 0x846E #define GL_ALIASED_POINT_SIZE_RANGE 0x846D #define GL_ALL_ATTRIB_BITS 0xFFFFFFFF #define GL_ALPHA 0x1906 #define GL_ALPHA12 0x803D #define GL_ALPHA16 0x803E #define GL_ALPHA4 0x803B #define GL_ALPHA8 0x803C #define GL_ALPHA_BIAS 0x0D1D #define GL_ALPHA_BITS 0x0D55 #define GL_ALPHA_SCALE 0x0D1C #define GL_ALPHA_TEST 0x0BC0 #define GL_ALPHA_TEST_FUNC 0x0BC1 #define GL_ALPHA_TEST_REF 0x0BC2 #define GL_ALWAYS 0x0207 #define GL_AMBIENT 0x1200 #define GL_AMBIENT_AND_DIFFUSE 0x1602 #define GL_AND 0x1501 #define GL_AND_INVERTED 0x1504 #define GL_AND_REVERSE 0x1502 #define GL_ANY_SAMPLES_PASSED 0x8C2F #define GL_ARRAY_BUFFER 0x8892 #define GL_ARRAY_BUFFER_BINDING 0x8894 #define GL_ATTACHED_SHADERS 0x8B85 #define GL_ATTRIB_STACK_DEPTH 0x0BB0 #define GL_AUTO_NORMAL 0x0D80 #define GL_AUX0 0x0409 #define GL_AUX1 0x040A #define GL_AUX2 0x040B #define GL_AUX3 0x040C #define GL_AUX_BUFFERS 0x0C00 #define GL_BACK 0x0405 #define GL_BACK_LEFT 0x0402 #define GL_BACK_RIGHT 0x0403 #define GL_BGR 0x80E0 #define GL_BGRA 0x80E1 #define GL_BITMAP 0x1A00 #define GL_BITMAP_TOKEN 0x0704 #define GL_BLEND 0x0BE2 #define GL_BLEND_COLOR 0x8005 #define GL_BLEND_DST 0x0BE0 #define GL_BLEND_DST_ALPHA 0x80CA #define GL_BLEND_DST_RGB 0x80C8 #define GL_BLEND_EQUATION 0x8009 #define GL_BLEND_EQUATION_ALPHA 0x883D #define GL_BLEND_EQUATION_RGB 0x8009 #define GL_BLEND_SRC 0x0BE1 #define GL_BLEND_SRC_ALPHA 0x80CB #define GL_BLEND_SRC_RGB 0x80C9 #define GL_BLUE 0x1905 #define GL_BLUE_BIAS 0x0D1B #define GL_BLUE_BITS 0x0D54 #define GL_BLUE_SCALE 0x0D1A #define GL_BOOL 0x8B56 #define GL_BOOL_VEC2 0x8B57 #define GL_BOOL_VEC3 0x8B58 #define GL_BOOL_VEC4 0x8B59 #define GL_BUFFER_ACCESS 0x88BB #define GL_BUFFER_MAPPED 0x88BC #define GL_BUFFER_MAP_POINTER 0x88BD #define GL_BUFFER_SIZE 0x8764 #define GL_BUFFER_USAGE 0x8765 #define GL_BYTE 0x1400 #define GL_C3F_V3F 0x2A24 #define GL_C4F_N3F_V3F 0x2A26 #define GL_C4UB_V2F 0x2A22 #define GL_C4UB_V3F 0x2A23 #define GL_CCW 0x0901 #define GL_CLAMP 0x2900 #define GL_CLAMP_TO_BORDER 0x812D #define GL_CLAMP_TO_EDGE 0x812F #define GL_CLEAR 0x1500 #define GL_CLIENT_ACTIVE_TEXTURE 0x84E1 #define GL_CLIENT_ALL_ATTRIB_BITS 0xFFFFFFFF #define GL_CLIENT_ATTRIB_STACK_DEPTH 0x0BB1 #define GL_CLIENT_PIXEL_STORE_BIT 0x00000001 #define GL_CLIENT_VERTEX_ARRAY_BIT 0x00000002 #define GL_CLIP_PLANE0 0x3000 #define GL_CLIP_PLANE1 0x3001 #define GL_CLIP_PLANE2 0x3002 #define GL_CLIP_PLANE3 0x3003 #define GL_CLIP_PLANE4 0x3004 #define GL_CLIP_PLANE5 0x3005 #define GL_COEFF 0x0A00 #define GL_COLOR 0x1800 #define GL_COLOR_ARRAY 0x8076 #define GL_COLOR_ARRAY_BUFFER_BINDING 0x8898 #define GL_COLOR_ARRAY_POINTER 0x8090 #define GL_COLOR_ARRAY_SIZE 0x8081 #define GL_COLOR_ARRAY_STRIDE 0x8083 #define GL_COLOR_ARRAY_TYPE 0x8082 #define GL_COLOR_ATTACHMENT0 0x8CE0 #define GL_COLOR_ATTACHMENT0_EXT 0x8CE0 #define GL_COLOR_ATTACHMENT1 0x8CE1 #define GL_COLOR_ATTACHMENT10 0x8CEA #define GL_COLOR_ATTACHMENT10_EXT 0x8CEA #define GL_COLOR_ATTACHMENT11 0x8CEB #define GL_COLOR_ATTACHMENT11_EXT 0x8CEB #define GL_COLOR_ATTACHMENT12 0x8CEC #define GL_COLOR_ATTACHMENT12_EXT 0x8CEC #define GL_COLOR_ATTACHMENT13 0x8CED #define GL_COLOR_ATTACHMENT13_EXT 0x8CED #define GL_COLOR_ATTACHMENT14 0x8CEE #define GL_COLOR_ATTACHMENT14_EXT 0x8CEE #define GL_COLOR_ATTACHMENT15 0x8CEF #define GL_COLOR_ATTACHMENT15_EXT 0x8CEF #define GL_COLOR_ATTACHMENT1_EXT 0x8CE1 #define GL_COLOR_ATTACHMENT2 0x8CE2 #define GL_COLOR_ATTACHMENT2_EXT 0x8CE2 #define GL_COLOR_ATTACHMENT3 0x8CE3 #define GL_COLOR_ATTACHMENT3_EXT 0x8CE3 #define GL_COLOR_ATTACHMENT4 0x8CE4 #define GL_COLOR_ATTACHMENT4_EXT 0x8CE4 #define GL_COLOR_ATTACHMENT5 0x8CE5 #define GL_COLOR_ATTACHMENT5_EXT 0x8CE5 #define GL_COLOR_ATTACHMENT6 0x8CE6 #define GL_COLOR_ATTACHMENT6_EXT 0x8CE6 #define GL_COLOR_ATTACHMENT7 0x8CE7 #define GL_COLOR_ATTACHMENT7_EXT 0x8CE7 #define GL_COLOR_ATTACHMENT8 0x8CE8 #define GL_COLOR_ATTACHMENT8_EXT 0x8CE8 #define GL_COLOR_ATTACHMENT9 0x8CE9 #define GL_COLOR_ATTACHMENT9_EXT 0x8CE9 #define GL_COLOR_BUFFER_BIT 0x00004000 #define GL_COLOR_CLEAR_VALUE 0x0C22 #define GL_COLOR_INDEX 0x1900 #define GL_COLOR_INDEXES 0x1603 #define GL_COLOR_LOGIC_OP 0x0BF2 #define GL_COLOR_MATERIAL 0x0B57 #define GL_COLOR_MATERIAL_FACE 0x0B55 #define GL_COLOR_MATERIAL_PARAMETER 0x0B56 #define GL_COLOR_SUM 0x8458 #define GL_COLOR_SUM_ARB 0x8458 #define GL_COLOR_WRITEMASK 0x0C23 #define GL_COMBINE 0x8570 #define GL_COMBINE_ALPHA 0x8572 #define GL_COMBINE_RGB 0x8571 #define GL_COMPARE_R_TO_TEXTURE 0x884E #define GL_COMPILE 0x1300 #define GL_COMPILE_AND_EXECUTE 0x1301 #define GL_COMPILE_STATUS 0x8B81 #define GL_COMPRESSED_ALPHA 0x84E9 #define GL_COMPRESSED_INTENSITY 0x84EC #define GL_COMPRESSED_LUMINANCE 0x84EA #define GL_COMPRESSED_LUMINANCE_ALPHA 0x84EB #define GL_COMPRESSED_RGB 0x84ED #define GL_COMPRESSED_RGBA 0x84EE #define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 #define GL_CONSTANT 0x8576 #define GL_CONSTANT_ALPHA 0x8003 #define GL_CONSTANT_ATTENUATION 0x1207 #define GL_CONSTANT_COLOR 0x8001 #define GL_COORD_REPLACE 0x8862 #define GL_COPY 0x1503 #define GL_COPY_INVERTED 0x150C #define GL_COPY_PIXEL_TOKEN 0x0706 #define GL_CULL_FACE 0x0B44 #define GL_CULL_FACE_MODE 0x0B45 #define GL_CURRENT_BIT 0x00000001 #define GL_CURRENT_COLOR 0x0B00 #define GL_CURRENT_FOG_COORD 0x8453 #define GL_CURRENT_FOG_COORDINATE 0x8453 #define GL_CURRENT_INDEX 0x0B01 #define GL_CURRENT_MATRIX_ARB 0x8641 #define GL_CURRENT_MATRIX_STACK_DEPTH_ARB 0x8640 #define GL_CURRENT_NORMAL 0x0B02 #define GL_CURRENT_OCCLUSION_QUERY_ID_NV 0x8865 #define GL_CURRENT_PROGRAM 0x8B8D #define GL_CURRENT_QUERY 0x8865 #define GL_CURRENT_QUERY_ARB 0x8865 #define GL_CURRENT_RASTER_COLOR 0x0B04 #define GL_CURRENT_RASTER_DISTANCE 0x0B09 #define GL_CURRENT_RASTER_INDEX 0x0B05 #define GL_CURRENT_RASTER_POSITION 0x0B07 #define GL_CURRENT_RASTER_POSITION_VALID 0x0B08 #define GL_CURRENT_RASTER_TEXTURE_COORDS 0x0B06 #define GL_CURRENT_SECONDARY_COLOR 0x8459 #define GL_CURRENT_TEXTURE_COORDS 0x0B03 #define GL_CURRENT_VERTEX_ATTRIB 0x8626 #define GL_CURRENT_VERTEX_ATTRIB_ARB 0x8626 #define GL_CW 0x0900 #define GL_DECAL 0x2101 #define GL_DECR 0x1E03 #define GL_DECR_WRAP 0x8508 #define GL_DELETE_STATUS 0x8B80 #define GL_DEPTH 0x1801 #define GL_DEPTH24_STENCIL8 0x88F0 #define GL_DEPTH24_STENCIL8_EXT 0x88F0 #define GL_DEPTH_ATTACHMENT 0x8D00 #define GL_DEPTH_ATTACHMENT_EXT 0x8D00 #define GL_DEPTH_BIAS 0x0D1F #define GL_DEPTH_BITS 0x0D56 #define GL_DEPTH_BOUNDS_EXT 0x8891 #define GL_DEPTH_BOUNDS_TEST_EXT 0x8890 #define GL_DEPTH_BUFFER_BIT 0x00000100 #define GL_DEPTH_CLAMP 0x864F #define GL_DEPTH_CLAMP_NV 0x864F #define GL_DEPTH_CLEAR_VALUE 0x0B73 #define GL_DEPTH_COMPONENT 0x1902 #define GL_DEPTH_COMPONENT16 0x81A5 #define GL_DEPTH_COMPONENT24 0x81A6 #define GL_DEPTH_COMPONENT32 0x81A7 #define GL_DEPTH_FUNC 0x0B74 #define GL_DEPTH_RANGE 0x0B70 #define GL_DEPTH_SCALE 0x0D1E #define GL_DEPTH_STENCIL 0x84F9 #define GL_DEPTH_STENCIL_ATTACHMENT 0x821A #define GL_DEPTH_STENCIL_EXT 0x84F9 #define GL_DEPTH_STENCIL_NV 0x84F9 #define GL_DEPTH_TEST 0x0B71 #define GL_DEPTH_TEXTURE_MODE 0x884B #define GL_DEPTH_WRITEMASK 0x0B72 #define GL_DIFFUSE 0x1201 #define GL_DITHER 0x0BD0 #define GL_DOMAIN 0x0A02 #define GL_DONT_CARE 0x1100 #define GL_DOT3_RGB 0x86AE #define GL_DOT3_RGBA 0x86AF #define GL_DOT3_RGBA_ARB 0x86AF #define GL_DOT3_RGBA_EXT 0x8741 #define GL_DOT3_RGB_ARB 0x86AE #define GL_DOT3_RGB_EXT 0x8740 #define GL_DOUBLE 0x140A #define GL_DOUBLEBUFFER 0x0C32 #define GL_DRAW_BUFFER 0x0C01 #define GL_DRAW_BUFFER0 0x8825 #define GL_DRAW_BUFFER1 0x8826 #define GL_DRAW_BUFFER10 0x882F #define GL_DRAW_BUFFER11 0x8830 #define GL_DRAW_BUFFER12 0x8831 #define GL_DRAW_BUFFER13 0x8832 #define GL_DRAW_BUFFER14 0x8833 #define GL_DRAW_BUFFER15 0x8834 #define GL_DRAW_BUFFER2 0x8827 #define GL_DRAW_BUFFER3 0x8828 #define GL_DRAW_BUFFER4 0x8829 #define GL_DRAW_BUFFER5 0x882A #define GL_DRAW_BUFFER6 0x882B #define GL_DRAW_BUFFER7 0x882C #define GL_DRAW_BUFFER8 0x882D #define GL_DRAW_BUFFER9 0x882E #define GL_DRAW_FRAMEBUFFER 0x8CA9 #define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6 #define GL_DRAW_PIXEL_TOKEN 0x0705 #define GL_DST_ALPHA 0x0304 #define GL_DST_COLOR 0x0306 #define GL_DYNAMIC_COPY 0x88EA #define GL_DYNAMIC_DRAW 0x88E8 #define GL_DYNAMIC_READ 0x88E9 #define GL_EDGE_FLAG 0x0B43 #define GL_EDGE_FLAG_ARRAY 0x8079 #define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING 0x889B #define GL_EDGE_FLAG_ARRAY_POINTER 0x8093 #define GL_EDGE_FLAG_ARRAY_STRIDE 0x808C #define GL_ELEMENT_ARRAY_BUFFER 0x8893 #define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 #define GL_EMISSION 0x1600 #define GL_ENABLE_BIT 0x00002000 #define GL_EQUAL 0x0202 #define GL_EQUIV 0x1509 #define GL_EVAL_BIT 0x00010000 #define GL_EXP 0x0800 #define GL_EXP2 0x0801 #define GL_EXTENSIONS 0x1F03 #define GL_EYE_LINEAR 0x2400 #define GL_EYE_PLANE 0x2502 #define GL_FALSE 0 #define GL_FASTEST 0x1101 #define GL_FEEDBACK 0x1C01 #define GL_FEEDBACK_BUFFER_POINTER 0x0DF0 #define GL_FEEDBACK_BUFFER_SIZE 0x0DF1 #define GL_FEEDBACK_BUFFER_TYPE 0x0DF2 #define GL_FILL 0x1B02 #define GL_FILL_RECTANGLE_NV 0x933C #define GL_FLAT 0x1D00 #define GL_FLOAT 0x1406 #define GL_FLOAT_MAT2 0x8B5A #define GL_FLOAT_MAT3 0x8B5B #define GL_FLOAT_MAT4 0x8B5C #define GL_FLOAT_VEC2 0x8B50 #define GL_FLOAT_VEC3 0x8B51 #define GL_FLOAT_VEC4 0x8B52 #define GL_FOG 0x0B60 #define GL_FOG_BIT 0x00000080 #define GL_FOG_COLOR 0x0B66 #define GL_FOG_COORD 0x8451 #define GL_FOG_COORDINATE 0x8451 #define GL_FOG_COORDINATE_ARRAY 0x8457 #define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING 0x889D #define GL_FOG_COORDINATE_ARRAY_POINTER 0x8456 #define GL_FOG_COORDINATE_ARRAY_STRIDE 0x8455 #define GL_FOG_COORDINATE_ARRAY_TYPE 0x8454 #define GL_FOG_COORDINATE_SOURCE 0x8450 #define GL_FOG_COORD_ARRAY 0x8457 #define GL_FOG_COORD_ARRAY_BUFFER_BINDING 0x889D #define GL_FOG_COORD_ARRAY_POINTER 0x8456 #define GL_FOG_COORD_ARRAY_STRIDE 0x8455 #define GL_FOG_COORD_ARRAY_TYPE 0x8454 #define GL_FOG_COORD_SRC 0x8450 #define GL_FOG_DENSITY 0x0B62 #define GL_FOG_END 0x0B64 #define GL_FOG_HINT 0x0C54 #define GL_FOG_INDEX 0x0B61 #define GL_FOG_MODE 0x0B65 #define GL_FOG_START 0x0B63 #define GL_FRAGMENT_DEPTH 0x8452 #define GL_FRAGMENT_PROGRAM_ARB 0x8804 #define GL_FRAGMENT_SHADER 0x8B30 #define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B #define GL_FRAMEBUFFER 0x8D40 #define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215 #define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214 #define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210 #define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211 #define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216 #define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213 #define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1 #define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT 0x8CD1 #define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0 #define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT 0x8CD0 #define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212 #define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217 #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT 0x8CD4 #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3 #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT 0x8CD3 #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2 #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT 0x8CD2 #define GL_FRAMEBUFFER_BINDING 0x8CA6 #define GL_FRAMEBUFFER_BINDING_EXT 0x8CA6 #define GL_FRAMEBUFFER_COMPLETE 0x8CD5 #define GL_FRAMEBUFFER_COMPLETE_EXT 0x8CD5 #define GL_FRAMEBUFFER_DEFAULT 0x8218 #define GL_FRAMEBUFFER_EXT 0x8D40 #define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 #define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT 0x8CD6 #define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT 0x8CD9 #define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB #define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT 0x8CDB #define GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT 0x8CDA #define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 #define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT 0x8CD7 #define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56 #define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC #define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT 0x8CDC #define GL_FRAMEBUFFER_UNDEFINED 0x8219 #define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD #define GL_FRAMEBUFFER_UNSUPPORTED_EXT 0x8CDD #define GL_FRONT 0x0404 #define GL_FRONT_AND_BACK 0x0408 #define GL_FRONT_FACE 0x0B46 #define GL_FRONT_LEFT 0x0400 #define GL_FRONT_RIGHT 0x0401 #define GL_FUNC_ADD 0x8006 #define GL_FUNC_REVERSE_SUBTRACT 0x800B #define GL_FUNC_SUBTRACT 0x800A #define GL_GENERATE_MIPMAP 0x8191 #define GL_GENERATE_MIPMAP_HINT 0x8192 #define GL_GEQUAL 0x0206 #define GL_GREATER 0x0204 #define GL_GREEN 0x1904 #define GL_GREEN_BIAS 0x0D19 #define GL_GREEN_BITS 0x0D53 #define GL_GREEN_SCALE 0x0D18 #define GL_HINT_BIT 0x00008000 #define GL_INCR 0x1E02 #define GL_INCR_WRAP 0x8507 #define GL_INDEX 0x8222 #define GL_INDEX_ARRAY 0x8077 #define GL_INDEX_ARRAY_BUFFER_BINDING 0x8899 #define GL_INDEX_ARRAY_POINTER 0x8091 #define GL_INDEX_ARRAY_STRIDE 0x8086 #define GL_INDEX_ARRAY_TYPE 0x8085 #define GL_INDEX_BITS 0x0D51 #define GL_INDEX_CLEAR_VALUE 0x0C20 #define GL_INDEX_LOGIC_OP 0x0BF1 #define GL_INDEX_MODE 0x0C30 #define GL_INDEX_OFFSET 0x0D13 #define GL_INDEX_SHIFT 0x0D12 #define GL_INDEX_WRITEMASK 0x0C21 #define GL_INFO_LOG_LENGTH 0x8B84 #define GL_INT 0x1404 #define GL_INTENSITY 0x8049 #define GL_INTENSITY12 0x804C #define GL_INTENSITY16 0x804D #define GL_INTENSITY4 0x804A #define GL_INTENSITY8 0x804B #define GL_INTERPOLATE 0x8575 #define GL_INT_VEC2 0x8B53 #define GL_INT_VEC3 0x8B54 #define GL_INT_VEC4 0x8B55 #define GL_INVALID_ENUM 0x0500 #define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 #define GL_INVALID_FRAMEBUFFER_OPERATION_EXT 0x0506 #define GL_INVALID_OPERATION 0x0502 #define GL_INVALID_VALUE 0x0501 #define GL_INVERT 0x150A #define GL_KEEP 0x1E00 #define GL_LEFT 0x0406 #define GL_LEQUAL 0x0203 #define GL_LESS 0x0201 #define GL_LIGHT0 0x4000 #define GL_LIGHT1 0x4001 #define GL_LIGHT2 0x4002 #define GL_LIGHT3 0x4003 #define GL_LIGHT4 0x4004 #define GL_LIGHT5 0x4005 #define GL_LIGHT6 0x4006 #define GL_LIGHT7 0x4007 #define GL_LIGHTING 0x0B50 #define GL_LIGHTING_BIT 0x00000040 #define GL_LIGHT_MODEL_AMBIENT 0x0B53 #define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8 #define GL_LIGHT_MODEL_LOCAL_VIEWER 0x0B51 #define GL_LIGHT_MODEL_TWO_SIDE 0x0B52 #define GL_LINE 0x1B01 #define GL_LINEAR 0x2601 #define GL_LINEAR_ATTENUATION 0x1208 #define GL_LINEAR_MIPMAP_LINEAR 0x2703 #define GL_LINEAR_MIPMAP_NEAREST 0x2701 #define GL_LINES 0x0001 #define GL_LINE_BIT 0x00000004 #define GL_LINE_LOOP 0x0002 #define GL_LINE_RESET_TOKEN 0x0707 #define GL_LINE_SMOOTH 0x0B20 #define GL_LINE_SMOOTH_HINT 0x0C52 #define GL_LINE_STIPPLE 0x0B24 #define GL_LINE_STIPPLE_PATTERN 0x0B25 #define GL_LINE_STIPPLE_REPEAT 0x0B26 #define GL_LINE_STRIP 0x0003 #define GL_LINE_TOKEN 0x0702 #define GL_LINE_WIDTH 0x0B21 #define GL_LINE_WIDTH_GRANULARITY 0x0B23 #define GL_LINE_WIDTH_RANGE 0x0B22 #define GL_LINK_STATUS 0x8B82 #define GL_LIST_BASE 0x0B32 #define GL_LIST_BIT 0x00020000 #define GL_LIST_INDEX 0x0B33 #define GL_LIST_MODE 0x0B30 #define GL_LOAD 0x0101 #define GL_LOGIC_OP 0x0BF1 #define GL_LOGIC_OP_MODE 0x0BF0 #define GL_LOWER_LEFT 0x8CA1 #define GL_LUMINANCE 0x1909 #define GL_LUMINANCE12 0x8041 #define GL_LUMINANCE12_ALPHA12 0x8047 #define GL_LUMINANCE12_ALPHA4 0x8046 #define GL_LUMINANCE16 0x8042 #define GL_LUMINANCE16_ALPHA16 0x8048 #define GL_LUMINANCE4 0x803F #define GL_LUMINANCE4_ALPHA4 0x8043 #define GL_LUMINANCE6_ALPHA2 0x8044 #define GL_LUMINANCE8 0x8040 #define GL_LUMINANCE8_ALPHA8 0x8045 #define GL_LUMINANCE_ALPHA 0x190A #define GL_MAP1_COLOR_4 0x0D90 #define GL_MAP1_GRID_DOMAIN 0x0DD0 #define GL_MAP1_GRID_SEGMENTS 0x0DD1 #define GL_MAP1_INDEX 0x0D91 #define GL_MAP1_NORMAL 0x0D92 #define GL_MAP1_TEXTURE_COORD_1 0x0D93 #define GL_MAP1_TEXTURE_COORD_2 0x0D94 #define GL_MAP1_TEXTURE_COORD_3 0x0D95 #define GL_MAP1_TEXTURE_COORD_4 0x0D96 #define GL_MAP1_VERTEX_3 0x0D97 #define GL_MAP1_VERTEX_4 0x0D98 #define GL_MAP2_COLOR_4 0x0DB0 #define GL_MAP2_GRID_DOMAIN 0x0DD2 #define GL_MAP2_GRID_SEGMENTS 0x0DD3 #define GL_MAP2_INDEX 0x0DB1 #define GL_MAP2_NORMAL 0x0DB2 #define GL_MAP2_TEXTURE_COORD_1 0x0DB3 #define GL_MAP2_TEXTURE_COORD_2 0x0DB4 #define GL_MAP2_TEXTURE_COORD_3 0x0DB5 #define GL_MAP2_TEXTURE_COORD_4 0x0DB6 #define GL_MAP2_VERTEX_3 0x0DB7 #define GL_MAP2_VERTEX_4 0x0DB8 #define GL_MAP_COLOR 0x0D10 #define GL_MAP_STENCIL 0x0D11 #define GL_MATRIX0_ARB 0x88C0 #define GL_MATRIX10_ARB 0x88CA #define GL_MATRIX11_ARB 0x88CB #define GL_MATRIX12_ARB 0x88CC #define GL_MATRIX13_ARB 0x88CD #define GL_MATRIX14_ARB 0x88CE #define GL_MATRIX15_ARB 0x88CF #define GL_MATRIX16_ARB 0x88D0 #define GL_MATRIX17_ARB 0x88D1 #define GL_MATRIX18_ARB 0x88D2 #define GL_MATRIX19_ARB 0x88D3 #define GL_MATRIX1_ARB 0x88C1 #define GL_MATRIX20_ARB 0x88D4 #define GL_MATRIX21_ARB 0x88D5 #define GL_MATRIX22_ARB 0x88D6 #define GL_MATRIX23_ARB 0x88D7 #define GL_MATRIX24_ARB 0x88D8 #define GL_MATRIX25_ARB 0x88D9 #define GL_MATRIX26_ARB 0x88DA #define GL_MATRIX27_ARB 0x88DB #define GL_MATRIX28_ARB 0x88DC #define GL_MATRIX29_ARB 0x88DD #define GL_MATRIX2_ARB 0x88C2 #define GL_MATRIX30_ARB 0x88DE #define GL_MATRIX31_ARB 0x88DF #define GL_MATRIX3_ARB 0x88C3 #define GL_MATRIX4_ARB 0x88C4 #define GL_MATRIX5_ARB 0x88C5 #define GL_MATRIX6_ARB 0x88C6 #define GL_MATRIX7_ARB 0x88C7 #define GL_MATRIX8_ARB 0x88C8 #define GL_MATRIX9_ARB 0x88C9 #define GL_MATRIX_MODE 0x0BA0 #define GL_MAX 0x8008 #define GL_MAX_3D_TEXTURE_SIZE 0x8073 #define GL_MAX_ATTRIB_STACK_DEPTH 0x0D35 #define GL_MAX_CLIENT_ATTRIB_STACK_DEPTH 0x0D3B #define GL_MAX_CLIP_PLANES 0x0D32 #define GL_MAX_COLOR_ATTACHMENTS 0x8CDF #define GL_MAX_COLOR_ATTACHMENTS_EXT 0x8CDF #define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D #define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C #define GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB 0x851C #define GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT 0x851C #define GL_MAX_DRAW_BUFFERS 0x8824 #define GL_MAX_ELEMENTS_INDICES 0x80E9 #define GL_MAX_ELEMENTS_VERTICES 0x80E8 #define GL_MAX_EVAL_ORDER 0x0D30 #define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 #define GL_MAX_LIGHTS 0x0D31 #define GL_MAX_LIST_NESTING 0x0B31 #define GL_MAX_MODELVIEW_STACK_DEPTH 0x0D36 #define GL_MAX_NAME_STACK_DEPTH 0x0D37 #define GL_MAX_PIXEL_MAP_TABLE 0x0D34 #define GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B1 #define GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB 0x880B #define GL_MAX_PROGRAM_ATTRIBS_ARB 0x88AD #define GL_MAX_PROGRAM_ENV_PARAMETERS_ARB 0x88B5 #define GL_MAX_PROGRAM_INSTRUCTIONS_ARB 0x88A1 #define GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB 0x88B4 #define GL_MAX_PROGRAM_MATRICES_ARB 0x862F #define GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB 0x862E #define GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B3 #define GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x880E #define GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AF #define GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A3 #define GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AB #define GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A7 #define GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x8810 #define GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x880F #define GL_MAX_PROGRAM_PARAMETERS_ARB 0x88A9 #define GL_MAX_PROGRAM_TEMPORARIES_ARB 0x88A5 #define GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB 0x880D #define GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB 0x880C #define GL_MAX_PROJECTION_STACK_DEPTH 0x0D38 #define GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB 0x84F8 #define GL_MAX_RECTANGLE_TEXTURE_SIZE_NV 0x84F8 #define GL_MAX_RENDERBUFFER_SIZE 0x84E8 #define GL_MAX_RENDERBUFFER_SIZE_EXT 0x84E8 #define GL_MAX_SAMPLES 0x8D57 #define GL_MAX_TEXTURE_COORDS 0x8871 #define GL_MAX_TEXTURE_COORDS_ARB 0x8871 #define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 #define GL_MAX_TEXTURE_IMAGE_UNITS_ARB 0x8872 #define GL_MAX_TEXTURE_LOD_BIAS 0x84FD #define GL_MAX_TEXTURE_SIZE 0x0D33 #define GL_MAX_TEXTURE_STACK_DEPTH 0x0D39 #define GL_MAX_TEXTURE_UNITS 0x84E2 #define GL_MAX_VARYING_FLOATS 0x8B4B #define GL_MAX_VERTEX_ATTRIBS 0x8869 #define GL_MAX_VERTEX_ATTRIBS_ARB 0x8869 #define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C #define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A #define GL_MAX_VIEWPORT_DIMS 0x0D3A #define GL_MIN 0x8007 #define GL_MIRRORED_REPEAT 0x8370 #define GL_MODELVIEW 0x1700 #define GL_MODELVIEW_MATRIX 0x0BA6 #define GL_MODELVIEW_STACK_DEPTH 0x0BA3 #define GL_MODULATE 0x2100 #define GL_MULT 0x0103 #define GL_MULTISAMPLE 0x809D #define GL_MULTISAMPLE_BIT 0x20000000 #define GL_N3F_V3F 0x2A25 #define GL_NAME_STACK_DEPTH 0x0D70 #define GL_NAND 0x150E #define GL_NEAREST 0x2600 #define GL_NEAREST_MIPMAP_LINEAR 0x2702 #define GL_NEAREST_MIPMAP_NEAREST 0x2700 #define GL_NEVER 0x0200 #define GL_NICEST 0x1102 #define GL_NONE 0 #define GL_NOOP 0x1505 #define GL_NOR 0x1508 #define GL_NORMALIZE 0x0BA1 #define GL_NORMAL_ARRAY 0x8075 #define GL_NORMAL_ARRAY_BUFFER_BINDING 0x8897 #define GL_NORMAL_ARRAY_POINTER 0x808F #define GL_NORMAL_ARRAY_STRIDE 0x807F #define GL_NORMAL_ARRAY_TYPE 0x807E #define GL_NORMAL_MAP 0x8511 #define GL_NORMAL_MAP_ARB 0x8511 #define GL_NORMAL_MAP_EXT 0x8511 #define GL_NOTEQUAL 0x0205 #define GL_NO_ERROR 0 #define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 #define GL_OBJECT_LINEAR 0x2401 #define GL_OBJECT_PLANE 0x2501 #define GL_ONE 1 #define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 #define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 #define GL_ONE_MINUS_DST_ALPHA 0x0305 #define GL_ONE_MINUS_DST_COLOR 0x0307 #define GL_ONE_MINUS_SRC_ALPHA 0x0303 #define GL_ONE_MINUS_SRC_COLOR 0x0301 #define GL_OPERAND0_ALPHA 0x8598 #define GL_OPERAND0_RGB 0x8590 #define GL_OPERAND1_ALPHA 0x8599 #define GL_OPERAND1_RGB 0x8591 #define GL_OPERAND2_ALPHA 0x859A #define GL_OPERAND2_RGB 0x8592 #define GL_OR 0x1507 #define GL_ORDER 0x0A01 #define GL_OR_INVERTED 0x150D #define GL_OR_REVERSE 0x150B #define GL_OUT_OF_MEMORY 0x0505 #define GL_PACK_ALIGNMENT 0x0D05 #define GL_PACK_IMAGE_HEIGHT 0x806C #define GL_PACK_LSB_FIRST 0x0D01 #define GL_PACK_ROW_LENGTH 0x0D02 #define GL_PACK_SKIP_IMAGES 0x806B #define GL_PACK_SKIP_PIXELS 0x0D04 #define GL_PACK_SKIP_ROWS 0x0D03 #define GL_PACK_SWAP_BYTES 0x0D00 #define GL_PASS_THROUGH_TOKEN 0x0700 #define GL_PERSPECTIVE_CORRECTION_HINT 0x0C50 #define GL_PIXEL_COUNTER_BITS_NV 0x8864 #define GL_PIXEL_COUNT_AVAILABLE_NV 0x8867 #define GL_PIXEL_COUNT_NV 0x8866 #define GL_PIXEL_MAP_A_TO_A 0x0C79 #define GL_PIXEL_MAP_A_TO_A_SIZE 0x0CB9 #define GL_PIXEL_MAP_B_TO_B 0x0C78 #define GL_PIXEL_MAP_B_TO_B_SIZE 0x0CB8 #define GL_PIXEL_MAP_G_TO_G 0x0C77 #define GL_PIXEL_MAP_G_TO_G_SIZE 0x0CB7 #define GL_PIXEL_MAP_I_TO_A 0x0C75 #define GL_PIXEL_MAP_I_TO_A_SIZE 0x0CB5 #define GL_PIXEL_MAP_I_TO_B 0x0C74 #define GL_PIXEL_MAP_I_TO_B_SIZE 0x0CB4 #define GL_PIXEL_MAP_I_TO_G 0x0C73 #define GL_PIXEL_MAP_I_TO_G_SIZE 0x0CB3 #define GL_PIXEL_MAP_I_TO_I 0x0C70 #define GL_PIXEL_MAP_I_TO_I_SIZE 0x0CB0 #define GL_PIXEL_MAP_I_TO_R 0x0C72 #define GL_PIXEL_MAP_I_TO_R_SIZE 0x0CB2 #define GL_PIXEL_MAP_R_TO_R 0x0C76 #define GL_PIXEL_MAP_R_TO_R_SIZE 0x0CB6 #define GL_PIXEL_MAP_S_TO_S 0x0C71 #define GL_PIXEL_MAP_S_TO_S_SIZE 0x0CB1 #define GL_PIXEL_MODE_BIT 0x00000020 #define GL_POINT 0x1B00 #define GL_POINTS 0x0000 #define GL_POINT_BIT 0x00000002 #define GL_POINT_DISTANCE_ATTENUATION 0x8129 #define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 #define GL_POINT_SIZE 0x0B11 #define GL_POINT_SIZE_GRANULARITY 0x0B13 #define GL_POINT_SIZE_MAX 0x8127 #define GL_POINT_SIZE_MIN 0x8126 #define GL_POINT_SIZE_RANGE 0x0B12 #define GL_POINT_SMOOTH 0x0B10 #define GL_POINT_SMOOTH_HINT 0x0C51 #define GL_POINT_SPRITE 0x8861 #define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 #define GL_POINT_TOKEN 0x0701 #define GL_POLYGON 0x0009 #define GL_POLYGON_BIT 0x00000008 #define GL_POLYGON_MODE 0x0B40 #define GL_POLYGON_OFFSET_FACTOR 0x8038 #define GL_POLYGON_OFFSET_FILL 0x8037 #define GL_POLYGON_OFFSET_LINE 0x2A02 #define GL_POLYGON_OFFSET_POINT 0x2A01 #define GL_POLYGON_OFFSET_UNITS 0x2A00 #define GL_POLYGON_SMOOTH 0x0B41 #define GL_POLYGON_SMOOTH_HINT 0x0C53 #define GL_POLYGON_STIPPLE 0x0B42 #define GL_POLYGON_STIPPLE_BIT 0x00000010 #define GL_POLYGON_TOKEN 0x0703 #define GL_POSITION 0x1203 #define GL_PREVIOUS 0x8578 #define GL_PRIMARY_COLOR 0x8577 #define GL_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B0 #define GL_PROGRAM_ALU_INSTRUCTIONS_ARB 0x8805 #define GL_PROGRAM_ATTRIBS_ARB 0x88AC #define GL_PROGRAM_BINDING_ARB 0x8677 #define GL_PROGRAM_ERROR_POSITION_ARB 0x864B #define GL_PROGRAM_ERROR_STRING_ARB 0x8874 #define GL_PROGRAM_FORMAT_ARB 0x8876 #define GL_PROGRAM_FORMAT_ASCII_ARB 0x8875 #define GL_PROGRAM_INSTRUCTIONS_ARB 0x88A0 #define GL_PROGRAM_LENGTH_ARB 0x8627 #define GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B2 #define GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x8808 #define GL_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AE #define GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A2 #define GL_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AA #define GL_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A6 #define GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x880A #define GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x8809 #define GL_PROGRAM_PARAMETERS_ARB 0x88A8 #define GL_PROGRAM_STRING_ARB 0x8628 #define GL_PROGRAM_TEMPORARIES_ARB 0x88A4 #define GL_PROGRAM_TEX_INDIRECTIONS_ARB 0x8807 #define GL_PROGRAM_TEX_INSTRUCTIONS_ARB 0x8806 #define GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB 0x88B6 #define GL_PROJECTION 0x1701 #define GL_PROJECTION_MATRIX 0x0BA7 #define GL_PROJECTION_STACK_DEPTH 0x0BA4 #define GL_PROXY_TEXTURE_1D 0x8063 #define GL_PROXY_TEXTURE_2D 0x8064 #define GL_PROXY_TEXTURE_3D 0x8070 #define GL_PROXY_TEXTURE_CUBE_MAP 0x851B #define GL_PROXY_TEXTURE_CUBE_MAP_ARB 0x851B #define GL_PROXY_TEXTURE_CUBE_MAP_EXT 0x851B #define GL_PROXY_TEXTURE_RECTANGLE_ARB 0x84F7 #define GL_PROXY_TEXTURE_RECTANGLE_NV 0x84F7 #define GL_Q 0x2003 #define GL_QUADRATIC_ATTENUATION 0x1209 #define GL_QUADS 0x0007 #define GL_QUAD_STRIP 0x0008 #define GL_QUERY_COUNTER_BITS 0x8864 #define GL_QUERY_COUNTER_BITS_ARB 0x8864 #define GL_QUERY_RESULT 0x8866 #define GL_QUERY_RESULT_ARB 0x8866 #define GL_QUERY_RESULT_AVAILABLE 0x8867 #define GL_QUERY_RESULT_AVAILABLE_ARB 0x8867 #define GL_R 0x2002 #define GL_R3_G3_B2 0x2A10 #define GL_READ_BUFFER 0x0C02 #define GL_READ_FRAMEBUFFER 0x8CA8 #define GL_READ_FRAMEBUFFER_BINDING 0x8CAA #define GL_READ_ONLY 0x88B8 #define GL_READ_WRITE 0x88BA #define GL_RED 0x1903 #define GL_RED_BIAS 0x0D15 #define GL_RED_BITS 0x0D52 #define GL_RED_SCALE 0x0D14 #define GL_REFLECTION_MAP 0x8512 #define GL_REFLECTION_MAP_ARB 0x8512 #define GL_REFLECTION_MAP_EXT 0x8512 #define GL_RENDER 0x1C00 #define GL_RENDERBUFFER 0x8D41 #define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53 #define GL_RENDERBUFFER_ALPHA_SIZE_EXT 0x8D53 #define GL_RENDERBUFFER_BINDING 0x8CA7 #define GL_RENDERBUFFER_BINDING_EXT 0x8CA7 #define GL_RENDERBUFFER_BLUE_SIZE 0x8D52 #define GL_RENDERBUFFER_BLUE_SIZE_EXT 0x8D52 #define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54 #define GL_RENDERBUFFER_DEPTH_SIZE_EXT 0x8D54 #define GL_RENDERBUFFER_EXT 0x8D41 #define GL_RENDERBUFFER_GREEN_SIZE 0x8D51 #define GL_RENDERBUFFER_GREEN_SIZE_EXT 0x8D51 #define GL_RENDERBUFFER_HEIGHT 0x8D43 #define GL_RENDERBUFFER_HEIGHT_EXT 0x8D43 #define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44 #define GL_RENDERBUFFER_INTERNAL_FORMAT_EXT 0x8D44 #define GL_RENDERBUFFER_RED_SIZE 0x8D50 #define GL_RENDERBUFFER_RED_SIZE_EXT 0x8D50 #define GL_RENDERBUFFER_SAMPLES 0x8CAB #define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55 #define GL_RENDERBUFFER_STENCIL_SIZE_EXT 0x8D55 #define GL_RENDERBUFFER_WIDTH 0x8D42 #define GL_RENDERBUFFER_WIDTH_EXT 0x8D42 #define GL_RENDERER 0x1F01 #define GL_RENDER_MODE 0x0C40 #define GL_REPEAT 0x2901 #define GL_REPLACE 0x1E01 #define GL_RESCALE_NORMAL 0x803A #define GL_RETURN 0x0102 #define GL_RGB 0x1907 #define GL_RGB10 0x8052 #define GL_RGB10_A2 0x8059 #define GL_RGB12 0x8053 #define GL_RGB16 0x8054 #define GL_RGB4 0x804F #define GL_RGB5 0x8050 #define GL_RGB5_A1 0x8057 #define GL_RGB8 0x8051 #define GL_RGBA 0x1908 #define GL_RGBA12 0x805A #define GL_RGBA16 0x805B #define GL_RGBA2 0x8055 #define GL_RGBA4 0x8056 #define GL_RGBA8 0x8058 #define GL_RGBA_MODE 0x0C31 #define GL_RGB_SCALE 0x8573 #define GL_RIGHT 0x0407 #define GL_S 0x2000 #define GL_SAMPLER_1D 0x8B5D #define GL_SAMPLER_1D_SHADOW 0x8B61 #define GL_SAMPLER_2D 0x8B5E #define GL_SAMPLER_2D_SHADOW 0x8B62 #define GL_SAMPLER_3D 0x8B5F #define GL_SAMPLER_CUBE 0x8B60 #define GL_SAMPLES 0x80A9 #define GL_SAMPLES_PASSED 0x8914 #define GL_SAMPLES_PASSED_ARB 0x8914 #define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E #define GL_SAMPLE_ALPHA_TO_ONE 0x809F #define GL_SAMPLE_BUFFERS 0x80A8 #define GL_SAMPLE_COVERAGE 0x80A0 #define GL_SAMPLE_COVERAGE_INVERT 0x80AB #define GL_SAMPLE_COVERAGE_VALUE 0x80AA #define GL_SCISSOR_BIT 0x00080000 #define GL_SCISSOR_BOX 0x0C10 #define GL_SCISSOR_TEST 0x0C11 #define GL_SECONDARY_COLOR_ARRAY 0x845E #define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING 0x889C #define GL_SECONDARY_COLOR_ARRAY_POINTER 0x845D #define GL_SECONDARY_COLOR_ARRAY_SIZE 0x845A #define GL_SECONDARY_COLOR_ARRAY_STRIDE 0x845C #define GL_SECONDARY_COLOR_ARRAY_TYPE 0x845B #define GL_SELECT 0x1C02 #define GL_SELECTION_BUFFER_POINTER 0x0DF3 #define GL_SELECTION_BUFFER_SIZE 0x0DF4 #define GL_SEPARATE_SPECULAR_COLOR 0x81FA #define GL_SET 0x150F #define GL_SHADER_SOURCE_LENGTH 0x8B88 #define GL_SHADER_TYPE 0x8B4F #define GL_SHADE_MODEL 0x0B54 #define GL_SHADING_LANGUAGE_VERSION 0x8B8C #define GL_SHININESS 0x1601 #define GL_SHORT 0x1402 #define GL_SINGLE_COLOR 0x81F9 #define GL_SMOOTH 0x1D01 #define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 #define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 #define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 #define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 #define GL_SOURCE0_ALPHA 0x8588 #define GL_SOURCE0_RGB 0x8580 #define GL_SOURCE1_ALPHA 0x8589 #define GL_SOURCE1_RGB 0x8581 #define GL_SOURCE2_ALPHA 0x858A #define GL_SOURCE2_RGB 0x8582 #define GL_SPECULAR 0x1202 #define GL_SPHERE_MAP 0x2402 #define GL_SPOT_CUTOFF 0x1206 #define GL_SPOT_DIRECTION 0x1204 #define GL_SPOT_EXPONENT 0x1205 #define GL_SRC0_ALPHA 0x8588 #define GL_SRC0_RGB 0x8580 #define GL_SRC1_ALPHA 0x8589 #define GL_SRC1_RGB 0x8581 #define GL_SRC2_ALPHA 0x858A #define GL_SRC2_RGB 0x8582 #define GL_SRC_ALPHA 0x0302 #define GL_SRC_ALPHA_SATURATE 0x0308 #define GL_SRC_COLOR 0x0300 #define GL_STACK_OVERFLOW 0x0503 #define GL_STACK_UNDERFLOW 0x0504 #define GL_STATIC_COPY 0x88E6 #define GL_STATIC_DRAW 0x88E4 #define GL_STATIC_READ 0x88E5 #define GL_STENCIL 0x1802 #define GL_STENCIL_ATTACHMENT 0x8D20 #define GL_STENCIL_ATTACHMENT_EXT 0x8D20 #define GL_STENCIL_BACK_FAIL 0x8801 #define GL_STENCIL_BACK_FUNC 0x8800 #define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 #define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 #define GL_STENCIL_BACK_REF 0x8CA3 #define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 #define GL_STENCIL_BACK_WRITEMASK 0x8CA5 #define GL_STENCIL_BITS 0x0D57 #define GL_STENCIL_BUFFER_BIT 0x00000400 #define GL_STENCIL_CLEAR_VALUE 0x0B91 #define GL_STENCIL_FAIL 0x0B94 #define GL_STENCIL_FUNC 0x0B92 #define GL_STENCIL_INDEX 0x1901 #define GL_STENCIL_INDEX1 0x8D46 #define GL_STENCIL_INDEX16 0x8D49 #define GL_STENCIL_INDEX16_EXT 0x8D49 #define GL_STENCIL_INDEX1_EXT 0x8D46 #define GL_STENCIL_INDEX4 0x8D47 #define GL_STENCIL_INDEX4_EXT 0x8D47 #define GL_STENCIL_INDEX8 0x8D48 #define GL_STENCIL_INDEX8_EXT 0x8D48 #define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 #define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 #define GL_STENCIL_REF 0x0B97 #define GL_STENCIL_TEST 0x0B90 #define GL_STENCIL_VALUE_MASK 0x0B93 #define GL_STENCIL_WRITEMASK 0x0B98 #define GL_STEREO 0x0C33 #define GL_STREAM_COPY 0x88E2 #define GL_STREAM_DRAW 0x88E0 #define GL_STREAM_READ 0x88E1 #define GL_SUBPIXEL_BITS 0x0D50 #define GL_SUBTRACT 0x84E7 #define GL_T 0x2001 #define GL_T2F_C3F_V3F 0x2A2A #define GL_T2F_C4F_N3F_V3F 0x2A2C #define GL_T2F_C4UB_V3F 0x2A29 #define GL_T2F_N3F_V3F 0x2A2B #define GL_T2F_V3F 0x2A27 #define GL_T4F_C4F_N3F_V4F 0x2A2D #define GL_T4F_V4F 0x2A28 #define GL_TEXTURE 0x1702 #define GL_TEXTURE0 0x84C0 #define GL_TEXTURE1 0x84C1 #define GL_TEXTURE10 0x84CA #define GL_TEXTURE11 0x84CB #define GL_TEXTURE12 0x84CC #define GL_TEXTURE13 0x84CD #define GL_TEXTURE14 0x84CE #define GL_TEXTURE15 0x84CF #define GL_TEXTURE16 0x84D0 #define GL_TEXTURE17 0x84D1 #define GL_TEXTURE18 0x84D2 #define GL_TEXTURE19 0x84D3 #define GL_TEXTURE2 0x84C2 #define GL_TEXTURE20 0x84D4 #define GL_TEXTURE21 0x84D5 #define GL_TEXTURE22 0x84D6 #define GL_TEXTURE23 0x84D7 #define GL_TEXTURE24 0x84D8 #define GL_TEXTURE25 0x84D9 #define GL_TEXTURE26 0x84DA #define GL_TEXTURE27 0x84DB #define GL_TEXTURE28 0x84DC #define GL_TEXTURE29 0x84DD #define GL_TEXTURE3 0x84C3 #define GL_TEXTURE30 0x84DE #define GL_TEXTURE31 0x84DF #define GL_TEXTURE4 0x84C4 #define GL_TEXTURE5 0x84C5 #define GL_TEXTURE6 0x84C6 #define GL_TEXTURE7 0x84C7 #define GL_TEXTURE8 0x84C8 #define GL_TEXTURE9 0x84C9 #define GL_TEXTURE_1D 0x0DE0 #define GL_TEXTURE_2D 0x0DE1 #define GL_TEXTURE_3D 0x806F #define GL_TEXTURE_ALPHA_SIZE 0x805F #define GL_TEXTURE_BASE_LEVEL 0x813C #define GL_TEXTURE_BINDING_1D 0x8068 #define GL_TEXTURE_BINDING_2D 0x8069 #define GL_TEXTURE_BINDING_3D 0x806A #define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 #define GL_TEXTURE_BINDING_CUBE_MAP_ARB 0x8514 #define GL_TEXTURE_BINDING_CUBE_MAP_EXT 0x8514 #define GL_TEXTURE_BINDING_RECTANGLE_ARB 0x84F6 #define GL_TEXTURE_BINDING_RECTANGLE_NV 0x84F6 #define GL_TEXTURE_BIT 0x00040000 #define GL_TEXTURE_BLUE_SIZE 0x805E #define GL_TEXTURE_BORDER 0x1005 #define GL_TEXTURE_BORDER_COLOR 0x1004 #define GL_TEXTURE_COMPARE_FUNC 0x884D #define GL_TEXTURE_COMPARE_MODE 0x884C #define GL_TEXTURE_COMPONENTS 0x1003 #define GL_TEXTURE_COMPRESSED 0x86A1 #define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 #define GL_TEXTURE_COMPRESSION_HINT 0x84EF #define GL_TEXTURE_COORD_ARRAY 0x8078 #define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING 0x889A #define GL_TEXTURE_COORD_ARRAY_POINTER 0x8092 #define GL_TEXTURE_COORD_ARRAY_SIZE 0x8088 #define GL_TEXTURE_COORD_ARRAY_STRIDE 0x808A #define GL_TEXTURE_COORD_ARRAY_TYPE 0x8089 #define GL_TEXTURE_CUBE_MAP 0x8513 #define GL_TEXTURE_CUBE_MAP_ARB 0x8513 #define GL_TEXTURE_CUBE_MAP_EXT 0x8513 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x8516 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT 0x8516 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x8518 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT 0x8518 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x851A #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT 0x851A #define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 #define GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x8515 #define GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT 0x8515 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x8517 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT 0x8517 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x8519 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT 0x8519 #define GL_TEXTURE_DEPTH 0x8071 #define GL_TEXTURE_DEPTH_SIZE 0x884A #define GL_TEXTURE_ENV 0x2300 #define GL_TEXTURE_ENV_COLOR 0x2201 #define GL_TEXTURE_ENV_MODE 0x2200 #define GL_TEXTURE_FILTER_CONTROL 0x8500 #define GL_TEXTURE_GEN_MODE 0x2500 #define GL_TEXTURE_GEN_Q 0x0C63 #define GL_TEXTURE_GEN_R 0x0C62 #define GL_TEXTURE_GEN_S 0x0C60 #define GL_TEXTURE_GEN_T 0x0C61 #define GL_TEXTURE_GREEN_SIZE 0x805D #define GL_TEXTURE_HEIGHT 0x1001 #define GL_TEXTURE_INTENSITY_SIZE 0x8061 #define GL_TEXTURE_INTERNAL_FORMAT 0x1003 #define GL_TEXTURE_LOD_BIAS 0x8501 #define GL_TEXTURE_LUMINANCE_SIZE 0x8060 #define GL_TEXTURE_MAG_FILTER 0x2800 #define GL_TEXTURE_MATRIX 0x0BA8 #define GL_TEXTURE_MAX_LEVEL 0x813D #define GL_TEXTURE_MAX_LOD 0x813B #define GL_TEXTURE_MIN_FILTER 0x2801 #define GL_TEXTURE_MIN_LOD 0x813A #define GL_TEXTURE_PRIORITY 0x8066 #define GL_TEXTURE_RECTANGLE_ARB 0x84F5 #define GL_TEXTURE_RECTANGLE_NV 0x84F5 #define GL_TEXTURE_RED_SIZE 0x805C #define GL_TEXTURE_RESIDENT 0x8067 #define GL_TEXTURE_STACK_DEPTH 0x0BA5 #define GL_TEXTURE_STENCIL_SIZE 0x88F1 #define GL_TEXTURE_STENCIL_SIZE_EXT 0x88F1 #define GL_TEXTURE_WIDTH 0x1000 #define GL_TEXTURE_WRAP_R 0x8072 #define GL_TEXTURE_WRAP_S 0x2802 #define GL_TEXTURE_WRAP_T 0x2803 #define GL_TRANSFORM_BIT 0x00001000 #define GL_TRANSPOSE_COLOR_MATRIX 0x84E6 #define GL_TRANSPOSE_CURRENT_MATRIX_ARB 0x88B7 #define GL_TRANSPOSE_MODELVIEW_MATRIX 0x84E3 #define GL_TRANSPOSE_PROJECTION_MATRIX 0x84E4 #define GL_TRANSPOSE_TEXTURE_MATRIX 0x84E5 #define GL_TRIANGLES 0x0004 #define GL_TRIANGLE_FAN 0x0006 #define GL_TRIANGLE_STRIP 0x0005 #define GL_TRUE 1 #define GL_UNPACK_ALIGNMENT 0x0CF5 #define GL_UNPACK_IMAGE_HEIGHT 0x806E #define GL_UNPACK_LSB_FIRST 0x0CF1 #define GL_UNPACK_ROW_LENGTH 0x0CF2 #define GL_UNPACK_SKIP_IMAGES 0x806D #define GL_UNPACK_SKIP_PIXELS 0x0CF4 #define GL_UNPACK_SKIP_ROWS 0x0CF3 #define GL_UNPACK_SWAP_BYTES 0x0CF0 #define GL_UNSIGNED_BYTE 0x1401 #define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 #define GL_UNSIGNED_BYTE_3_3_2 0x8032 #define GL_UNSIGNED_INT 0x1405 #define GL_UNSIGNED_INT_10_10_10_2 0x8036 #define GL_UNSIGNED_INT_24_8 0x84FA #define GL_UNSIGNED_INT_24_8_EXT 0x84FA #define GL_UNSIGNED_INT_24_8_NV 0x84FA #define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 #define GL_UNSIGNED_INT_8_8_8_8 0x8035 #define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 #define GL_UNSIGNED_NORMALIZED 0x8C17 #define GL_UNSIGNED_SHORT 0x1403 #define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 #define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 #define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 #define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 #define GL_UNSIGNED_SHORT_5_6_5 0x8363 #define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 #define GL_UPPER_LEFT 0x8CA2 #define GL_V2F 0x2A20 #define GL_V3F 0x2A21 #define GL_VALIDATE_STATUS 0x8B83 #define GL_VENDOR 0x1F00 #define GL_VERSION 0x1F02 #define GL_VERTEX_ARRAY 0x8074 #define GL_VERTEX_ARRAY_BUFFER_BINDING 0x8896 #define GL_VERTEX_ARRAY_POINTER 0x808E #define GL_VERTEX_ARRAY_SIZE 0x807A #define GL_VERTEX_ARRAY_STRIDE 0x807C #define GL_VERTEX_ARRAY_TYPE 0x807B #define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F #define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 #define GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB 0x8622 #define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A #define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB 0x886A #define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 #define GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB 0x8645 #define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 #define GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB 0x8623 #define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 #define GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB 0x8624 #define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 #define GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB 0x8625 #define GL_VERTEX_PROGRAM_ARB 0x8620 #define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 #define GL_VERTEX_PROGRAM_POINT_SIZE_ARB 0x8642 #define GL_VERTEX_PROGRAM_TWO_SIDE 0x8643 #define GL_VERTEX_PROGRAM_TWO_SIDE_ARB 0x8643 #define GL_VERTEX_SHADER 0x8B31 #define GL_VIEWPORT 0x0BA2 #define GL_VIEWPORT_BIT 0x00000800 #define GL_WEIGHT_ARRAY_BUFFER_BINDING 0x889E #define GL_WRITE_ONLY 0x88B9 #define GL_XOR 0x1506 #define GL_ZERO 0 #define GL_ZOOM_X 0x0D16 #define GL_ZOOM_Y 0x0D17 #include "../KHR/khrplatform.h" typedef unsigned int GLenum; typedef unsigned char GLboolean; typedef unsigned int GLbitfield; typedef void GLvoid; typedef khronos_int8_t GLbyte; typedef khronos_uint8_t GLubyte; typedef khronos_int16_t GLshort; typedef khronos_uint16_t GLushort; typedef int GLint; typedef unsigned int GLuint; typedef khronos_int32_t GLclampx; typedef int GLsizei; typedef khronos_float_t GLfloat; typedef khronos_float_t GLclampf; typedef double GLdouble; typedef double GLclampd; typedef void *GLeglClientBufferEXT; typedef void *GLeglImageOES; typedef char GLchar; typedef char GLcharARB; #ifdef __APPLE__ typedef void *GLhandleARB; #else typedef unsigned int GLhandleARB; #endif typedef khronos_uint16_t GLhalf; typedef khronos_uint16_t GLhalfARB; typedef khronos_int32_t GLfixed; #if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060) typedef khronos_intptr_t GLintptr; #else typedef khronos_intptr_t GLintptr; #endif #if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060) typedef khronos_intptr_t GLintptrARB; #else typedef khronos_intptr_t GLintptrARB; #endif #if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060) typedef khronos_ssize_t GLsizeiptr; #else typedef khronos_ssize_t GLsizeiptr; #endif #if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060) typedef khronos_ssize_t GLsizeiptrARB; #else typedef khronos_ssize_t GLsizeiptrARB; #endif typedef khronos_int64_t GLint64; typedef khronos_int64_t GLint64EXT; typedef khronos_uint64_t GLuint64; typedef khronos_uint64_t GLuint64EXT; typedef struct __GLsync *GLsync; struct _cl_context; struct _cl_event; typedef void (GLAD_API_PTR *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); typedef void (GLAD_API_PTR *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); typedef void (GLAD_API_PTR *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); typedef void (GLAD_API_PTR *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam); typedef unsigned short GLhalfNV; typedef GLintptr GLvdpauSurfaceNV; typedef void (GLAD_API_PTR *GLVULKANPROCNV)(void); #define GL_VERSION_1_0 1 GLAD_API_CALL int GLAD_GL_VERSION_1_0; #define GL_VERSION_1_1 1 GLAD_API_CALL int GLAD_GL_VERSION_1_1; #define GL_VERSION_1_2 1 GLAD_API_CALL int GLAD_GL_VERSION_1_2; #define GL_VERSION_1_3 1 GLAD_API_CALL int GLAD_GL_VERSION_1_3; #define GL_VERSION_1_4 1 GLAD_API_CALL int GLAD_GL_VERSION_1_4; #define GL_VERSION_1_5 1 GLAD_API_CALL int GLAD_GL_VERSION_1_5; #define GL_VERSION_2_0 1 GLAD_API_CALL int GLAD_GL_VERSION_2_0; #define GL_ARB_depth_clamp 1 GLAD_API_CALL int GLAD_GL_ARB_depth_clamp; #define GL_ARB_fragment_program 1 GLAD_API_CALL int GLAD_GL_ARB_fragment_program; #define GL_ARB_framebuffer_object 1 GLAD_API_CALL int GLAD_GL_ARB_framebuffer_object; #define GL_ARB_occlusion_query 1 GLAD_API_CALL int GLAD_GL_ARB_occlusion_query; #define GL_ARB_occlusion_query2 1 GLAD_API_CALL int GLAD_GL_ARB_occlusion_query2; #define GL_ARB_texture_cube_map 1 GLAD_API_CALL int GLAD_GL_ARB_texture_cube_map; #define GL_ARB_texture_env_dot3 1 GLAD_API_CALL int GLAD_GL_ARB_texture_env_dot3; #define GL_ARB_texture_non_power_of_two 1 GLAD_API_CALL int GLAD_GL_ARB_texture_non_power_of_two; #define GL_ARB_texture_rectangle 1 GLAD_API_CALL int GLAD_GL_ARB_texture_rectangle; #define GL_ARB_vertex_program 1 GLAD_API_CALL int GLAD_GL_ARB_vertex_program; #define GL_EXT_depth_bounds_test 1 GLAD_API_CALL int GLAD_GL_EXT_depth_bounds_test; #define GL_EXT_framebuffer_object 1 GLAD_API_CALL int GLAD_GL_EXT_framebuffer_object; #define GL_EXT_packed_depth_stencil 1 GLAD_API_CALL int GLAD_GL_EXT_packed_depth_stencil; #define GL_EXT_texture_cube_map 1 GLAD_API_CALL int GLAD_GL_EXT_texture_cube_map; #define GL_EXT_texture_env_dot3 1 GLAD_API_CALL int GLAD_GL_EXT_texture_env_dot3; #define GL_EXT_texture_rectangle 1 GLAD_API_CALL int GLAD_GL_EXT_texture_rectangle; #define GL_NV_depth_clamp 1 GLAD_API_CALL int GLAD_GL_NV_depth_clamp; #define GL_NV_fill_rectangle 1 GLAD_API_CALL int GLAD_GL_NV_fill_rectangle; #define GL_NV_occlusion_query 1 GLAD_API_CALL int GLAD_GL_NV_occlusion_query; #define GL_NV_packed_depth_stencil 1 GLAD_API_CALL int GLAD_GL_NV_packed_depth_stencil; #define GL_NV_texture_rectangle 1 GLAD_API_CALL int GLAD_GL_NV_texture_rectangle; typedef void (GLAD_API_PTR *PFNGLACCUMPROC)(GLenum op, GLfloat value); typedef void (GLAD_API_PTR *PFNGLACTIVETEXTUREPROC)(GLenum texture); typedef void (GLAD_API_PTR *PFNGLALPHAFUNCPROC)(GLenum func, GLfloat ref); typedef GLboolean (GLAD_API_PTR *PFNGLARETEXTURESRESIDENTPROC)(GLsizei n, const GLuint * textures, GLboolean * residences); typedef void (GLAD_API_PTR *PFNGLARRAYELEMENTPROC)(GLint i); typedef void (GLAD_API_PTR *PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader); typedef void (GLAD_API_PTR *PFNGLBEGINPROC)(GLenum mode); typedef void (GLAD_API_PTR *PFNGLBEGINOCCLUSIONQUERYNVPROC)(GLuint id); typedef void (GLAD_API_PTR *PFNGLBEGINQUERYPROC)(GLenum target, GLuint id); typedef void (GLAD_API_PTR *PFNGLBEGINQUERYARBPROC)(GLenum target, GLuint id); typedef void (GLAD_API_PTR *PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar * name); typedef void (GLAD_API_PTR *PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer); typedef void (GLAD_API_PTR *PFNGLBINDFRAMEBUFFERPROC)(GLenum target, GLuint framebuffer); typedef void (GLAD_API_PTR *PFNGLBINDFRAMEBUFFEREXTPROC)(GLenum target, GLuint framebuffer); typedef void (GLAD_API_PTR *PFNGLBINDPROGRAMARBPROC)(GLenum target, GLuint program); typedef void (GLAD_API_PTR *PFNGLBINDRENDERBUFFERPROC)(GLenum target, GLuint renderbuffer); typedef void (GLAD_API_PTR *PFNGLBINDRENDERBUFFEREXTPROC)(GLenum target, GLuint renderbuffer); typedef void (GLAD_API_PTR *PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture); typedef void (GLAD_API_PTR *PFNGLBITMAPPROC)(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap); typedef void (GLAD_API_PTR *PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); typedef void (GLAD_API_PTR *PFNGLBLENDEQUATIONPROC)(GLenum mode); typedef void (GLAD_API_PTR *PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha); typedef void (GLAD_API_PTR *PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor); typedef void (GLAD_API_PTR *PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); typedef void (GLAD_API_PTR *PFNGLBLITFRAMEBUFFERPROC)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); typedef void (GLAD_API_PTR *PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void * data, GLenum usage); typedef void (GLAD_API_PTR *PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void * data); typedef void (GLAD_API_PTR *PFNGLCALLLISTPROC)(GLuint list); typedef void (GLAD_API_PTR *PFNGLCALLLISTSPROC)(GLsizei n, GLenum type, const void * lists); typedef GLenum (GLAD_API_PTR *PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target); typedef GLenum (GLAD_API_PTR *PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)(GLenum target); typedef void (GLAD_API_PTR *PFNGLCLEARPROC)(GLbitfield mask); typedef void (GLAD_API_PTR *PFNGLCLEARACCUMPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); typedef void (GLAD_API_PTR *PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); typedef void (GLAD_API_PTR *PFNGLCLEARDEPTHPROC)(GLdouble depth); typedef void (GLAD_API_PTR *PFNGLCLEARINDEXPROC)(GLfloat c); typedef void (GLAD_API_PTR *PFNGLCLEARSTENCILPROC)(GLint s); typedef void (GLAD_API_PTR *PFNGLCLIENTACTIVETEXTUREPROC)(GLenum texture); typedef void (GLAD_API_PTR *PFNGLCLIPPLANEPROC)(GLenum plane, const GLdouble * equation); typedef void (GLAD_API_PTR *PFNGLCOLOR3BPROC)(GLbyte red, GLbyte green, GLbyte blue); typedef void (GLAD_API_PTR *PFNGLCOLOR3BVPROC)(const GLbyte * v); typedef void (GLAD_API_PTR *PFNGLCOLOR3DPROC)(GLdouble red, GLdouble green, GLdouble blue); typedef void (GLAD_API_PTR *PFNGLCOLOR3DVPROC)(const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLCOLOR3FPROC)(GLfloat red, GLfloat green, GLfloat blue); typedef void (GLAD_API_PTR *PFNGLCOLOR3FVPROC)(const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLCOLOR3IPROC)(GLint red, GLint green, GLint blue); typedef void (GLAD_API_PTR *PFNGLCOLOR3IVPROC)(const GLint * v); typedef void (GLAD_API_PTR *PFNGLCOLOR3SPROC)(GLshort red, GLshort green, GLshort blue); typedef void (GLAD_API_PTR *PFNGLCOLOR3SVPROC)(const GLshort * v); typedef void (GLAD_API_PTR *PFNGLCOLOR3UBPROC)(GLubyte red, GLubyte green, GLubyte blue); typedef void (GLAD_API_PTR *PFNGLCOLOR3UBVPROC)(const GLubyte * v); typedef void (GLAD_API_PTR *PFNGLCOLOR3UIPROC)(GLuint red, GLuint green, GLuint blue); typedef void (GLAD_API_PTR *PFNGLCOLOR3UIVPROC)(const GLuint * v); typedef void (GLAD_API_PTR *PFNGLCOLOR3USPROC)(GLushort red, GLushort green, GLushort blue); typedef void (GLAD_API_PTR *PFNGLCOLOR3USVPROC)(const GLushort * v); typedef void (GLAD_API_PTR *PFNGLCOLOR4BPROC)(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); typedef void (GLAD_API_PTR *PFNGLCOLOR4BVPROC)(const GLbyte * v); typedef void (GLAD_API_PTR *PFNGLCOLOR4DPROC)(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); typedef void (GLAD_API_PTR *PFNGLCOLOR4DVPROC)(const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLCOLOR4FPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); typedef void (GLAD_API_PTR *PFNGLCOLOR4FVPROC)(const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLCOLOR4IPROC)(GLint red, GLint green, GLint blue, GLint alpha); typedef void (GLAD_API_PTR *PFNGLCOLOR4IVPROC)(const GLint * v); typedef void (GLAD_API_PTR *PFNGLCOLOR4SPROC)(GLshort red, GLshort green, GLshort blue, GLshort alpha); typedef void (GLAD_API_PTR *PFNGLCOLOR4SVPROC)(const GLshort * v); typedef void (GLAD_API_PTR *PFNGLCOLOR4UBPROC)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); typedef void (GLAD_API_PTR *PFNGLCOLOR4UBVPROC)(const GLubyte * v); typedef void (GLAD_API_PTR *PFNGLCOLOR4UIPROC)(GLuint red, GLuint green, GLuint blue, GLuint alpha); typedef void (GLAD_API_PTR *PFNGLCOLOR4UIVPROC)(const GLuint * v); typedef void (GLAD_API_PTR *PFNGLCOLOR4USPROC)(GLushort red, GLushort green, GLushort blue, GLushort alpha); typedef void (GLAD_API_PTR *PFNGLCOLOR4USVPROC)(const GLushort * v); typedef void (GLAD_API_PTR *PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); typedef void (GLAD_API_PTR *PFNGLCOLORMATERIALPROC)(GLenum face, GLenum mode); typedef void (GLAD_API_PTR *PFNGLCOLORPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void * pointer); typedef void (GLAD_API_PTR *PFNGLCOMPILESHADERPROC)(GLuint shader); typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * data); typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * data); typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXIMAGE3DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * data); typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data); typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data); typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data); typedef void (GLAD_API_PTR *PFNGLCOPYPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type); typedef void (GLAD_API_PTR *PFNGLCOPYTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); typedef void (GLAD_API_PTR *PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); typedef void (GLAD_API_PTR *PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); typedef void (GLAD_API_PTR *PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); typedef void (GLAD_API_PTR *PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); typedef GLuint (GLAD_API_PTR *PFNGLCREATEPROGRAMPROC)(void); typedef GLuint (GLAD_API_PTR *PFNGLCREATESHADERPROC)(GLenum type); typedef void (GLAD_API_PTR *PFNGLCULLFACEPROC)(GLenum mode); typedef void (GLAD_API_PTR *PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint * buffers); typedef void (GLAD_API_PTR *PFNGLDELETEFRAMEBUFFERSPROC)(GLsizei n, const GLuint * framebuffers); typedef void (GLAD_API_PTR *PFNGLDELETEFRAMEBUFFERSEXTPROC)(GLsizei n, const GLuint * framebuffers); typedef void (GLAD_API_PTR *PFNGLDELETELISTSPROC)(GLuint list, GLsizei range); typedef void (GLAD_API_PTR *PFNGLDELETEOCCLUSIONQUERIESNVPROC)(GLsizei n, const GLuint * ids); typedef void (GLAD_API_PTR *PFNGLDELETEPROGRAMPROC)(GLuint program); typedef void (GLAD_API_PTR *PFNGLDELETEPROGRAMSARBPROC)(GLsizei n, const GLuint * programs); typedef void (GLAD_API_PTR *PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint * ids); typedef void (GLAD_API_PTR *PFNGLDELETEQUERIESARBPROC)(GLsizei n, const GLuint * ids); typedef void (GLAD_API_PTR *PFNGLDELETERENDERBUFFERSPROC)(GLsizei n, const GLuint * renderbuffers); typedef void (GLAD_API_PTR *PFNGLDELETERENDERBUFFERSEXTPROC)(GLsizei n, const GLuint * renderbuffers); typedef void (GLAD_API_PTR *PFNGLDELETESHADERPROC)(GLuint shader); typedef void (GLAD_API_PTR *PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint * textures); typedef void (GLAD_API_PTR *PFNGLDEPTHBOUNDSEXTPROC)(GLclampd zmin, GLclampd zmax); typedef void (GLAD_API_PTR *PFNGLDEPTHFUNCPROC)(GLenum func); typedef void (GLAD_API_PTR *PFNGLDEPTHMASKPROC)(GLboolean flag); typedef void (GLAD_API_PTR *PFNGLDEPTHRANGEPROC)(GLdouble n, GLdouble f); typedef void (GLAD_API_PTR *PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader); typedef void (GLAD_API_PTR *PFNGLDISABLEPROC)(GLenum cap); typedef void (GLAD_API_PTR *PFNGLDISABLECLIENTSTATEPROC)(GLenum array); typedef void (GLAD_API_PTR *PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index); typedef void (GLAD_API_PTR *PFNGLDISABLEVERTEXATTRIBARRAYARBPROC)(GLuint index); typedef void (GLAD_API_PTR *PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count); typedef void (GLAD_API_PTR *PFNGLDRAWBUFFERPROC)(GLenum buf); typedef void (GLAD_API_PTR *PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum * bufs); typedef void (GLAD_API_PTR *PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void * indices); typedef void (GLAD_API_PTR *PFNGLDRAWPIXELSPROC)(GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels); typedef void (GLAD_API_PTR *PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices); typedef void (GLAD_API_PTR *PFNGLEDGEFLAGPROC)(GLboolean flag); typedef void (GLAD_API_PTR *PFNGLEDGEFLAGPOINTERPROC)(GLsizei stride, const void * pointer); typedef void (GLAD_API_PTR *PFNGLEDGEFLAGVPROC)(const GLboolean * flag); typedef void (GLAD_API_PTR *PFNGLENABLEPROC)(GLenum cap); typedef void (GLAD_API_PTR *PFNGLENABLECLIENTSTATEPROC)(GLenum array); typedef void (GLAD_API_PTR *PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index); typedef void (GLAD_API_PTR *PFNGLENABLEVERTEXATTRIBARRAYARBPROC)(GLuint index); typedef void (GLAD_API_PTR *PFNGLENDPROC)(void); typedef void (GLAD_API_PTR *PFNGLENDLISTPROC)(void); typedef void (GLAD_API_PTR *PFNGLENDOCCLUSIONQUERYNVPROC)(void); typedef void (GLAD_API_PTR *PFNGLENDQUERYPROC)(GLenum target); typedef void (GLAD_API_PTR *PFNGLENDQUERYARBPROC)(GLenum target); typedef void (GLAD_API_PTR *PFNGLEVALCOORD1DPROC)(GLdouble u); typedef void (GLAD_API_PTR *PFNGLEVALCOORD1DVPROC)(const GLdouble * u); typedef void (GLAD_API_PTR *PFNGLEVALCOORD1FPROC)(GLfloat u); typedef void (GLAD_API_PTR *PFNGLEVALCOORD1FVPROC)(const GLfloat * u); typedef void (GLAD_API_PTR *PFNGLEVALCOORD2DPROC)(GLdouble u, GLdouble v); typedef void (GLAD_API_PTR *PFNGLEVALCOORD2DVPROC)(const GLdouble * u); typedef void (GLAD_API_PTR *PFNGLEVALCOORD2FPROC)(GLfloat u, GLfloat v); typedef void (GLAD_API_PTR *PFNGLEVALCOORD2FVPROC)(const GLfloat * u); typedef void (GLAD_API_PTR *PFNGLEVALMESH1PROC)(GLenum mode, GLint i1, GLint i2); typedef void (GLAD_API_PTR *PFNGLEVALMESH2PROC)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); typedef void (GLAD_API_PTR *PFNGLEVALPOINT1PROC)(GLint i); typedef void (GLAD_API_PTR *PFNGLEVALPOINT2PROC)(GLint i, GLint j); typedef void (GLAD_API_PTR *PFNGLFEEDBACKBUFFERPROC)(GLsizei size, GLenum type, GLfloat * buffer); typedef void (GLAD_API_PTR *PFNGLFINISHPROC)(void); typedef void (GLAD_API_PTR *PFNGLFLUSHPROC)(void); typedef void (GLAD_API_PTR *PFNGLFOGCOORDPOINTERPROC)(GLenum type, GLsizei stride, const void * pointer); typedef void (GLAD_API_PTR *PFNGLFOGCOORDDPROC)(GLdouble coord); typedef void (GLAD_API_PTR *PFNGLFOGCOORDDVPROC)(const GLdouble * coord); typedef void (GLAD_API_PTR *PFNGLFOGCOORDFPROC)(GLfloat coord); typedef void (GLAD_API_PTR *PFNGLFOGCOORDFVPROC)(const GLfloat * coord); typedef void (GLAD_API_PTR *PFNGLFOGFPROC)(GLenum pname, GLfloat param); typedef void (GLAD_API_PTR *PFNGLFOGFVPROC)(GLenum pname, const GLfloat * params); typedef void (GLAD_API_PTR *PFNGLFOGIPROC)(GLenum pname, GLint param); typedef void (GLAD_API_PTR *PFNGLFOGIVPROC)(GLenum pname, const GLint * params); typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURE1DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURE1DEXTPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURE3DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURE3DEXTPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURELAYERPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); typedef void (GLAD_API_PTR *PFNGLFRONTFACEPROC)(GLenum mode); typedef void (GLAD_API_PTR *PFNGLFRUSTUMPROC)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); typedef void (GLAD_API_PTR *PFNGLGENBUFFERSPROC)(GLsizei n, GLuint * buffers); typedef void (GLAD_API_PTR *PFNGLGENFRAMEBUFFERSPROC)(GLsizei n, GLuint * framebuffers); typedef void (GLAD_API_PTR *PFNGLGENFRAMEBUFFERSEXTPROC)(GLsizei n, GLuint * framebuffers); typedef GLuint (GLAD_API_PTR *PFNGLGENLISTSPROC)(GLsizei range); typedef void (GLAD_API_PTR *PFNGLGENOCCLUSIONQUERIESNVPROC)(GLsizei n, GLuint * ids); typedef void (GLAD_API_PTR *PFNGLGENPROGRAMSARBPROC)(GLsizei n, GLuint * programs); typedef void (GLAD_API_PTR *PFNGLGENQUERIESPROC)(GLsizei n, GLuint * ids); typedef void (GLAD_API_PTR *PFNGLGENQUERIESARBPROC)(GLsizei n, GLuint * ids); typedef void (GLAD_API_PTR *PFNGLGENRENDERBUFFERSPROC)(GLsizei n, GLuint * renderbuffers); typedef void (GLAD_API_PTR *PFNGLGENRENDERBUFFERSEXTPROC)(GLsizei n, GLuint * renderbuffers); typedef void (GLAD_API_PTR *PFNGLGENTEXTURESPROC)(GLsizei n, GLuint * textures); typedef void (GLAD_API_PTR *PFNGLGENERATEMIPMAPPROC)(GLenum target); typedef void (GLAD_API_PTR *PFNGLGENERATEMIPMAPEXTPROC)(GLenum target); typedef void (GLAD_API_PTR *PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name); typedef void (GLAD_API_PTR *PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name); typedef void (GLAD_API_PTR *PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei * count, GLuint * shaders); typedef GLint (GLAD_API_PTR *PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar * name); typedef void (GLAD_API_PTR *PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean * data); typedef void (GLAD_API_PTR *PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint * params); typedef void (GLAD_API_PTR *PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void ** params); typedef void (GLAD_API_PTR *PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void * data); typedef void (GLAD_API_PTR *PFNGLGETCLIPPLANEPROC)(GLenum plane, GLdouble * equation); typedef void (GLAD_API_PTR *PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void * img); typedef void (GLAD_API_PTR *PFNGLGETDOUBLEVPROC)(GLenum pname, GLdouble * data); typedef GLenum (GLAD_API_PTR *PFNGLGETERRORPROC)(void); typedef void (GLAD_API_PTR *PFNGLGETFLOATVPROC)(GLenum pname, GLfloat * data); typedef void (GLAD_API_PTR *PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum target, GLenum attachment, GLenum pname, GLint * params); typedef void (GLAD_API_PTR *PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)(GLenum target, GLenum attachment, GLenum pname, GLint * params); typedef void (GLAD_API_PTR *PFNGLGETINTEGERVPROC)(GLenum pname, GLint * data); typedef void (GLAD_API_PTR *PFNGLGETLIGHTFVPROC)(GLenum light, GLenum pname, GLfloat * params); typedef void (GLAD_API_PTR *PFNGLGETLIGHTIVPROC)(GLenum light, GLenum pname, GLint * params); typedef void (GLAD_API_PTR *PFNGLGETMAPDVPROC)(GLenum target, GLenum query, GLdouble * v); typedef void (GLAD_API_PTR *PFNGLGETMAPFVPROC)(GLenum target, GLenum query, GLfloat * v); typedef void (GLAD_API_PTR *PFNGLGETMAPIVPROC)(GLenum target, GLenum query, GLint * v); typedef void (GLAD_API_PTR *PFNGLGETMATERIALFVPROC)(GLenum face, GLenum pname, GLfloat * params); typedef void (GLAD_API_PTR *PFNGLGETMATERIALIVPROC)(GLenum face, GLenum pname, GLint * params); typedef void (GLAD_API_PTR *PFNGLGETOCCLUSIONQUERYIVNVPROC)(GLuint id, GLenum pname, GLint * params); typedef void (GLAD_API_PTR *PFNGLGETOCCLUSIONQUERYUIVNVPROC)(GLuint id, GLenum pname, GLuint * params); typedef void (GLAD_API_PTR *PFNGLGETPIXELMAPFVPROC)(GLenum map, GLfloat * values); typedef void (GLAD_API_PTR *PFNGLGETPIXELMAPUIVPROC)(GLenum map, GLuint * values); typedef void (GLAD_API_PTR *PFNGLGETPIXELMAPUSVPROC)(GLenum map, GLushort * values); typedef void (GLAD_API_PTR *PFNGLGETPOINTERVPROC)(GLenum pname, void ** params); typedef void (GLAD_API_PTR *PFNGLGETPOLYGONSTIPPLEPROC)(GLubyte * mask); typedef void (GLAD_API_PTR *PFNGLGETPROGRAMENVPARAMETERDVARBPROC)(GLenum target, GLuint index, GLdouble * params); typedef void (GLAD_API_PTR *PFNGLGETPROGRAMENVPARAMETERFVARBPROC)(GLenum target, GLuint index, GLfloat * params); typedef void (GLAD_API_PTR *PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog); typedef void (GLAD_API_PTR *PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC)(GLenum target, GLuint index, GLdouble * params); typedef void (GLAD_API_PTR *PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC)(GLenum target, GLuint index, GLfloat * params); typedef void (GLAD_API_PTR *PFNGLGETPROGRAMSTRINGARBPROC)(GLenum target, GLenum pname, void * string); typedef void (GLAD_API_PTR *PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint * params); typedef void (GLAD_API_PTR *PFNGLGETPROGRAMIVARBPROC)(GLenum target, GLenum pname, GLint * params); typedef void (GLAD_API_PTR *PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint * params); typedef void (GLAD_API_PTR *PFNGLGETQUERYOBJECTIVARBPROC)(GLuint id, GLenum pname, GLint * params); typedef void (GLAD_API_PTR *PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint * params); typedef void (GLAD_API_PTR *PFNGLGETQUERYOBJECTUIVARBPROC)(GLuint id, GLenum pname, GLuint * params); typedef void (GLAD_API_PTR *PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint * params); typedef void (GLAD_API_PTR *PFNGLGETQUERYIVARBPROC)(GLenum target, GLenum pname, GLint * params); typedef void (GLAD_API_PTR *PFNGLGETRENDERBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint * params); typedef void (GLAD_API_PTR *PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC)(GLenum target, GLenum pname, GLint * params); typedef void (GLAD_API_PTR *PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog); typedef void (GLAD_API_PTR *PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source); typedef void (GLAD_API_PTR *PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint * params); typedef const GLubyte * (GLAD_API_PTR *PFNGLGETSTRINGPROC)(GLenum name); typedef void (GLAD_API_PTR *PFNGLGETTEXENVFVPROC)(GLenum target, GLenum pname, GLfloat * params); typedef void (GLAD_API_PTR *PFNGLGETTEXENVIVPROC)(GLenum target, GLenum pname, GLint * params); typedef void (GLAD_API_PTR *PFNGLGETTEXGENDVPROC)(GLenum coord, GLenum pname, GLdouble * params); typedef void (GLAD_API_PTR *PFNGLGETTEXGENFVPROC)(GLenum coord, GLenum pname, GLfloat * params); typedef void (GLAD_API_PTR *PFNGLGETTEXGENIVPROC)(GLenum coord, GLenum pname, GLint * params); typedef void (GLAD_API_PTR *PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void * pixels); typedef void (GLAD_API_PTR *PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat * params); typedef void (GLAD_API_PTR *PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint * params); typedef void (GLAD_API_PTR *PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat * params); typedef void (GLAD_API_PTR *PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint * params); typedef GLint (GLAD_API_PTR *PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar * name); typedef void (GLAD_API_PTR *PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat * params); typedef void (GLAD_API_PTR *PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint * params); typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void ** pointer); typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBPOINTERVARBPROC)(GLuint index, GLenum pname, void ** pointer); typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBDVPROC)(GLuint index, GLenum pname, GLdouble * params); typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBDVARBPROC)(GLuint index, GLenum pname, GLdouble * params); typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat * params); typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBFVARBPROC)(GLuint index, GLenum pname, GLfloat * params); typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint * params); typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBIVARBPROC)(GLuint index, GLenum pname, GLint * params); typedef void (GLAD_API_PTR *PFNGLHINTPROC)(GLenum target, GLenum mode); typedef void (GLAD_API_PTR *PFNGLINDEXMASKPROC)(GLuint mask); typedef void (GLAD_API_PTR *PFNGLINDEXPOINTERPROC)(GLenum type, GLsizei stride, const void * pointer); typedef void (GLAD_API_PTR *PFNGLINDEXDPROC)(GLdouble c); typedef void (GLAD_API_PTR *PFNGLINDEXDVPROC)(const GLdouble * c); typedef void (GLAD_API_PTR *PFNGLINDEXFPROC)(GLfloat c); typedef void (GLAD_API_PTR *PFNGLINDEXFVPROC)(const GLfloat * c); typedef void (GLAD_API_PTR *PFNGLINDEXIPROC)(GLint c); typedef void (GLAD_API_PTR *PFNGLINDEXIVPROC)(const GLint * c); typedef void (GLAD_API_PTR *PFNGLINDEXSPROC)(GLshort c); typedef void (GLAD_API_PTR *PFNGLINDEXSVPROC)(const GLshort * c); typedef void (GLAD_API_PTR *PFNGLINDEXUBPROC)(GLubyte c); typedef void (GLAD_API_PTR *PFNGLINDEXUBVPROC)(const GLubyte * c); typedef void (GLAD_API_PTR *PFNGLINITNAMESPROC)(void); typedef void (GLAD_API_PTR *PFNGLINTERLEAVEDARRAYSPROC)(GLenum format, GLsizei stride, const void * pointer); typedef GLboolean (GLAD_API_PTR *PFNGLISBUFFERPROC)(GLuint buffer); typedef GLboolean (GLAD_API_PTR *PFNGLISENABLEDPROC)(GLenum cap); typedef GLboolean (GLAD_API_PTR *PFNGLISFRAMEBUFFERPROC)(GLuint framebuffer); typedef GLboolean (GLAD_API_PTR *PFNGLISFRAMEBUFFEREXTPROC)(GLuint framebuffer); typedef GLboolean (GLAD_API_PTR *PFNGLISLISTPROC)(GLuint list); typedef GLboolean (GLAD_API_PTR *PFNGLISOCCLUSIONQUERYNVPROC)(GLuint id); typedef GLboolean (GLAD_API_PTR *PFNGLISPROGRAMPROC)(GLuint program); typedef GLboolean (GLAD_API_PTR *PFNGLISPROGRAMARBPROC)(GLuint program); typedef GLboolean (GLAD_API_PTR *PFNGLISQUERYPROC)(GLuint id); typedef GLboolean (GLAD_API_PTR *PFNGLISQUERYARBPROC)(GLuint id); typedef GLboolean (GLAD_API_PTR *PFNGLISRENDERBUFFERPROC)(GLuint renderbuffer); typedef GLboolean (GLAD_API_PTR *PFNGLISRENDERBUFFEREXTPROC)(GLuint renderbuffer); typedef GLboolean (GLAD_API_PTR *PFNGLISSHADERPROC)(GLuint shader); typedef GLboolean (GLAD_API_PTR *PFNGLISTEXTUREPROC)(GLuint texture); typedef void (GLAD_API_PTR *PFNGLLIGHTMODELFPROC)(GLenum pname, GLfloat param); typedef void (GLAD_API_PTR *PFNGLLIGHTMODELFVPROC)(GLenum pname, const GLfloat * params); typedef void (GLAD_API_PTR *PFNGLLIGHTMODELIPROC)(GLenum pname, GLint param); typedef void (GLAD_API_PTR *PFNGLLIGHTMODELIVPROC)(GLenum pname, const GLint * params); typedef void (GLAD_API_PTR *PFNGLLIGHTFPROC)(GLenum light, GLenum pname, GLfloat param); typedef void (GLAD_API_PTR *PFNGLLIGHTFVPROC)(GLenum light, GLenum pname, const GLfloat * params); typedef void (GLAD_API_PTR *PFNGLLIGHTIPROC)(GLenum light, GLenum pname, GLint param); typedef void (GLAD_API_PTR *PFNGLLIGHTIVPROC)(GLenum light, GLenum pname, const GLint * params); typedef void (GLAD_API_PTR *PFNGLLINESTIPPLEPROC)(GLint factor, GLushort pattern); typedef void (GLAD_API_PTR *PFNGLLINEWIDTHPROC)(GLfloat width); typedef void (GLAD_API_PTR *PFNGLLINKPROGRAMPROC)(GLuint program); typedef void (GLAD_API_PTR *PFNGLLISTBASEPROC)(GLuint base); typedef void (GLAD_API_PTR *PFNGLLOADIDENTITYPROC)(void); typedef void (GLAD_API_PTR *PFNGLLOADMATRIXDPROC)(const GLdouble * m); typedef void (GLAD_API_PTR *PFNGLLOADMATRIXFPROC)(const GLfloat * m); typedef void (GLAD_API_PTR *PFNGLLOADNAMEPROC)(GLuint name); typedef void (GLAD_API_PTR *PFNGLLOADTRANSPOSEMATRIXDPROC)(const GLdouble * m); typedef void (GLAD_API_PTR *PFNGLLOADTRANSPOSEMATRIXFPROC)(const GLfloat * m); typedef void (GLAD_API_PTR *PFNGLLOGICOPPROC)(GLenum opcode); typedef void (GLAD_API_PTR *PFNGLMAP1DPROC)(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble * points); typedef void (GLAD_API_PTR *PFNGLMAP1FPROC)(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat * points); typedef void (GLAD_API_PTR *PFNGLMAP2DPROC)(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble * points); typedef void (GLAD_API_PTR *PFNGLMAP2FPROC)(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat * points); typedef void * (GLAD_API_PTR *PFNGLMAPBUFFERPROC)(GLenum target, GLenum access); typedef void (GLAD_API_PTR *PFNGLMAPGRID1DPROC)(GLint un, GLdouble u1, GLdouble u2); typedef void (GLAD_API_PTR *PFNGLMAPGRID1FPROC)(GLint un, GLfloat u1, GLfloat u2); typedef void (GLAD_API_PTR *PFNGLMAPGRID2DPROC)(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); typedef void (GLAD_API_PTR *PFNGLMAPGRID2FPROC)(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); typedef void (GLAD_API_PTR *PFNGLMATERIALFPROC)(GLenum face, GLenum pname, GLfloat param); typedef void (GLAD_API_PTR *PFNGLMATERIALFVPROC)(GLenum face, GLenum pname, const GLfloat * params); typedef void (GLAD_API_PTR *PFNGLMATERIALIPROC)(GLenum face, GLenum pname, GLint param); typedef void (GLAD_API_PTR *PFNGLMATERIALIVPROC)(GLenum face, GLenum pname, const GLint * params); typedef void (GLAD_API_PTR *PFNGLMATRIXMODEPROC)(GLenum mode); typedef void (GLAD_API_PTR *PFNGLMULTMATRIXDPROC)(const GLdouble * m); typedef void (GLAD_API_PTR *PFNGLMULTMATRIXFPROC)(const GLfloat * m); typedef void (GLAD_API_PTR *PFNGLMULTTRANSPOSEMATRIXDPROC)(const GLdouble * m); typedef void (GLAD_API_PTR *PFNGLMULTTRANSPOSEMATRIXFPROC)(const GLfloat * m); typedef void (GLAD_API_PTR *PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint * first, const GLsizei * count, GLsizei drawcount); typedef void (GLAD_API_PTR *PFNGLMULTIDRAWELEMENTSPROC)(GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD1DPROC)(GLenum target, GLdouble s); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD1DVPROC)(GLenum target, const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD1FPROC)(GLenum target, GLfloat s); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD1FVPROC)(GLenum target, const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD1IPROC)(GLenum target, GLint s); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD1IVPROC)(GLenum target, const GLint * v); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD1SPROC)(GLenum target, GLshort s); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD1SVPROC)(GLenum target, const GLshort * v); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD2DPROC)(GLenum target, GLdouble s, GLdouble t); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD2DVPROC)(GLenum target, const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD2FPROC)(GLenum target, GLfloat s, GLfloat t); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD2FVPROC)(GLenum target, const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD2IPROC)(GLenum target, GLint s, GLint t); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD2IVPROC)(GLenum target, const GLint * v); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD2SPROC)(GLenum target, GLshort s, GLshort t); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD2SVPROC)(GLenum target, const GLshort * v); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD3DPROC)(GLenum target, GLdouble s, GLdouble t, GLdouble r); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD3DVPROC)(GLenum target, const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD3FPROC)(GLenum target, GLfloat s, GLfloat t, GLfloat r); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD3FVPROC)(GLenum target, const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD3IPROC)(GLenum target, GLint s, GLint t, GLint r); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD3IVPROC)(GLenum target, const GLint * v); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD3SPROC)(GLenum target, GLshort s, GLshort t, GLshort r); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD3SVPROC)(GLenum target, const GLshort * v); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD4DPROC)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD4DVPROC)(GLenum target, const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD4FPROC)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD4FVPROC)(GLenum target, const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD4IPROC)(GLenum target, GLint s, GLint t, GLint r, GLint q); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD4IVPROC)(GLenum target, const GLint * v); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD4SPROC)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD4SVPROC)(GLenum target, const GLshort * v); typedef void (GLAD_API_PTR *PFNGLNEWLISTPROC)(GLuint list, GLenum mode); typedef void (GLAD_API_PTR *PFNGLNORMAL3BPROC)(GLbyte nx, GLbyte ny, GLbyte nz); typedef void (GLAD_API_PTR *PFNGLNORMAL3BVPROC)(const GLbyte * v); typedef void (GLAD_API_PTR *PFNGLNORMAL3DPROC)(GLdouble nx, GLdouble ny, GLdouble nz); typedef void (GLAD_API_PTR *PFNGLNORMAL3DVPROC)(const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLNORMAL3FPROC)(GLfloat nx, GLfloat ny, GLfloat nz); typedef void (GLAD_API_PTR *PFNGLNORMAL3FVPROC)(const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLNORMAL3IPROC)(GLint nx, GLint ny, GLint nz); typedef void (GLAD_API_PTR *PFNGLNORMAL3IVPROC)(const GLint * v); typedef void (GLAD_API_PTR *PFNGLNORMAL3SPROC)(GLshort nx, GLshort ny, GLshort nz); typedef void (GLAD_API_PTR *PFNGLNORMAL3SVPROC)(const GLshort * v); typedef void (GLAD_API_PTR *PFNGLNORMALPOINTERPROC)(GLenum type, GLsizei stride, const void * pointer); typedef void (GLAD_API_PTR *PFNGLORTHOPROC)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); typedef void (GLAD_API_PTR *PFNGLPASSTHROUGHPROC)(GLfloat token); typedef void (GLAD_API_PTR *PFNGLPIXELMAPFVPROC)(GLenum map, GLsizei mapsize, const GLfloat * values); typedef void (GLAD_API_PTR *PFNGLPIXELMAPUIVPROC)(GLenum map, GLsizei mapsize, const GLuint * values); typedef void (GLAD_API_PTR *PFNGLPIXELMAPUSVPROC)(GLenum map, GLsizei mapsize, const GLushort * values); typedef void (GLAD_API_PTR *PFNGLPIXELSTOREFPROC)(GLenum pname, GLfloat param); typedef void (GLAD_API_PTR *PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param); typedef void (GLAD_API_PTR *PFNGLPIXELTRANSFERFPROC)(GLenum pname, GLfloat param); typedef void (GLAD_API_PTR *PFNGLPIXELTRANSFERIPROC)(GLenum pname, GLint param); typedef void (GLAD_API_PTR *PFNGLPIXELZOOMPROC)(GLfloat xfactor, GLfloat yfactor); typedef void (GLAD_API_PTR *PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param); typedef void (GLAD_API_PTR *PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat * params); typedef void (GLAD_API_PTR *PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param); typedef void (GLAD_API_PTR *PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint * params); typedef void (GLAD_API_PTR *PFNGLPOINTSIZEPROC)(GLfloat size); typedef void (GLAD_API_PTR *PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode); typedef void (GLAD_API_PTR *PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units); typedef void (GLAD_API_PTR *PFNGLPOLYGONSTIPPLEPROC)(const GLubyte * mask); typedef void (GLAD_API_PTR *PFNGLPOPATTRIBPROC)(void); typedef void (GLAD_API_PTR *PFNGLPOPCLIENTATTRIBPROC)(void); typedef void (GLAD_API_PTR *PFNGLPOPMATRIXPROC)(void); typedef void (GLAD_API_PTR *PFNGLPOPNAMEPROC)(void); typedef void (GLAD_API_PTR *PFNGLPRIORITIZETEXTURESPROC)(GLsizei n, const GLuint * textures, const GLfloat * priorities); typedef void (GLAD_API_PTR *PFNGLPROGRAMENVPARAMETER4DARBPROC)(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (GLAD_API_PTR *PFNGLPROGRAMENVPARAMETER4DVARBPROC)(GLenum target, GLuint index, const GLdouble * params); typedef void (GLAD_API_PTR *PFNGLPROGRAMENVPARAMETER4FARBPROC)(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (GLAD_API_PTR *PFNGLPROGRAMENVPARAMETER4FVARBPROC)(GLenum target, GLuint index, const GLfloat * params); typedef void (GLAD_API_PTR *PFNGLPROGRAMLOCALPARAMETER4DARBPROC)(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (GLAD_API_PTR *PFNGLPROGRAMLOCALPARAMETER4DVARBPROC)(GLenum target, GLuint index, const GLdouble * params); typedef void (GLAD_API_PTR *PFNGLPROGRAMLOCALPARAMETER4FARBPROC)(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (GLAD_API_PTR *PFNGLPROGRAMLOCALPARAMETER4FVARBPROC)(GLenum target, GLuint index, const GLfloat * params); typedef void (GLAD_API_PTR *PFNGLPROGRAMSTRINGARBPROC)(GLenum target, GLenum format, GLsizei len, const void * string); typedef void (GLAD_API_PTR *PFNGLPUSHATTRIBPROC)(GLbitfield mask); typedef void (GLAD_API_PTR *PFNGLPUSHCLIENTATTRIBPROC)(GLbitfield mask); typedef void (GLAD_API_PTR *PFNGLPUSHMATRIXPROC)(void); typedef void (GLAD_API_PTR *PFNGLPUSHNAMEPROC)(GLuint name); typedef void (GLAD_API_PTR *PFNGLRASTERPOS2DPROC)(GLdouble x, GLdouble y); typedef void (GLAD_API_PTR *PFNGLRASTERPOS2DVPROC)(const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLRASTERPOS2FPROC)(GLfloat x, GLfloat y); typedef void (GLAD_API_PTR *PFNGLRASTERPOS2FVPROC)(const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLRASTERPOS2IPROC)(GLint x, GLint y); typedef void (GLAD_API_PTR *PFNGLRASTERPOS2IVPROC)(const GLint * v); typedef void (GLAD_API_PTR *PFNGLRASTERPOS2SPROC)(GLshort x, GLshort y); typedef void (GLAD_API_PTR *PFNGLRASTERPOS2SVPROC)(const GLshort * v); typedef void (GLAD_API_PTR *PFNGLRASTERPOS3DPROC)(GLdouble x, GLdouble y, GLdouble z); typedef void (GLAD_API_PTR *PFNGLRASTERPOS3DVPROC)(const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLRASTERPOS3FPROC)(GLfloat x, GLfloat y, GLfloat z); typedef void (GLAD_API_PTR *PFNGLRASTERPOS3FVPROC)(const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLRASTERPOS3IPROC)(GLint x, GLint y, GLint z); typedef void (GLAD_API_PTR *PFNGLRASTERPOS3IVPROC)(const GLint * v); typedef void (GLAD_API_PTR *PFNGLRASTERPOS3SPROC)(GLshort x, GLshort y, GLshort z); typedef void (GLAD_API_PTR *PFNGLRASTERPOS3SVPROC)(const GLshort * v); typedef void (GLAD_API_PTR *PFNGLRASTERPOS4DPROC)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (GLAD_API_PTR *PFNGLRASTERPOS4DVPROC)(const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLRASTERPOS4FPROC)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (GLAD_API_PTR *PFNGLRASTERPOS4FVPROC)(const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLRASTERPOS4IPROC)(GLint x, GLint y, GLint z, GLint w); typedef void (GLAD_API_PTR *PFNGLRASTERPOS4IVPROC)(const GLint * v); typedef void (GLAD_API_PTR *PFNGLRASTERPOS4SPROC)(GLshort x, GLshort y, GLshort z, GLshort w); typedef void (GLAD_API_PTR *PFNGLRASTERPOS4SVPROC)(const GLshort * v); typedef void (GLAD_API_PTR *PFNGLREADBUFFERPROC)(GLenum src); typedef void (GLAD_API_PTR *PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void * pixels); typedef void (GLAD_API_PTR *PFNGLRECTDPROC)(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); typedef void (GLAD_API_PTR *PFNGLRECTDVPROC)(const GLdouble * v1, const GLdouble * v2); typedef void (GLAD_API_PTR *PFNGLRECTFPROC)(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); typedef void (GLAD_API_PTR *PFNGLRECTFVPROC)(const GLfloat * v1, const GLfloat * v2); typedef void (GLAD_API_PTR *PFNGLRECTIPROC)(GLint x1, GLint y1, GLint x2, GLint y2); typedef void (GLAD_API_PTR *PFNGLRECTIVPROC)(const GLint * v1, const GLint * v2); typedef void (GLAD_API_PTR *PFNGLRECTSPROC)(GLshort x1, GLshort y1, GLshort x2, GLshort y2); typedef void (GLAD_API_PTR *PFNGLRECTSVPROC)(const GLshort * v1, const GLshort * v2); typedef GLint (GLAD_API_PTR *PFNGLRENDERMODEPROC)(GLenum mode); typedef void (GLAD_API_PTR *PFNGLRENDERBUFFERSTORAGEPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); typedef void (GLAD_API_PTR *PFNGLRENDERBUFFERSTORAGEEXTPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); typedef void (GLAD_API_PTR *PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); typedef void (GLAD_API_PTR *PFNGLROTATEDPROC)(GLdouble angle, GLdouble x, GLdouble y, GLdouble z); typedef void (GLAD_API_PTR *PFNGLROTATEFPROC)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAD_API_PTR *PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert); typedef void (GLAD_API_PTR *PFNGLSCALEDPROC)(GLdouble x, GLdouble y, GLdouble z); typedef void (GLAD_API_PTR *PFNGLSCALEFPROC)(GLfloat x, GLfloat y, GLfloat z); typedef void (GLAD_API_PTR *PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height); typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3BPROC)(GLbyte red, GLbyte green, GLbyte blue); typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3BVPROC)(const GLbyte * v); typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3DPROC)(GLdouble red, GLdouble green, GLdouble blue); typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3DVPROC)(const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3FPROC)(GLfloat red, GLfloat green, GLfloat blue); typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3FVPROC)(const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3IPROC)(GLint red, GLint green, GLint blue); typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3IVPROC)(const GLint * v); typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3SPROC)(GLshort red, GLshort green, GLshort blue); typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3SVPROC)(const GLshort * v); typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3UBPROC)(GLubyte red, GLubyte green, GLubyte blue); typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3UBVPROC)(const GLubyte * v); typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3UIPROC)(GLuint red, GLuint green, GLuint blue); typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3UIVPROC)(const GLuint * v); typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3USPROC)(GLushort red, GLushort green, GLushort blue); typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3USVPROC)(const GLushort * v); typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLORPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void * pointer); typedef void (GLAD_API_PTR *PFNGLSELECTBUFFERPROC)(GLsizei size, GLuint * buffer); typedef void (GLAD_API_PTR *PFNGLSHADEMODELPROC)(GLenum mode); typedef void (GLAD_API_PTR *PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const* string, const GLint * length); typedef void (GLAD_API_PTR *PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask); typedef void (GLAD_API_PTR *PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask); typedef void (GLAD_API_PTR *PFNGLSTENCILMASKPROC)(GLuint mask); typedef void (GLAD_API_PTR *PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask); typedef void (GLAD_API_PTR *PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass); typedef void (GLAD_API_PTR *PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); typedef void (GLAD_API_PTR *PFNGLTEXCOORD1DPROC)(GLdouble s); typedef void (GLAD_API_PTR *PFNGLTEXCOORD1DVPROC)(const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLTEXCOORD1FPROC)(GLfloat s); typedef void (GLAD_API_PTR *PFNGLTEXCOORD1FVPROC)(const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLTEXCOORD1IPROC)(GLint s); typedef void (GLAD_API_PTR *PFNGLTEXCOORD1IVPROC)(const GLint * v); typedef void (GLAD_API_PTR *PFNGLTEXCOORD1SPROC)(GLshort s); typedef void (GLAD_API_PTR *PFNGLTEXCOORD1SVPROC)(const GLshort * v); typedef void (GLAD_API_PTR *PFNGLTEXCOORD2DPROC)(GLdouble s, GLdouble t); typedef void (GLAD_API_PTR *PFNGLTEXCOORD2DVPROC)(const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLTEXCOORD2FPROC)(GLfloat s, GLfloat t); typedef void (GLAD_API_PTR *PFNGLTEXCOORD2FVPROC)(const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLTEXCOORD2IPROC)(GLint s, GLint t); typedef void (GLAD_API_PTR *PFNGLTEXCOORD2IVPROC)(const GLint * v); typedef void (GLAD_API_PTR *PFNGLTEXCOORD2SPROC)(GLshort s, GLshort t); typedef void (GLAD_API_PTR *PFNGLTEXCOORD2SVPROC)(const GLshort * v); typedef void (GLAD_API_PTR *PFNGLTEXCOORD3DPROC)(GLdouble s, GLdouble t, GLdouble r); typedef void (GLAD_API_PTR *PFNGLTEXCOORD3DVPROC)(const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLTEXCOORD3FPROC)(GLfloat s, GLfloat t, GLfloat r); typedef void (GLAD_API_PTR *PFNGLTEXCOORD3FVPROC)(const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLTEXCOORD3IPROC)(GLint s, GLint t, GLint r); typedef void (GLAD_API_PTR *PFNGLTEXCOORD3IVPROC)(const GLint * v); typedef void (GLAD_API_PTR *PFNGLTEXCOORD3SPROC)(GLshort s, GLshort t, GLshort r); typedef void (GLAD_API_PTR *PFNGLTEXCOORD3SVPROC)(const GLshort * v); typedef void (GLAD_API_PTR *PFNGLTEXCOORD4DPROC)(GLdouble s, GLdouble t, GLdouble r, GLdouble q); typedef void (GLAD_API_PTR *PFNGLTEXCOORD4DVPROC)(const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLTEXCOORD4FPROC)(GLfloat s, GLfloat t, GLfloat r, GLfloat q); typedef void (GLAD_API_PTR *PFNGLTEXCOORD4FVPROC)(const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLTEXCOORD4IPROC)(GLint s, GLint t, GLint r, GLint q); typedef void (GLAD_API_PTR *PFNGLTEXCOORD4IVPROC)(const GLint * v); typedef void (GLAD_API_PTR *PFNGLTEXCOORD4SPROC)(GLshort s, GLshort t, GLshort r, GLshort q); typedef void (GLAD_API_PTR *PFNGLTEXCOORD4SVPROC)(const GLshort * v); typedef void (GLAD_API_PTR *PFNGLTEXCOORDPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void * pointer); typedef void (GLAD_API_PTR *PFNGLTEXENVFPROC)(GLenum target, GLenum pname, GLfloat param); typedef void (GLAD_API_PTR *PFNGLTEXENVFVPROC)(GLenum target, GLenum pname, const GLfloat * params); typedef void (GLAD_API_PTR *PFNGLTEXENVIPROC)(GLenum target, GLenum pname, GLint param); typedef void (GLAD_API_PTR *PFNGLTEXENVIVPROC)(GLenum target, GLenum pname, const GLint * params); typedef void (GLAD_API_PTR *PFNGLTEXGENDPROC)(GLenum coord, GLenum pname, GLdouble param); typedef void (GLAD_API_PTR *PFNGLTEXGENDVPROC)(GLenum coord, GLenum pname, const GLdouble * params); typedef void (GLAD_API_PTR *PFNGLTEXGENFPROC)(GLenum coord, GLenum pname, GLfloat param); typedef void (GLAD_API_PTR *PFNGLTEXGENFVPROC)(GLenum coord, GLenum pname, const GLfloat * params); typedef void (GLAD_API_PTR *PFNGLTEXGENIPROC)(GLenum coord, GLenum pname, GLint param); typedef void (GLAD_API_PTR *PFNGLTEXGENIVPROC)(GLenum coord, GLenum pname, const GLint * params); typedef void (GLAD_API_PTR *PFNGLTEXIMAGE1DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels); typedef void (GLAD_API_PTR *PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels); typedef void (GLAD_API_PTR *PFNGLTEXIMAGE3DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels); typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param); typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat * params); typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param); typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint * params); typedef void (GLAD_API_PTR *PFNGLTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels); typedef void (GLAD_API_PTR *PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels); typedef void (GLAD_API_PTR *PFNGLTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels); typedef void (GLAD_API_PTR *PFNGLTRANSLATEDPROC)(GLdouble x, GLdouble y, GLdouble z); typedef void (GLAD_API_PTR *PFNGLTRANSLATEFPROC)(GLfloat x, GLfloat y, GLfloat z); typedef void (GLAD_API_PTR *PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0); typedef void (GLAD_API_PTR *PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat * value); typedef void (GLAD_API_PTR *PFNGLUNIFORM1IPROC)(GLint location, GLint v0); typedef void (GLAD_API_PTR *PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint * value); typedef void (GLAD_API_PTR *PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1); typedef void (GLAD_API_PTR *PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat * value); typedef void (GLAD_API_PTR *PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1); typedef void (GLAD_API_PTR *PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint * value); typedef void (GLAD_API_PTR *PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); typedef void (GLAD_API_PTR *PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat * value); typedef void (GLAD_API_PTR *PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2); typedef void (GLAD_API_PTR *PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint * value); typedef void (GLAD_API_PTR *PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); typedef void (GLAD_API_PTR *PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat * value); typedef void (GLAD_API_PTR *PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); typedef void (GLAD_API_PTR *PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint * value); typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); typedef GLboolean (GLAD_API_PTR *PFNGLUNMAPBUFFERPROC)(GLenum target); typedef void (GLAD_API_PTR *PFNGLUSEPROGRAMPROC)(GLuint program); typedef void (GLAD_API_PTR *PFNGLVALIDATEPROGRAMPROC)(GLuint program); typedef void (GLAD_API_PTR *PFNGLVERTEX2DPROC)(GLdouble x, GLdouble y); typedef void (GLAD_API_PTR *PFNGLVERTEX2DVPROC)(const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLVERTEX2FPROC)(GLfloat x, GLfloat y); typedef void (GLAD_API_PTR *PFNGLVERTEX2FVPROC)(const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLVERTEX2IPROC)(GLint x, GLint y); typedef void (GLAD_API_PTR *PFNGLVERTEX2IVPROC)(const GLint * v); typedef void (GLAD_API_PTR *PFNGLVERTEX2SPROC)(GLshort x, GLshort y); typedef void (GLAD_API_PTR *PFNGLVERTEX2SVPROC)(const GLshort * v); typedef void (GLAD_API_PTR *PFNGLVERTEX3DPROC)(GLdouble x, GLdouble y, GLdouble z); typedef void (GLAD_API_PTR *PFNGLVERTEX3DVPROC)(const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLVERTEX3FPROC)(GLfloat x, GLfloat y, GLfloat z); typedef void (GLAD_API_PTR *PFNGLVERTEX3FVPROC)(const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLVERTEX3IPROC)(GLint x, GLint y, GLint z); typedef void (GLAD_API_PTR *PFNGLVERTEX3IVPROC)(const GLint * v); typedef void (GLAD_API_PTR *PFNGLVERTEX3SPROC)(GLshort x, GLshort y, GLshort z); typedef void (GLAD_API_PTR *PFNGLVERTEX3SVPROC)(const GLshort * v); typedef void (GLAD_API_PTR *PFNGLVERTEX4DPROC)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (GLAD_API_PTR *PFNGLVERTEX4DVPROC)(const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLVERTEX4FPROC)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (GLAD_API_PTR *PFNGLVERTEX4FVPROC)(const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLVERTEX4IPROC)(GLint x, GLint y, GLint z, GLint w); typedef void (GLAD_API_PTR *PFNGLVERTEX4IVPROC)(const GLint * v); typedef void (GLAD_API_PTR *PFNGLVERTEX4SPROC)(GLshort x, GLshort y, GLshort z, GLshort w); typedef void (GLAD_API_PTR *PFNGLVERTEX4SVPROC)(const GLshort * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1DPROC)(GLuint index, GLdouble x); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1DARBPROC)(GLuint index, GLdouble x); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1DVPROC)(GLuint index, const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1DVARBPROC)(GLuint index, const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1FARBPROC)(GLuint index, GLfloat x); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1FVARBPROC)(GLuint index, const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1SPROC)(GLuint index, GLshort x); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1SARBPROC)(GLuint index, GLshort x); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1SVPROC)(GLuint index, const GLshort * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1SVARBPROC)(GLuint index, const GLshort * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2DPROC)(GLuint index, GLdouble x, GLdouble y); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2DARBPROC)(GLuint index, GLdouble x, GLdouble y); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2DVPROC)(GLuint index, const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2DVARBPROC)(GLuint index, const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2FARBPROC)(GLuint index, GLfloat x, GLfloat y); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2FVARBPROC)(GLuint index, const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2SPROC)(GLuint index, GLshort x, GLshort y); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2SARBPROC)(GLuint index, GLshort x, GLshort y); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2SVPROC)(GLuint index, const GLshort * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2SVARBPROC)(GLuint index, const GLshort * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3DARBPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3DVPROC)(GLuint index, const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3DVARBPROC)(GLuint index, const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3FARBPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3FVARBPROC)(GLuint index, const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3SPROC)(GLuint index, GLshort x, GLshort y, GLshort z); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3SARBPROC)(GLuint index, GLshort x, GLshort y, GLshort z); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3SVPROC)(GLuint index, const GLshort * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3SVARBPROC)(GLuint index, const GLshort * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NBVPROC)(GLuint index, const GLbyte * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NBVARBPROC)(GLuint index, const GLbyte * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NIVPROC)(GLuint index, const GLint * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NIVARBPROC)(GLuint index, const GLint * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NSVPROC)(GLuint index, const GLshort * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NSVARBPROC)(GLuint index, const GLshort * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NUBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NUBARBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NUBVPROC)(GLuint index, const GLubyte * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NUBVARBPROC)(GLuint index, const GLubyte * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NUIVPROC)(GLuint index, const GLuint * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NUIVARBPROC)(GLuint index, const GLuint * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NUSVPROC)(GLuint index, const GLushort * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NUSVARBPROC)(GLuint index, const GLushort * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4BVPROC)(GLuint index, const GLbyte * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4BVARBPROC)(GLuint index, const GLbyte * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4DARBPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4DVPROC)(GLuint index, const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4DVARBPROC)(GLuint index, const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4FARBPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4FVARBPROC)(GLuint index, const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4IVPROC)(GLuint index, const GLint * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4IVARBPROC)(GLuint index, const GLint * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4SPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4SARBPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4SVPROC)(GLuint index, const GLshort * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4SVARBPROC)(GLuint index, const GLshort * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4UBVPROC)(GLuint index, const GLubyte * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4UBVARBPROC)(GLuint index, const GLubyte * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4UIVPROC)(GLuint index, const GLuint * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4UIVARBPROC)(GLuint index, const GLuint * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4USVPROC)(GLuint index, const GLushort * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4USVARBPROC)(GLuint index, const GLushort * v); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer); typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBPOINTERARBPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer); typedef void (GLAD_API_PTR *PFNGLVERTEXPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void * pointer); typedef void (GLAD_API_PTR *PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height); typedef void (GLAD_API_PTR *PFNGLWINDOWPOS2DPROC)(GLdouble x, GLdouble y); typedef void (GLAD_API_PTR *PFNGLWINDOWPOS2DVPROC)(const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLWINDOWPOS2FPROC)(GLfloat x, GLfloat y); typedef void (GLAD_API_PTR *PFNGLWINDOWPOS2FVPROC)(const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLWINDOWPOS2IPROC)(GLint x, GLint y); typedef void (GLAD_API_PTR *PFNGLWINDOWPOS2IVPROC)(const GLint * v); typedef void (GLAD_API_PTR *PFNGLWINDOWPOS2SPROC)(GLshort x, GLshort y); typedef void (GLAD_API_PTR *PFNGLWINDOWPOS2SVPROC)(const GLshort * v); typedef void (GLAD_API_PTR *PFNGLWINDOWPOS3DPROC)(GLdouble x, GLdouble y, GLdouble z); typedef void (GLAD_API_PTR *PFNGLWINDOWPOS3DVPROC)(const GLdouble * v); typedef void (GLAD_API_PTR *PFNGLWINDOWPOS3FPROC)(GLfloat x, GLfloat y, GLfloat z); typedef void (GLAD_API_PTR *PFNGLWINDOWPOS3FVPROC)(const GLfloat * v); typedef void (GLAD_API_PTR *PFNGLWINDOWPOS3IPROC)(GLint x, GLint y, GLint z); typedef void (GLAD_API_PTR *PFNGLWINDOWPOS3IVPROC)(const GLint * v); typedef void (GLAD_API_PTR *PFNGLWINDOWPOS3SPROC)(GLshort x, GLshort y, GLshort z); typedef void (GLAD_API_PTR *PFNGLWINDOWPOS3SVPROC)(const GLshort * v); GLAD_API_CALL PFNGLACCUMPROC glad_glAccum; #define glAccum glad_glAccum GLAD_API_CALL PFNGLACTIVETEXTUREPROC glad_glActiveTexture; #define glActiveTexture glad_glActiveTexture GLAD_API_CALL PFNGLALPHAFUNCPROC glad_glAlphaFunc; #define glAlphaFunc glad_glAlphaFunc GLAD_API_CALL PFNGLARETEXTURESRESIDENTPROC glad_glAreTexturesResident; #define glAreTexturesResident glad_glAreTexturesResident GLAD_API_CALL PFNGLARRAYELEMENTPROC glad_glArrayElement; #define glArrayElement glad_glArrayElement GLAD_API_CALL PFNGLATTACHSHADERPROC glad_glAttachShader; #define glAttachShader glad_glAttachShader GLAD_API_CALL PFNGLBEGINPROC glad_glBegin; #define glBegin glad_glBegin GLAD_API_CALL PFNGLBEGINOCCLUSIONQUERYNVPROC glad_glBeginOcclusionQueryNV; #define glBeginOcclusionQueryNV glad_glBeginOcclusionQueryNV GLAD_API_CALL PFNGLBEGINQUERYPROC glad_glBeginQuery; #define glBeginQuery glad_glBeginQuery GLAD_API_CALL PFNGLBEGINQUERYARBPROC glad_glBeginQueryARB; #define glBeginQueryARB glad_glBeginQueryARB GLAD_API_CALL PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation; #define glBindAttribLocation glad_glBindAttribLocation GLAD_API_CALL PFNGLBINDBUFFERPROC glad_glBindBuffer; #define glBindBuffer glad_glBindBuffer GLAD_API_CALL PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer; #define glBindFramebuffer glad_glBindFramebuffer GLAD_API_CALL PFNGLBINDFRAMEBUFFEREXTPROC glad_glBindFramebufferEXT; #define glBindFramebufferEXT glad_glBindFramebufferEXT GLAD_API_CALL PFNGLBINDPROGRAMARBPROC glad_glBindProgramARB; #define glBindProgramARB glad_glBindProgramARB GLAD_API_CALL PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer; #define glBindRenderbuffer glad_glBindRenderbuffer GLAD_API_CALL PFNGLBINDRENDERBUFFEREXTPROC glad_glBindRenderbufferEXT; #define glBindRenderbufferEXT glad_glBindRenderbufferEXT GLAD_API_CALL PFNGLBINDTEXTUREPROC glad_glBindTexture; #define glBindTexture glad_glBindTexture GLAD_API_CALL PFNGLBITMAPPROC glad_glBitmap; #define glBitmap glad_glBitmap GLAD_API_CALL PFNGLBLENDCOLORPROC glad_glBlendColor; #define glBlendColor glad_glBlendColor GLAD_API_CALL PFNGLBLENDEQUATIONPROC glad_glBlendEquation; #define glBlendEquation glad_glBlendEquation GLAD_API_CALL PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate; #define glBlendEquationSeparate glad_glBlendEquationSeparate GLAD_API_CALL PFNGLBLENDFUNCPROC glad_glBlendFunc; #define glBlendFunc glad_glBlendFunc GLAD_API_CALL PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate; #define glBlendFuncSeparate glad_glBlendFuncSeparate GLAD_API_CALL PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer; #define glBlitFramebuffer glad_glBlitFramebuffer GLAD_API_CALL PFNGLBUFFERDATAPROC glad_glBufferData; #define glBufferData glad_glBufferData GLAD_API_CALL PFNGLBUFFERSUBDATAPROC glad_glBufferSubData; #define glBufferSubData glad_glBufferSubData GLAD_API_CALL PFNGLCALLLISTPROC glad_glCallList; #define glCallList glad_glCallList GLAD_API_CALL PFNGLCALLLISTSPROC glad_glCallLists; #define glCallLists glad_glCallLists GLAD_API_CALL PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus; #define glCheckFramebufferStatus glad_glCheckFramebufferStatus GLAD_API_CALL PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC glad_glCheckFramebufferStatusEXT; #define glCheckFramebufferStatusEXT glad_glCheckFramebufferStatusEXT GLAD_API_CALL PFNGLCLEARPROC glad_glClear; #define glClear glad_glClear GLAD_API_CALL PFNGLCLEARACCUMPROC glad_glClearAccum; #define glClearAccum glad_glClearAccum GLAD_API_CALL PFNGLCLEARCOLORPROC glad_glClearColor; #define glClearColor glad_glClearColor GLAD_API_CALL PFNGLCLEARDEPTHPROC glad_glClearDepth; #define glClearDepth glad_glClearDepth GLAD_API_CALL PFNGLCLEARINDEXPROC glad_glClearIndex; #define glClearIndex glad_glClearIndex GLAD_API_CALL PFNGLCLEARSTENCILPROC glad_glClearStencil; #define glClearStencil glad_glClearStencil GLAD_API_CALL PFNGLCLIENTACTIVETEXTUREPROC glad_glClientActiveTexture; #define glClientActiveTexture glad_glClientActiveTexture GLAD_API_CALL PFNGLCLIPPLANEPROC glad_glClipPlane; #define glClipPlane glad_glClipPlane GLAD_API_CALL PFNGLCOLOR3BPROC glad_glColor3b; #define glColor3b glad_glColor3b GLAD_API_CALL PFNGLCOLOR3BVPROC glad_glColor3bv; #define glColor3bv glad_glColor3bv GLAD_API_CALL PFNGLCOLOR3DPROC glad_glColor3d; #define glColor3d glad_glColor3d GLAD_API_CALL PFNGLCOLOR3DVPROC glad_glColor3dv; #define glColor3dv glad_glColor3dv GLAD_API_CALL PFNGLCOLOR3FPROC glad_glColor3f; #define glColor3f glad_glColor3f GLAD_API_CALL PFNGLCOLOR3FVPROC glad_glColor3fv; #define glColor3fv glad_glColor3fv GLAD_API_CALL PFNGLCOLOR3IPROC glad_glColor3i; #define glColor3i glad_glColor3i GLAD_API_CALL PFNGLCOLOR3IVPROC glad_glColor3iv; #define glColor3iv glad_glColor3iv GLAD_API_CALL PFNGLCOLOR3SPROC glad_glColor3s; #define glColor3s glad_glColor3s GLAD_API_CALL PFNGLCOLOR3SVPROC glad_glColor3sv; #define glColor3sv glad_glColor3sv GLAD_API_CALL PFNGLCOLOR3UBPROC glad_glColor3ub; #define glColor3ub glad_glColor3ub GLAD_API_CALL PFNGLCOLOR3UBVPROC glad_glColor3ubv; #define glColor3ubv glad_glColor3ubv GLAD_API_CALL PFNGLCOLOR3UIPROC glad_glColor3ui; #define glColor3ui glad_glColor3ui GLAD_API_CALL PFNGLCOLOR3UIVPROC glad_glColor3uiv; #define glColor3uiv glad_glColor3uiv GLAD_API_CALL PFNGLCOLOR3USPROC glad_glColor3us; #define glColor3us glad_glColor3us GLAD_API_CALL PFNGLCOLOR3USVPROC glad_glColor3usv; #define glColor3usv glad_glColor3usv GLAD_API_CALL PFNGLCOLOR4BPROC glad_glColor4b; #define glColor4b glad_glColor4b GLAD_API_CALL PFNGLCOLOR4BVPROC glad_glColor4bv; #define glColor4bv glad_glColor4bv GLAD_API_CALL PFNGLCOLOR4DPROC glad_glColor4d; #define glColor4d glad_glColor4d GLAD_API_CALL PFNGLCOLOR4DVPROC glad_glColor4dv; #define glColor4dv glad_glColor4dv GLAD_API_CALL PFNGLCOLOR4FPROC glad_glColor4f; #define glColor4f glad_glColor4f GLAD_API_CALL PFNGLCOLOR4FVPROC glad_glColor4fv; #define glColor4fv glad_glColor4fv GLAD_API_CALL PFNGLCOLOR4IPROC glad_glColor4i; #define glColor4i glad_glColor4i GLAD_API_CALL PFNGLCOLOR4IVPROC glad_glColor4iv; #define glColor4iv glad_glColor4iv GLAD_API_CALL PFNGLCOLOR4SPROC glad_glColor4s; #define glColor4s glad_glColor4s GLAD_API_CALL PFNGLCOLOR4SVPROC glad_glColor4sv; #define glColor4sv glad_glColor4sv GLAD_API_CALL PFNGLCOLOR4UBPROC glad_glColor4ub; #define glColor4ub glad_glColor4ub GLAD_API_CALL PFNGLCOLOR4UBVPROC glad_glColor4ubv; #define glColor4ubv glad_glColor4ubv GLAD_API_CALL PFNGLCOLOR4UIPROC glad_glColor4ui; #define glColor4ui glad_glColor4ui GLAD_API_CALL PFNGLCOLOR4UIVPROC glad_glColor4uiv; #define glColor4uiv glad_glColor4uiv GLAD_API_CALL PFNGLCOLOR4USPROC glad_glColor4us; #define glColor4us glad_glColor4us GLAD_API_CALL PFNGLCOLOR4USVPROC glad_glColor4usv; #define glColor4usv glad_glColor4usv GLAD_API_CALL PFNGLCOLORMASKPROC glad_glColorMask; #define glColorMask glad_glColorMask GLAD_API_CALL PFNGLCOLORMATERIALPROC glad_glColorMaterial; #define glColorMaterial glad_glColorMaterial GLAD_API_CALL PFNGLCOLORPOINTERPROC glad_glColorPointer; #define glColorPointer glad_glColorPointer GLAD_API_CALL PFNGLCOMPILESHADERPROC glad_glCompileShader; #define glCompileShader glad_glCompileShader GLAD_API_CALL PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D; #define glCompressedTexImage1D glad_glCompressedTexImage1D GLAD_API_CALL PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D; #define glCompressedTexImage2D glad_glCompressedTexImage2D GLAD_API_CALL PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D; #define glCompressedTexImage3D glad_glCompressedTexImage3D GLAD_API_CALL PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D; #define glCompressedTexSubImage1D glad_glCompressedTexSubImage1D GLAD_API_CALL PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D; #define glCompressedTexSubImage2D glad_glCompressedTexSubImage2D GLAD_API_CALL PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D; #define glCompressedTexSubImage3D glad_glCompressedTexSubImage3D GLAD_API_CALL PFNGLCOPYPIXELSPROC glad_glCopyPixels; #define glCopyPixels glad_glCopyPixels GLAD_API_CALL PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D; #define glCopyTexImage1D glad_glCopyTexImage1D GLAD_API_CALL PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D; #define glCopyTexImage2D glad_glCopyTexImage2D GLAD_API_CALL PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D; #define glCopyTexSubImage1D glad_glCopyTexSubImage1D GLAD_API_CALL PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D; #define glCopyTexSubImage2D glad_glCopyTexSubImage2D GLAD_API_CALL PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D; #define glCopyTexSubImage3D glad_glCopyTexSubImage3D GLAD_API_CALL PFNGLCREATEPROGRAMPROC glad_glCreateProgram; #define glCreateProgram glad_glCreateProgram GLAD_API_CALL PFNGLCREATESHADERPROC glad_glCreateShader; #define glCreateShader glad_glCreateShader GLAD_API_CALL PFNGLCULLFACEPROC glad_glCullFace; #define glCullFace glad_glCullFace GLAD_API_CALL PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers; #define glDeleteBuffers glad_glDeleteBuffers GLAD_API_CALL PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers; #define glDeleteFramebuffers glad_glDeleteFramebuffers GLAD_API_CALL PFNGLDELETEFRAMEBUFFERSEXTPROC glad_glDeleteFramebuffersEXT; #define glDeleteFramebuffersEXT glad_glDeleteFramebuffersEXT GLAD_API_CALL PFNGLDELETELISTSPROC glad_glDeleteLists; #define glDeleteLists glad_glDeleteLists GLAD_API_CALL PFNGLDELETEOCCLUSIONQUERIESNVPROC glad_glDeleteOcclusionQueriesNV; #define glDeleteOcclusionQueriesNV glad_glDeleteOcclusionQueriesNV GLAD_API_CALL PFNGLDELETEPROGRAMPROC glad_glDeleteProgram; #define glDeleteProgram glad_glDeleteProgram GLAD_API_CALL PFNGLDELETEPROGRAMSARBPROC glad_glDeleteProgramsARB; #define glDeleteProgramsARB glad_glDeleteProgramsARB GLAD_API_CALL PFNGLDELETEQUERIESPROC glad_glDeleteQueries; #define glDeleteQueries glad_glDeleteQueries GLAD_API_CALL PFNGLDELETEQUERIESARBPROC glad_glDeleteQueriesARB; #define glDeleteQueriesARB glad_glDeleteQueriesARB GLAD_API_CALL PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers; #define glDeleteRenderbuffers glad_glDeleteRenderbuffers GLAD_API_CALL PFNGLDELETERENDERBUFFERSEXTPROC glad_glDeleteRenderbuffersEXT; #define glDeleteRenderbuffersEXT glad_glDeleteRenderbuffersEXT GLAD_API_CALL PFNGLDELETESHADERPROC glad_glDeleteShader; #define glDeleteShader glad_glDeleteShader GLAD_API_CALL PFNGLDELETETEXTURESPROC glad_glDeleteTextures; #define glDeleteTextures glad_glDeleteTextures GLAD_API_CALL PFNGLDEPTHBOUNDSEXTPROC glad_glDepthBoundsEXT; #define glDepthBoundsEXT glad_glDepthBoundsEXT GLAD_API_CALL PFNGLDEPTHFUNCPROC glad_glDepthFunc; #define glDepthFunc glad_glDepthFunc GLAD_API_CALL PFNGLDEPTHMASKPROC glad_glDepthMask; #define glDepthMask glad_glDepthMask GLAD_API_CALL PFNGLDEPTHRANGEPROC glad_glDepthRange; #define glDepthRange glad_glDepthRange GLAD_API_CALL PFNGLDETACHSHADERPROC glad_glDetachShader; #define glDetachShader glad_glDetachShader GLAD_API_CALL PFNGLDISABLEPROC glad_glDisable; #define glDisable glad_glDisable GLAD_API_CALL PFNGLDISABLECLIENTSTATEPROC glad_glDisableClientState; #define glDisableClientState glad_glDisableClientState GLAD_API_CALL PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray; #define glDisableVertexAttribArray glad_glDisableVertexAttribArray GLAD_API_CALL PFNGLDISABLEVERTEXATTRIBARRAYARBPROC glad_glDisableVertexAttribArrayARB; #define glDisableVertexAttribArrayARB glad_glDisableVertexAttribArrayARB GLAD_API_CALL PFNGLDRAWARRAYSPROC glad_glDrawArrays; #define glDrawArrays glad_glDrawArrays GLAD_API_CALL PFNGLDRAWBUFFERPROC glad_glDrawBuffer; #define glDrawBuffer glad_glDrawBuffer GLAD_API_CALL PFNGLDRAWBUFFERSPROC glad_glDrawBuffers; #define glDrawBuffers glad_glDrawBuffers GLAD_API_CALL PFNGLDRAWELEMENTSPROC glad_glDrawElements; #define glDrawElements glad_glDrawElements GLAD_API_CALL PFNGLDRAWPIXELSPROC glad_glDrawPixels; #define glDrawPixels glad_glDrawPixels GLAD_API_CALL PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements; #define glDrawRangeElements glad_glDrawRangeElements GLAD_API_CALL PFNGLEDGEFLAGPROC glad_glEdgeFlag; #define glEdgeFlag glad_glEdgeFlag GLAD_API_CALL PFNGLEDGEFLAGPOINTERPROC glad_glEdgeFlagPointer; #define glEdgeFlagPointer glad_glEdgeFlagPointer GLAD_API_CALL PFNGLEDGEFLAGVPROC glad_glEdgeFlagv; #define glEdgeFlagv glad_glEdgeFlagv GLAD_API_CALL PFNGLENABLEPROC glad_glEnable; #define glEnable glad_glEnable GLAD_API_CALL PFNGLENABLECLIENTSTATEPROC glad_glEnableClientState; #define glEnableClientState glad_glEnableClientState GLAD_API_CALL PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray; #define glEnableVertexAttribArray glad_glEnableVertexAttribArray GLAD_API_CALL PFNGLENABLEVERTEXATTRIBARRAYARBPROC glad_glEnableVertexAttribArrayARB; #define glEnableVertexAttribArrayARB glad_glEnableVertexAttribArrayARB GLAD_API_CALL PFNGLENDPROC glad_glEnd; #define glEnd glad_glEnd GLAD_API_CALL PFNGLENDLISTPROC glad_glEndList; #define glEndList glad_glEndList GLAD_API_CALL PFNGLENDOCCLUSIONQUERYNVPROC glad_glEndOcclusionQueryNV; #define glEndOcclusionQueryNV glad_glEndOcclusionQueryNV GLAD_API_CALL PFNGLENDQUERYPROC glad_glEndQuery; #define glEndQuery glad_glEndQuery GLAD_API_CALL PFNGLENDQUERYARBPROC glad_glEndQueryARB; #define glEndQueryARB glad_glEndQueryARB GLAD_API_CALL PFNGLEVALCOORD1DPROC glad_glEvalCoord1d; #define glEvalCoord1d glad_glEvalCoord1d GLAD_API_CALL PFNGLEVALCOORD1DVPROC glad_glEvalCoord1dv; #define glEvalCoord1dv glad_glEvalCoord1dv GLAD_API_CALL PFNGLEVALCOORD1FPROC glad_glEvalCoord1f; #define glEvalCoord1f glad_glEvalCoord1f GLAD_API_CALL PFNGLEVALCOORD1FVPROC glad_glEvalCoord1fv; #define glEvalCoord1fv glad_glEvalCoord1fv GLAD_API_CALL PFNGLEVALCOORD2DPROC glad_glEvalCoord2d; #define glEvalCoord2d glad_glEvalCoord2d GLAD_API_CALL PFNGLEVALCOORD2DVPROC glad_glEvalCoord2dv; #define glEvalCoord2dv glad_glEvalCoord2dv GLAD_API_CALL PFNGLEVALCOORD2FPROC glad_glEvalCoord2f; #define glEvalCoord2f glad_glEvalCoord2f GLAD_API_CALL PFNGLEVALCOORD2FVPROC glad_glEvalCoord2fv; #define glEvalCoord2fv glad_glEvalCoord2fv GLAD_API_CALL PFNGLEVALMESH1PROC glad_glEvalMesh1; #define glEvalMesh1 glad_glEvalMesh1 GLAD_API_CALL PFNGLEVALMESH2PROC glad_glEvalMesh2; #define glEvalMesh2 glad_glEvalMesh2 GLAD_API_CALL PFNGLEVALPOINT1PROC glad_glEvalPoint1; #define glEvalPoint1 glad_glEvalPoint1 GLAD_API_CALL PFNGLEVALPOINT2PROC glad_glEvalPoint2; #define glEvalPoint2 glad_glEvalPoint2 GLAD_API_CALL PFNGLFEEDBACKBUFFERPROC glad_glFeedbackBuffer; #define glFeedbackBuffer glad_glFeedbackBuffer GLAD_API_CALL PFNGLFINISHPROC glad_glFinish; #define glFinish glad_glFinish GLAD_API_CALL PFNGLFLUSHPROC glad_glFlush; #define glFlush glad_glFlush GLAD_API_CALL PFNGLFOGCOORDPOINTERPROC glad_glFogCoordPointer; #define glFogCoordPointer glad_glFogCoordPointer GLAD_API_CALL PFNGLFOGCOORDDPROC glad_glFogCoordd; #define glFogCoordd glad_glFogCoordd GLAD_API_CALL PFNGLFOGCOORDDVPROC glad_glFogCoorddv; #define glFogCoorddv glad_glFogCoorddv GLAD_API_CALL PFNGLFOGCOORDFPROC glad_glFogCoordf; #define glFogCoordf glad_glFogCoordf GLAD_API_CALL PFNGLFOGCOORDFVPROC glad_glFogCoordfv; #define glFogCoordfv glad_glFogCoordfv GLAD_API_CALL PFNGLFOGFPROC glad_glFogf; #define glFogf glad_glFogf GLAD_API_CALL PFNGLFOGFVPROC glad_glFogfv; #define glFogfv glad_glFogfv GLAD_API_CALL PFNGLFOGIPROC glad_glFogi; #define glFogi glad_glFogi GLAD_API_CALL PFNGLFOGIVPROC glad_glFogiv; #define glFogiv glad_glFogiv GLAD_API_CALL PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer; #define glFramebufferRenderbuffer glad_glFramebufferRenderbuffer GLAD_API_CALL PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC glad_glFramebufferRenderbufferEXT; #define glFramebufferRenderbufferEXT glad_glFramebufferRenderbufferEXT GLAD_API_CALL PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D; #define glFramebufferTexture1D glad_glFramebufferTexture1D GLAD_API_CALL PFNGLFRAMEBUFFERTEXTURE1DEXTPROC glad_glFramebufferTexture1DEXT; #define glFramebufferTexture1DEXT glad_glFramebufferTexture1DEXT GLAD_API_CALL PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D; #define glFramebufferTexture2D glad_glFramebufferTexture2D GLAD_API_CALL PFNGLFRAMEBUFFERTEXTURE2DEXTPROC glad_glFramebufferTexture2DEXT; #define glFramebufferTexture2DEXT glad_glFramebufferTexture2DEXT GLAD_API_CALL PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D; #define glFramebufferTexture3D glad_glFramebufferTexture3D GLAD_API_CALL PFNGLFRAMEBUFFERTEXTURE3DEXTPROC glad_glFramebufferTexture3DEXT; #define glFramebufferTexture3DEXT glad_glFramebufferTexture3DEXT GLAD_API_CALL PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer; #define glFramebufferTextureLayer glad_glFramebufferTextureLayer GLAD_API_CALL PFNGLFRONTFACEPROC glad_glFrontFace; #define glFrontFace glad_glFrontFace GLAD_API_CALL PFNGLFRUSTUMPROC glad_glFrustum; #define glFrustum glad_glFrustum GLAD_API_CALL PFNGLGENBUFFERSPROC glad_glGenBuffers; #define glGenBuffers glad_glGenBuffers GLAD_API_CALL PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers; #define glGenFramebuffers glad_glGenFramebuffers GLAD_API_CALL PFNGLGENFRAMEBUFFERSEXTPROC glad_glGenFramebuffersEXT; #define glGenFramebuffersEXT glad_glGenFramebuffersEXT GLAD_API_CALL PFNGLGENLISTSPROC glad_glGenLists; #define glGenLists glad_glGenLists GLAD_API_CALL PFNGLGENOCCLUSIONQUERIESNVPROC glad_glGenOcclusionQueriesNV; #define glGenOcclusionQueriesNV glad_glGenOcclusionQueriesNV GLAD_API_CALL PFNGLGENPROGRAMSARBPROC glad_glGenProgramsARB; #define glGenProgramsARB glad_glGenProgramsARB GLAD_API_CALL PFNGLGENQUERIESPROC glad_glGenQueries; #define glGenQueries glad_glGenQueries GLAD_API_CALL PFNGLGENQUERIESARBPROC glad_glGenQueriesARB; #define glGenQueriesARB glad_glGenQueriesARB GLAD_API_CALL PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers; #define glGenRenderbuffers glad_glGenRenderbuffers GLAD_API_CALL PFNGLGENRENDERBUFFERSEXTPROC glad_glGenRenderbuffersEXT; #define glGenRenderbuffersEXT glad_glGenRenderbuffersEXT GLAD_API_CALL PFNGLGENTEXTURESPROC glad_glGenTextures; #define glGenTextures glad_glGenTextures GLAD_API_CALL PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap; #define glGenerateMipmap glad_glGenerateMipmap GLAD_API_CALL PFNGLGENERATEMIPMAPEXTPROC glad_glGenerateMipmapEXT; #define glGenerateMipmapEXT glad_glGenerateMipmapEXT GLAD_API_CALL PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib; #define glGetActiveAttrib glad_glGetActiveAttrib GLAD_API_CALL PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform; #define glGetActiveUniform glad_glGetActiveUniform GLAD_API_CALL PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders; #define glGetAttachedShaders glad_glGetAttachedShaders GLAD_API_CALL PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation; #define glGetAttribLocation glad_glGetAttribLocation GLAD_API_CALL PFNGLGETBOOLEANVPROC glad_glGetBooleanv; #define glGetBooleanv glad_glGetBooleanv GLAD_API_CALL PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv; #define glGetBufferParameteriv glad_glGetBufferParameteriv GLAD_API_CALL PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv; #define glGetBufferPointerv glad_glGetBufferPointerv GLAD_API_CALL PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData; #define glGetBufferSubData glad_glGetBufferSubData GLAD_API_CALL PFNGLGETCLIPPLANEPROC glad_glGetClipPlane; #define glGetClipPlane glad_glGetClipPlane GLAD_API_CALL PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage; #define glGetCompressedTexImage glad_glGetCompressedTexImage GLAD_API_CALL PFNGLGETDOUBLEVPROC glad_glGetDoublev; #define glGetDoublev glad_glGetDoublev GLAD_API_CALL PFNGLGETERRORPROC glad_glGetError; #define glGetError glad_glGetError GLAD_API_CALL PFNGLGETFLOATVPROC glad_glGetFloatv; #define glGetFloatv glad_glGetFloatv GLAD_API_CALL PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv; #define glGetFramebufferAttachmentParameteriv glad_glGetFramebufferAttachmentParameteriv GLAD_API_CALL PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC glad_glGetFramebufferAttachmentParameterivEXT; #define glGetFramebufferAttachmentParameterivEXT glad_glGetFramebufferAttachmentParameterivEXT GLAD_API_CALL PFNGLGETINTEGERVPROC glad_glGetIntegerv; #define glGetIntegerv glad_glGetIntegerv GLAD_API_CALL PFNGLGETLIGHTFVPROC glad_glGetLightfv; #define glGetLightfv glad_glGetLightfv GLAD_API_CALL PFNGLGETLIGHTIVPROC glad_glGetLightiv; #define glGetLightiv glad_glGetLightiv GLAD_API_CALL PFNGLGETMAPDVPROC glad_glGetMapdv; #define glGetMapdv glad_glGetMapdv GLAD_API_CALL PFNGLGETMAPFVPROC glad_glGetMapfv; #define glGetMapfv glad_glGetMapfv GLAD_API_CALL PFNGLGETMAPIVPROC glad_glGetMapiv; #define glGetMapiv glad_glGetMapiv GLAD_API_CALL PFNGLGETMATERIALFVPROC glad_glGetMaterialfv; #define glGetMaterialfv glad_glGetMaterialfv GLAD_API_CALL PFNGLGETMATERIALIVPROC glad_glGetMaterialiv; #define glGetMaterialiv glad_glGetMaterialiv GLAD_API_CALL PFNGLGETOCCLUSIONQUERYIVNVPROC glad_glGetOcclusionQueryivNV; #define glGetOcclusionQueryivNV glad_glGetOcclusionQueryivNV GLAD_API_CALL PFNGLGETOCCLUSIONQUERYUIVNVPROC glad_glGetOcclusionQueryuivNV; #define glGetOcclusionQueryuivNV glad_glGetOcclusionQueryuivNV GLAD_API_CALL PFNGLGETPIXELMAPFVPROC glad_glGetPixelMapfv; #define glGetPixelMapfv glad_glGetPixelMapfv GLAD_API_CALL PFNGLGETPIXELMAPUIVPROC glad_glGetPixelMapuiv; #define glGetPixelMapuiv glad_glGetPixelMapuiv GLAD_API_CALL PFNGLGETPIXELMAPUSVPROC glad_glGetPixelMapusv; #define glGetPixelMapusv glad_glGetPixelMapusv GLAD_API_CALL PFNGLGETPOINTERVPROC glad_glGetPointerv; #define glGetPointerv glad_glGetPointerv GLAD_API_CALL PFNGLGETPOLYGONSTIPPLEPROC glad_glGetPolygonStipple; #define glGetPolygonStipple glad_glGetPolygonStipple GLAD_API_CALL PFNGLGETPROGRAMENVPARAMETERDVARBPROC glad_glGetProgramEnvParameterdvARB; #define glGetProgramEnvParameterdvARB glad_glGetProgramEnvParameterdvARB GLAD_API_CALL PFNGLGETPROGRAMENVPARAMETERFVARBPROC glad_glGetProgramEnvParameterfvARB; #define glGetProgramEnvParameterfvARB glad_glGetProgramEnvParameterfvARB GLAD_API_CALL PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog; #define glGetProgramInfoLog glad_glGetProgramInfoLog GLAD_API_CALL PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC glad_glGetProgramLocalParameterdvARB; #define glGetProgramLocalParameterdvARB glad_glGetProgramLocalParameterdvARB GLAD_API_CALL PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC glad_glGetProgramLocalParameterfvARB; #define glGetProgramLocalParameterfvARB glad_glGetProgramLocalParameterfvARB GLAD_API_CALL PFNGLGETPROGRAMSTRINGARBPROC glad_glGetProgramStringARB; #define glGetProgramStringARB glad_glGetProgramStringARB GLAD_API_CALL PFNGLGETPROGRAMIVPROC glad_glGetProgramiv; #define glGetProgramiv glad_glGetProgramiv GLAD_API_CALL PFNGLGETPROGRAMIVARBPROC glad_glGetProgramivARB; #define glGetProgramivARB glad_glGetProgramivARB GLAD_API_CALL PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv; #define glGetQueryObjectiv glad_glGetQueryObjectiv GLAD_API_CALL PFNGLGETQUERYOBJECTIVARBPROC glad_glGetQueryObjectivARB; #define glGetQueryObjectivARB glad_glGetQueryObjectivARB GLAD_API_CALL PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv; #define glGetQueryObjectuiv glad_glGetQueryObjectuiv GLAD_API_CALL PFNGLGETQUERYOBJECTUIVARBPROC glad_glGetQueryObjectuivARB; #define glGetQueryObjectuivARB glad_glGetQueryObjectuivARB GLAD_API_CALL PFNGLGETQUERYIVPROC glad_glGetQueryiv; #define glGetQueryiv glad_glGetQueryiv GLAD_API_CALL PFNGLGETQUERYIVARBPROC glad_glGetQueryivARB; #define glGetQueryivARB glad_glGetQueryivARB GLAD_API_CALL PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv; #define glGetRenderbufferParameteriv glad_glGetRenderbufferParameteriv GLAD_API_CALL PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC glad_glGetRenderbufferParameterivEXT; #define glGetRenderbufferParameterivEXT glad_glGetRenderbufferParameterivEXT GLAD_API_CALL PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog; #define glGetShaderInfoLog glad_glGetShaderInfoLog GLAD_API_CALL PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource; #define glGetShaderSource glad_glGetShaderSource GLAD_API_CALL PFNGLGETSHADERIVPROC glad_glGetShaderiv; #define glGetShaderiv glad_glGetShaderiv GLAD_API_CALL PFNGLGETSTRINGPROC glad_glGetString; #define glGetString glad_glGetString GLAD_API_CALL PFNGLGETTEXENVFVPROC glad_glGetTexEnvfv; #define glGetTexEnvfv glad_glGetTexEnvfv GLAD_API_CALL PFNGLGETTEXENVIVPROC glad_glGetTexEnviv; #define glGetTexEnviv glad_glGetTexEnviv GLAD_API_CALL PFNGLGETTEXGENDVPROC glad_glGetTexGendv; #define glGetTexGendv glad_glGetTexGendv GLAD_API_CALL PFNGLGETTEXGENFVPROC glad_glGetTexGenfv; #define glGetTexGenfv glad_glGetTexGenfv GLAD_API_CALL PFNGLGETTEXGENIVPROC glad_glGetTexGeniv; #define glGetTexGeniv glad_glGetTexGeniv GLAD_API_CALL PFNGLGETTEXIMAGEPROC glad_glGetTexImage; #define glGetTexImage glad_glGetTexImage GLAD_API_CALL PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv; #define glGetTexLevelParameterfv glad_glGetTexLevelParameterfv GLAD_API_CALL PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv; #define glGetTexLevelParameteriv glad_glGetTexLevelParameteriv GLAD_API_CALL PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv; #define glGetTexParameterfv glad_glGetTexParameterfv GLAD_API_CALL PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv; #define glGetTexParameteriv glad_glGetTexParameteriv GLAD_API_CALL PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation; #define glGetUniformLocation glad_glGetUniformLocation GLAD_API_CALL PFNGLGETUNIFORMFVPROC glad_glGetUniformfv; #define glGetUniformfv glad_glGetUniformfv GLAD_API_CALL PFNGLGETUNIFORMIVPROC glad_glGetUniformiv; #define glGetUniformiv glad_glGetUniformiv GLAD_API_CALL PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv; #define glGetVertexAttribPointerv glad_glGetVertexAttribPointerv GLAD_API_CALL PFNGLGETVERTEXATTRIBPOINTERVARBPROC glad_glGetVertexAttribPointervARB; #define glGetVertexAttribPointervARB glad_glGetVertexAttribPointervARB GLAD_API_CALL PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv; #define glGetVertexAttribdv glad_glGetVertexAttribdv GLAD_API_CALL PFNGLGETVERTEXATTRIBDVARBPROC glad_glGetVertexAttribdvARB; #define glGetVertexAttribdvARB glad_glGetVertexAttribdvARB GLAD_API_CALL PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv; #define glGetVertexAttribfv glad_glGetVertexAttribfv GLAD_API_CALL PFNGLGETVERTEXATTRIBFVARBPROC glad_glGetVertexAttribfvARB; #define glGetVertexAttribfvARB glad_glGetVertexAttribfvARB GLAD_API_CALL PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv; #define glGetVertexAttribiv glad_glGetVertexAttribiv GLAD_API_CALL PFNGLGETVERTEXATTRIBIVARBPROC glad_glGetVertexAttribivARB; #define glGetVertexAttribivARB glad_glGetVertexAttribivARB GLAD_API_CALL PFNGLHINTPROC glad_glHint; #define glHint glad_glHint GLAD_API_CALL PFNGLINDEXMASKPROC glad_glIndexMask; #define glIndexMask glad_glIndexMask GLAD_API_CALL PFNGLINDEXPOINTERPROC glad_glIndexPointer; #define glIndexPointer glad_glIndexPointer GLAD_API_CALL PFNGLINDEXDPROC glad_glIndexd; #define glIndexd glad_glIndexd GLAD_API_CALL PFNGLINDEXDVPROC glad_glIndexdv; #define glIndexdv glad_glIndexdv GLAD_API_CALL PFNGLINDEXFPROC glad_glIndexf; #define glIndexf glad_glIndexf GLAD_API_CALL PFNGLINDEXFVPROC glad_glIndexfv; #define glIndexfv glad_glIndexfv GLAD_API_CALL PFNGLINDEXIPROC glad_glIndexi; #define glIndexi glad_glIndexi GLAD_API_CALL PFNGLINDEXIVPROC glad_glIndexiv; #define glIndexiv glad_glIndexiv GLAD_API_CALL PFNGLINDEXSPROC glad_glIndexs; #define glIndexs glad_glIndexs GLAD_API_CALL PFNGLINDEXSVPROC glad_glIndexsv; #define glIndexsv glad_glIndexsv GLAD_API_CALL PFNGLINDEXUBPROC glad_glIndexub; #define glIndexub glad_glIndexub GLAD_API_CALL PFNGLINDEXUBVPROC glad_glIndexubv; #define glIndexubv glad_glIndexubv GLAD_API_CALL PFNGLINITNAMESPROC glad_glInitNames; #define glInitNames glad_glInitNames GLAD_API_CALL PFNGLINTERLEAVEDARRAYSPROC glad_glInterleavedArrays; #define glInterleavedArrays glad_glInterleavedArrays GLAD_API_CALL PFNGLISBUFFERPROC glad_glIsBuffer; #define glIsBuffer glad_glIsBuffer GLAD_API_CALL PFNGLISENABLEDPROC glad_glIsEnabled; #define glIsEnabled glad_glIsEnabled GLAD_API_CALL PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer; #define glIsFramebuffer glad_glIsFramebuffer GLAD_API_CALL PFNGLISFRAMEBUFFEREXTPROC glad_glIsFramebufferEXT; #define glIsFramebufferEXT glad_glIsFramebufferEXT GLAD_API_CALL PFNGLISLISTPROC glad_glIsList; #define glIsList glad_glIsList GLAD_API_CALL PFNGLISOCCLUSIONQUERYNVPROC glad_glIsOcclusionQueryNV; #define glIsOcclusionQueryNV glad_glIsOcclusionQueryNV GLAD_API_CALL PFNGLISPROGRAMPROC glad_glIsProgram; #define glIsProgram glad_glIsProgram GLAD_API_CALL PFNGLISPROGRAMARBPROC glad_glIsProgramARB; #define glIsProgramARB glad_glIsProgramARB GLAD_API_CALL PFNGLISQUERYPROC glad_glIsQuery; #define glIsQuery glad_glIsQuery GLAD_API_CALL PFNGLISQUERYARBPROC glad_glIsQueryARB; #define glIsQueryARB glad_glIsQueryARB GLAD_API_CALL PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer; #define glIsRenderbuffer glad_glIsRenderbuffer GLAD_API_CALL PFNGLISRENDERBUFFEREXTPROC glad_glIsRenderbufferEXT; #define glIsRenderbufferEXT glad_glIsRenderbufferEXT GLAD_API_CALL PFNGLISSHADERPROC glad_glIsShader; #define glIsShader glad_glIsShader GLAD_API_CALL PFNGLISTEXTUREPROC glad_glIsTexture; #define glIsTexture glad_glIsTexture GLAD_API_CALL PFNGLLIGHTMODELFPROC glad_glLightModelf; #define glLightModelf glad_glLightModelf GLAD_API_CALL PFNGLLIGHTMODELFVPROC glad_glLightModelfv; #define glLightModelfv glad_glLightModelfv GLAD_API_CALL PFNGLLIGHTMODELIPROC glad_glLightModeli; #define glLightModeli glad_glLightModeli GLAD_API_CALL PFNGLLIGHTMODELIVPROC glad_glLightModeliv; #define glLightModeliv glad_glLightModeliv GLAD_API_CALL PFNGLLIGHTFPROC glad_glLightf; #define glLightf glad_glLightf GLAD_API_CALL PFNGLLIGHTFVPROC glad_glLightfv; #define glLightfv glad_glLightfv GLAD_API_CALL PFNGLLIGHTIPROC glad_glLighti; #define glLighti glad_glLighti GLAD_API_CALL PFNGLLIGHTIVPROC glad_glLightiv; #define glLightiv glad_glLightiv GLAD_API_CALL PFNGLLINESTIPPLEPROC glad_glLineStipple; #define glLineStipple glad_glLineStipple GLAD_API_CALL PFNGLLINEWIDTHPROC glad_glLineWidth; #define glLineWidth glad_glLineWidth GLAD_API_CALL PFNGLLINKPROGRAMPROC glad_glLinkProgram; #define glLinkProgram glad_glLinkProgram GLAD_API_CALL PFNGLLISTBASEPROC glad_glListBase; #define glListBase glad_glListBase GLAD_API_CALL PFNGLLOADIDENTITYPROC glad_glLoadIdentity; #define glLoadIdentity glad_glLoadIdentity GLAD_API_CALL PFNGLLOADMATRIXDPROC glad_glLoadMatrixd; #define glLoadMatrixd glad_glLoadMatrixd GLAD_API_CALL PFNGLLOADMATRIXFPROC glad_glLoadMatrixf; #define glLoadMatrixf glad_glLoadMatrixf GLAD_API_CALL PFNGLLOADNAMEPROC glad_glLoadName; #define glLoadName glad_glLoadName GLAD_API_CALL PFNGLLOADTRANSPOSEMATRIXDPROC glad_glLoadTransposeMatrixd; #define glLoadTransposeMatrixd glad_glLoadTransposeMatrixd GLAD_API_CALL PFNGLLOADTRANSPOSEMATRIXFPROC glad_glLoadTransposeMatrixf; #define glLoadTransposeMatrixf glad_glLoadTransposeMatrixf GLAD_API_CALL PFNGLLOGICOPPROC glad_glLogicOp; #define glLogicOp glad_glLogicOp GLAD_API_CALL PFNGLMAP1DPROC glad_glMap1d; #define glMap1d glad_glMap1d GLAD_API_CALL PFNGLMAP1FPROC glad_glMap1f; #define glMap1f glad_glMap1f GLAD_API_CALL PFNGLMAP2DPROC glad_glMap2d; #define glMap2d glad_glMap2d GLAD_API_CALL PFNGLMAP2FPROC glad_glMap2f; #define glMap2f glad_glMap2f GLAD_API_CALL PFNGLMAPBUFFERPROC glad_glMapBuffer; #define glMapBuffer glad_glMapBuffer GLAD_API_CALL PFNGLMAPGRID1DPROC glad_glMapGrid1d; #define glMapGrid1d glad_glMapGrid1d GLAD_API_CALL PFNGLMAPGRID1FPROC glad_glMapGrid1f; #define glMapGrid1f glad_glMapGrid1f GLAD_API_CALL PFNGLMAPGRID2DPROC glad_glMapGrid2d; #define glMapGrid2d glad_glMapGrid2d GLAD_API_CALL PFNGLMAPGRID2FPROC glad_glMapGrid2f; #define glMapGrid2f glad_glMapGrid2f GLAD_API_CALL PFNGLMATERIALFPROC glad_glMaterialf; #define glMaterialf glad_glMaterialf GLAD_API_CALL PFNGLMATERIALFVPROC glad_glMaterialfv; #define glMaterialfv glad_glMaterialfv GLAD_API_CALL PFNGLMATERIALIPROC glad_glMateriali; #define glMateriali glad_glMateriali GLAD_API_CALL PFNGLMATERIALIVPROC glad_glMaterialiv; #define glMaterialiv glad_glMaterialiv GLAD_API_CALL PFNGLMATRIXMODEPROC glad_glMatrixMode; #define glMatrixMode glad_glMatrixMode GLAD_API_CALL PFNGLMULTMATRIXDPROC glad_glMultMatrixd; #define glMultMatrixd glad_glMultMatrixd GLAD_API_CALL PFNGLMULTMATRIXFPROC glad_glMultMatrixf; #define glMultMatrixf glad_glMultMatrixf GLAD_API_CALL PFNGLMULTTRANSPOSEMATRIXDPROC glad_glMultTransposeMatrixd; #define glMultTransposeMatrixd glad_glMultTransposeMatrixd GLAD_API_CALL PFNGLMULTTRANSPOSEMATRIXFPROC glad_glMultTransposeMatrixf; #define glMultTransposeMatrixf glad_glMultTransposeMatrixf GLAD_API_CALL PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays; #define glMultiDrawArrays glad_glMultiDrawArrays GLAD_API_CALL PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements; #define glMultiDrawElements glad_glMultiDrawElements GLAD_API_CALL PFNGLMULTITEXCOORD1DPROC glad_glMultiTexCoord1d; #define glMultiTexCoord1d glad_glMultiTexCoord1d GLAD_API_CALL PFNGLMULTITEXCOORD1DVPROC glad_glMultiTexCoord1dv; #define glMultiTexCoord1dv glad_glMultiTexCoord1dv GLAD_API_CALL PFNGLMULTITEXCOORD1FPROC glad_glMultiTexCoord1f; #define glMultiTexCoord1f glad_glMultiTexCoord1f GLAD_API_CALL PFNGLMULTITEXCOORD1FVPROC glad_glMultiTexCoord1fv; #define glMultiTexCoord1fv glad_glMultiTexCoord1fv GLAD_API_CALL PFNGLMULTITEXCOORD1IPROC glad_glMultiTexCoord1i; #define glMultiTexCoord1i glad_glMultiTexCoord1i GLAD_API_CALL PFNGLMULTITEXCOORD1IVPROC glad_glMultiTexCoord1iv; #define glMultiTexCoord1iv glad_glMultiTexCoord1iv GLAD_API_CALL PFNGLMULTITEXCOORD1SPROC glad_glMultiTexCoord1s; #define glMultiTexCoord1s glad_glMultiTexCoord1s GLAD_API_CALL PFNGLMULTITEXCOORD1SVPROC glad_glMultiTexCoord1sv; #define glMultiTexCoord1sv glad_glMultiTexCoord1sv GLAD_API_CALL PFNGLMULTITEXCOORD2DPROC glad_glMultiTexCoord2d; #define glMultiTexCoord2d glad_glMultiTexCoord2d GLAD_API_CALL PFNGLMULTITEXCOORD2DVPROC glad_glMultiTexCoord2dv; #define glMultiTexCoord2dv glad_glMultiTexCoord2dv GLAD_API_CALL PFNGLMULTITEXCOORD2FPROC glad_glMultiTexCoord2f; #define glMultiTexCoord2f glad_glMultiTexCoord2f GLAD_API_CALL PFNGLMULTITEXCOORD2FVPROC glad_glMultiTexCoord2fv; #define glMultiTexCoord2fv glad_glMultiTexCoord2fv GLAD_API_CALL PFNGLMULTITEXCOORD2IPROC glad_glMultiTexCoord2i; #define glMultiTexCoord2i glad_glMultiTexCoord2i GLAD_API_CALL PFNGLMULTITEXCOORD2IVPROC glad_glMultiTexCoord2iv; #define glMultiTexCoord2iv glad_glMultiTexCoord2iv GLAD_API_CALL PFNGLMULTITEXCOORD2SPROC glad_glMultiTexCoord2s; #define glMultiTexCoord2s glad_glMultiTexCoord2s GLAD_API_CALL PFNGLMULTITEXCOORD2SVPROC glad_glMultiTexCoord2sv; #define glMultiTexCoord2sv glad_glMultiTexCoord2sv GLAD_API_CALL PFNGLMULTITEXCOORD3DPROC glad_glMultiTexCoord3d; #define glMultiTexCoord3d glad_glMultiTexCoord3d GLAD_API_CALL PFNGLMULTITEXCOORD3DVPROC glad_glMultiTexCoord3dv; #define glMultiTexCoord3dv glad_glMultiTexCoord3dv GLAD_API_CALL PFNGLMULTITEXCOORD3FPROC glad_glMultiTexCoord3f; #define glMultiTexCoord3f glad_glMultiTexCoord3f GLAD_API_CALL PFNGLMULTITEXCOORD3FVPROC glad_glMultiTexCoord3fv; #define glMultiTexCoord3fv glad_glMultiTexCoord3fv GLAD_API_CALL PFNGLMULTITEXCOORD3IPROC glad_glMultiTexCoord3i; #define glMultiTexCoord3i glad_glMultiTexCoord3i GLAD_API_CALL PFNGLMULTITEXCOORD3IVPROC glad_glMultiTexCoord3iv; #define glMultiTexCoord3iv glad_glMultiTexCoord3iv GLAD_API_CALL PFNGLMULTITEXCOORD3SPROC glad_glMultiTexCoord3s; #define glMultiTexCoord3s glad_glMultiTexCoord3s GLAD_API_CALL PFNGLMULTITEXCOORD3SVPROC glad_glMultiTexCoord3sv; #define glMultiTexCoord3sv glad_glMultiTexCoord3sv GLAD_API_CALL PFNGLMULTITEXCOORD4DPROC glad_glMultiTexCoord4d; #define glMultiTexCoord4d glad_glMultiTexCoord4d GLAD_API_CALL PFNGLMULTITEXCOORD4DVPROC glad_glMultiTexCoord4dv; #define glMultiTexCoord4dv glad_glMultiTexCoord4dv GLAD_API_CALL PFNGLMULTITEXCOORD4FPROC glad_glMultiTexCoord4f; #define glMultiTexCoord4f glad_glMultiTexCoord4f GLAD_API_CALL PFNGLMULTITEXCOORD4FVPROC glad_glMultiTexCoord4fv; #define glMultiTexCoord4fv glad_glMultiTexCoord4fv GLAD_API_CALL PFNGLMULTITEXCOORD4IPROC glad_glMultiTexCoord4i; #define glMultiTexCoord4i glad_glMultiTexCoord4i GLAD_API_CALL PFNGLMULTITEXCOORD4IVPROC glad_glMultiTexCoord4iv; #define glMultiTexCoord4iv glad_glMultiTexCoord4iv GLAD_API_CALL PFNGLMULTITEXCOORD4SPROC glad_glMultiTexCoord4s; #define glMultiTexCoord4s glad_glMultiTexCoord4s GLAD_API_CALL PFNGLMULTITEXCOORD4SVPROC glad_glMultiTexCoord4sv; #define glMultiTexCoord4sv glad_glMultiTexCoord4sv GLAD_API_CALL PFNGLNEWLISTPROC glad_glNewList; #define glNewList glad_glNewList GLAD_API_CALL PFNGLNORMAL3BPROC glad_glNormal3b; #define glNormal3b glad_glNormal3b GLAD_API_CALL PFNGLNORMAL3BVPROC glad_glNormal3bv; #define glNormal3bv glad_glNormal3bv GLAD_API_CALL PFNGLNORMAL3DPROC glad_glNormal3d; #define glNormal3d glad_glNormal3d GLAD_API_CALL PFNGLNORMAL3DVPROC glad_glNormal3dv; #define glNormal3dv glad_glNormal3dv GLAD_API_CALL PFNGLNORMAL3FPROC glad_glNormal3f; #define glNormal3f glad_glNormal3f GLAD_API_CALL PFNGLNORMAL3FVPROC glad_glNormal3fv; #define glNormal3fv glad_glNormal3fv GLAD_API_CALL PFNGLNORMAL3IPROC glad_glNormal3i; #define glNormal3i glad_glNormal3i GLAD_API_CALL PFNGLNORMAL3IVPROC glad_glNormal3iv; #define glNormal3iv glad_glNormal3iv GLAD_API_CALL PFNGLNORMAL3SPROC glad_glNormal3s; #define glNormal3s glad_glNormal3s GLAD_API_CALL PFNGLNORMAL3SVPROC glad_glNormal3sv; #define glNormal3sv glad_glNormal3sv GLAD_API_CALL PFNGLNORMALPOINTERPROC glad_glNormalPointer; #define glNormalPointer glad_glNormalPointer GLAD_API_CALL PFNGLORTHOPROC glad_glOrtho; #define glOrtho glad_glOrtho GLAD_API_CALL PFNGLPASSTHROUGHPROC glad_glPassThrough; #define glPassThrough glad_glPassThrough GLAD_API_CALL PFNGLPIXELMAPFVPROC glad_glPixelMapfv; #define glPixelMapfv glad_glPixelMapfv GLAD_API_CALL PFNGLPIXELMAPUIVPROC glad_glPixelMapuiv; #define glPixelMapuiv glad_glPixelMapuiv GLAD_API_CALL PFNGLPIXELMAPUSVPROC glad_glPixelMapusv; #define glPixelMapusv glad_glPixelMapusv GLAD_API_CALL PFNGLPIXELSTOREFPROC glad_glPixelStoref; #define glPixelStoref glad_glPixelStoref GLAD_API_CALL PFNGLPIXELSTOREIPROC glad_glPixelStorei; #define glPixelStorei glad_glPixelStorei GLAD_API_CALL PFNGLPIXELTRANSFERFPROC glad_glPixelTransferf; #define glPixelTransferf glad_glPixelTransferf GLAD_API_CALL PFNGLPIXELTRANSFERIPROC glad_glPixelTransferi; #define glPixelTransferi glad_glPixelTransferi GLAD_API_CALL PFNGLPIXELZOOMPROC glad_glPixelZoom; #define glPixelZoom glad_glPixelZoom GLAD_API_CALL PFNGLPOINTPARAMETERFPROC glad_glPointParameterf; #define glPointParameterf glad_glPointParameterf GLAD_API_CALL PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv; #define glPointParameterfv glad_glPointParameterfv GLAD_API_CALL PFNGLPOINTPARAMETERIPROC glad_glPointParameteri; #define glPointParameteri glad_glPointParameteri GLAD_API_CALL PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv; #define glPointParameteriv glad_glPointParameteriv GLAD_API_CALL PFNGLPOINTSIZEPROC glad_glPointSize; #define glPointSize glad_glPointSize GLAD_API_CALL PFNGLPOLYGONMODEPROC glad_glPolygonMode; #define glPolygonMode glad_glPolygonMode GLAD_API_CALL PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset; #define glPolygonOffset glad_glPolygonOffset GLAD_API_CALL PFNGLPOLYGONSTIPPLEPROC glad_glPolygonStipple; #define glPolygonStipple glad_glPolygonStipple GLAD_API_CALL PFNGLPOPATTRIBPROC glad_glPopAttrib; #define glPopAttrib glad_glPopAttrib GLAD_API_CALL PFNGLPOPCLIENTATTRIBPROC glad_glPopClientAttrib; #define glPopClientAttrib glad_glPopClientAttrib GLAD_API_CALL PFNGLPOPMATRIXPROC glad_glPopMatrix; #define glPopMatrix glad_glPopMatrix GLAD_API_CALL PFNGLPOPNAMEPROC glad_glPopName; #define glPopName glad_glPopName GLAD_API_CALL PFNGLPRIORITIZETEXTURESPROC glad_glPrioritizeTextures; #define glPrioritizeTextures glad_glPrioritizeTextures GLAD_API_CALL PFNGLPROGRAMENVPARAMETER4DARBPROC glad_glProgramEnvParameter4dARB; #define glProgramEnvParameter4dARB glad_glProgramEnvParameter4dARB GLAD_API_CALL PFNGLPROGRAMENVPARAMETER4DVARBPROC glad_glProgramEnvParameter4dvARB; #define glProgramEnvParameter4dvARB glad_glProgramEnvParameter4dvARB GLAD_API_CALL PFNGLPROGRAMENVPARAMETER4FARBPROC glad_glProgramEnvParameter4fARB; #define glProgramEnvParameter4fARB glad_glProgramEnvParameter4fARB GLAD_API_CALL PFNGLPROGRAMENVPARAMETER4FVARBPROC glad_glProgramEnvParameter4fvARB; #define glProgramEnvParameter4fvARB glad_glProgramEnvParameter4fvARB GLAD_API_CALL PFNGLPROGRAMLOCALPARAMETER4DARBPROC glad_glProgramLocalParameter4dARB; #define glProgramLocalParameter4dARB glad_glProgramLocalParameter4dARB GLAD_API_CALL PFNGLPROGRAMLOCALPARAMETER4DVARBPROC glad_glProgramLocalParameter4dvARB; #define glProgramLocalParameter4dvARB glad_glProgramLocalParameter4dvARB GLAD_API_CALL PFNGLPROGRAMLOCALPARAMETER4FARBPROC glad_glProgramLocalParameter4fARB; #define glProgramLocalParameter4fARB glad_glProgramLocalParameter4fARB GLAD_API_CALL PFNGLPROGRAMLOCALPARAMETER4FVARBPROC glad_glProgramLocalParameter4fvARB; #define glProgramLocalParameter4fvARB glad_glProgramLocalParameter4fvARB GLAD_API_CALL PFNGLPROGRAMSTRINGARBPROC glad_glProgramStringARB; #define glProgramStringARB glad_glProgramStringARB GLAD_API_CALL PFNGLPUSHATTRIBPROC glad_glPushAttrib; #define glPushAttrib glad_glPushAttrib GLAD_API_CALL PFNGLPUSHCLIENTATTRIBPROC glad_glPushClientAttrib; #define glPushClientAttrib glad_glPushClientAttrib GLAD_API_CALL PFNGLPUSHMATRIXPROC glad_glPushMatrix; #define glPushMatrix glad_glPushMatrix GLAD_API_CALL PFNGLPUSHNAMEPROC glad_glPushName; #define glPushName glad_glPushName GLAD_API_CALL PFNGLRASTERPOS2DPROC glad_glRasterPos2d; #define glRasterPos2d glad_glRasterPos2d GLAD_API_CALL PFNGLRASTERPOS2DVPROC glad_glRasterPos2dv; #define glRasterPos2dv glad_glRasterPos2dv GLAD_API_CALL PFNGLRASTERPOS2FPROC glad_glRasterPos2f; #define glRasterPos2f glad_glRasterPos2f GLAD_API_CALL PFNGLRASTERPOS2FVPROC glad_glRasterPos2fv; #define glRasterPos2fv glad_glRasterPos2fv GLAD_API_CALL PFNGLRASTERPOS2IPROC glad_glRasterPos2i; #define glRasterPos2i glad_glRasterPos2i GLAD_API_CALL PFNGLRASTERPOS2IVPROC glad_glRasterPos2iv; #define glRasterPos2iv glad_glRasterPos2iv GLAD_API_CALL PFNGLRASTERPOS2SPROC glad_glRasterPos2s; #define glRasterPos2s glad_glRasterPos2s GLAD_API_CALL PFNGLRASTERPOS2SVPROC glad_glRasterPos2sv; #define glRasterPos2sv glad_glRasterPos2sv GLAD_API_CALL PFNGLRASTERPOS3DPROC glad_glRasterPos3d; #define glRasterPos3d glad_glRasterPos3d GLAD_API_CALL PFNGLRASTERPOS3DVPROC glad_glRasterPos3dv; #define glRasterPos3dv glad_glRasterPos3dv GLAD_API_CALL PFNGLRASTERPOS3FPROC glad_glRasterPos3f; #define glRasterPos3f glad_glRasterPos3f GLAD_API_CALL PFNGLRASTERPOS3FVPROC glad_glRasterPos3fv; #define glRasterPos3fv glad_glRasterPos3fv GLAD_API_CALL PFNGLRASTERPOS3IPROC glad_glRasterPos3i; #define glRasterPos3i glad_glRasterPos3i GLAD_API_CALL PFNGLRASTERPOS3IVPROC glad_glRasterPos3iv; #define glRasterPos3iv glad_glRasterPos3iv GLAD_API_CALL PFNGLRASTERPOS3SPROC glad_glRasterPos3s; #define glRasterPos3s glad_glRasterPos3s GLAD_API_CALL PFNGLRASTERPOS3SVPROC glad_glRasterPos3sv; #define glRasterPos3sv glad_glRasterPos3sv GLAD_API_CALL PFNGLRASTERPOS4DPROC glad_glRasterPos4d; #define glRasterPos4d glad_glRasterPos4d GLAD_API_CALL PFNGLRASTERPOS4DVPROC glad_glRasterPos4dv; #define glRasterPos4dv glad_glRasterPos4dv GLAD_API_CALL PFNGLRASTERPOS4FPROC glad_glRasterPos4f; #define glRasterPos4f glad_glRasterPos4f GLAD_API_CALL PFNGLRASTERPOS4FVPROC glad_glRasterPos4fv; #define glRasterPos4fv glad_glRasterPos4fv GLAD_API_CALL PFNGLRASTERPOS4IPROC glad_glRasterPos4i; #define glRasterPos4i glad_glRasterPos4i GLAD_API_CALL PFNGLRASTERPOS4IVPROC glad_glRasterPos4iv; #define glRasterPos4iv glad_glRasterPos4iv GLAD_API_CALL PFNGLRASTERPOS4SPROC glad_glRasterPos4s; #define glRasterPos4s glad_glRasterPos4s GLAD_API_CALL PFNGLRASTERPOS4SVPROC glad_glRasterPos4sv; #define glRasterPos4sv glad_glRasterPos4sv GLAD_API_CALL PFNGLREADBUFFERPROC glad_glReadBuffer; #define glReadBuffer glad_glReadBuffer GLAD_API_CALL PFNGLREADPIXELSPROC glad_glReadPixels; #define glReadPixels glad_glReadPixels GLAD_API_CALL PFNGLRECTDPROC glad_glRectd; #define glRectd glad_glRectd GLAD_API_CALL PFNGLRECTDVPROC glad_glRectdv; #define glRectdv glad_glRectdv GLAD_API_CALL PFNGLRECTFPROC glad_glRectf; #define glRectf glad_glRectf GLAD_API_CALL PFNGLRECTFVPROC glad_glRectfv; #define glRectfv glad_glRectfv GLAD_API_CALL PFNGLRECTIPROC glad_glRecti; #define glRecti glad_glRecti GLAD_API_CALL PFNGLRECTIVPROC glad_glRectiv; #define glRectiv glad_glRectiv GLAD_API_CALL PFNGLRECTSPROC glad_glRects; #define glRects glad_glRects GLAD_API_CALL PFNGLRECTSVPROC glad_glRectsv; #define glRectsv glad_glRectsv GLAD_API_CALL PFNGLRENDERMODEPROC glad_glRenderMode; #define glRenderMode glad_glRenderMode GLAD_API_CALL PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage; #define glRenderbufferStorage glad_glRenderbufferStorage GLAD_API_CALL PFNGLRENDERBUFFERSTORAGEEXTPROC glad_glRenderbufferStorageEXT; #define glRenderbufferStorageEXT glad_glRenderbufferStorageEXT GLAD_API_CALL PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample; #define glRenderbufferStorageMultisample glad_glRenderbufferStorageMultisample GLAD_API_CALL PFNGLROTATEDPROC glad_glRotated; #define glRotated glad_glRotated GLAD_API_CALL PFNGLROTATEFPROC glad_glRotatef; #define glRotatef glad_glRotatef GLAD_API_CALL PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage; #define glSampleCoverage glad_glSampleCoverage GLAD_API_CALL PFNGLSCALEDPROC glad_glScaled; #define glScaled glad_glScaled GLAD_API_CALL PFNGLSCALEFPROC glad_glScalef; #define glScalef glad_glScalef GLAD_API_CALL PFNGLSCISSORPROC glad_glScissor; #define glScissor glad_glScissor GLAD_API_CALL PFNGLSECONDARYCOLOR3BPROC glad_glSecondaryColor3b; #define glSecondaryColor3b glad_glSecondaryColor3b GLAD_API_CALL PFNGLSECONDARYCOLOR3BVPROC glad_glSecondaryColor3bv; #define glSecondaryColor3bv glad_glSecondaryColor3bv GLAD_API_CALL PFNGLSECONDARYCOLOR3DPROC glad_glSecondaryColor3d; #define glSecondaryColor3d glad_glSecondaryColor3d GLAD_API_CALL PFNGLSECONDARYCOLOR3DVPROC glad_glSecondaryColor3dv; #define glSecondaryColor3dv glad_glSecondaryColor3dv GLAD_API_CALL PFNGLSECONDARYCOLOR3FPROC glad_glSecondaryColor3f; #define glSecondaryColor3f glad_glSecondaryColor3f GLAD_API_CALL PFNGLSECONDARYCOLOR3FVPROC glad_glSecondaryColor3fv; #define glSecondaryColor3fv glad_glSecondaryColor3fv GLAD_API_CALL PFNGLSECONDARYCOLOR3IPROC glad_glSecondaryColor3i; #define glSecondaryColor3i glad_glSecondaryColor3i GLAD_API_CALL PFNGLSECONDARYCOLOR3IVPROC glad_glSecondaryColor3iv; #define glSecondaryColor3iv glad_glSecondaryColor3iv GLAD_API_CALL PFNGLSECONDARYCOLOR3SPROC glad_glSecondaryColor3s; #define glSecondaryColor3s glad_glSecondaryColor3s GLAD_API_CALL PFNGLSECONDARYCOLOR3SVPROC glad_glSecondaryColor3sv; #define glSecondaryColor3sv glad_glSecondaryColor3sv GLAD_API_CALL PFNGLSECONDARYCOLOR3UBPROC glad_glSecondaryColor3ub; #define glSecondaryColor3ub glad_glSecondaryColor3ub GLAD_API_CALL PFNGLSECONDARYCOLOR3UBVPROC glad_glSecondaryColor3ubv; #define glSecondaryColor3ubv glad_glSecondaryColor3ubv GLAD_API_CALL PFNGLSECONDARYCOLOR3UIPROC glad_glSecondaryColor3ui; #define glSecondaryColor3ui glad_glSecondaryColor3ui GLAD_API_CALL PFNGLSECONDARYCOLOR3UIVPROC glad_glSecondaryColor3uiv; #define glSecondaryColor3uiv glad_glSecondaryColor3uiv GLAD_API_CALL PFNGLSECONDARYCOLOR3USPROC glad_glSecondaryColor3us; #define glSecondaryColor3us glad_glSecondaryColor3us GLAD_API_CALL PFNGLSECONDARYCOLOR3USVPROC glad_glSecondaryColor3usv; #define glSecondaryColor3usv glad_glSecondaryColor3usv GLAD_API_CALL PFNGLSECONDARYCOLORPOINTERPROC glad_glSecondaryColorPointer; #define glSecondaryColorPointer glad_glSecondaryColorPointer GLAD_API_CALL PFNGLSELECTBUFFERPROC glad_glSelectBuffer; #define glSelectBuffer glad_glSelectBuffer GLAD_API_CALL PFNGLSHADEMODELPROC glad_glShadeModel; #define glShadeModel glad_glShadeModel GLAD_API_CALL PFNGLSHADERSOURCEPROC glad_glShaderSource; #define glShaderSource glad_glShaderSource GLAD_API_CALL PFNGLSTENCILFUNCPROC glad_glStencilFunc; #define glStencilFunc glad_glStencilFunc GLAD_API_CALL PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate; #define glStencilFuncSeparate glad_glStencilFuncSeparate GLAD_API_CALL PFNGLSTENCILMASKPROC glad_glStencilMask; #define glStencilMask glad_glStencilMask GLAD_API_CALL PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate; #define glStencilMaskSeparate glad_glStencilMaskSeparate GLAD_API_CALL PFNGLSTENCILOPPROC glad_glStencilOp; #define glStencilOp glad_glStencilOp GLAD_API_CALL PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate; #define glStencilOpSeparate glad_glStencilOpSeparate GLAD_API_CALL PFNGLTEXCOORD1DPROC glad_glTexCoord1d; #define glTexCoord1d glad_glTexCoord1d GLAD_API_CALL PFNGLTEXCOORD1DVPROC glad_glTexCoord1dv; #define glTexCoord1dv glad_glTexCoord1dv GLAD_API_CALL PFNGLTEXCOORD1FPROC glad_glTexCoord1f; #define glTexCoord1f glad_glTexCoord1f GLAD_API_CALL PFNGLTEXCOORD1FVPROC glad_glTexCoord1fv; #define glTexCoord1fv glad_glTexCoord1fv GLAD_API_CALL PFNGLTEXCOORD1IPROC glad_glTexCoord1i; #define glTexCoord1i glad_glTexCoord1i GLAD_API_CALL PFNGLTEXCOORD1IVPROC glad_glTexCoord1iv; #define glTexCoord1iv glad_glTexCoord1iv GLAD_API_CALL PFNGLTEXCOORD1SPROC glad_glTexCoord1s; #define glTexCoord1s glad_glTexCoord1s GLAD_API_CALL PFNGLTEXCOORD1SVPROC glad_glTexCoord1sv; #define glTexCoord1sv glad_glTexCoord1sv GLAD_API_CALL PFNGLTEXCOORD2DPROC glad_glTexCoord2d; #define glTexCoord2d glad_glTexCoord2d GLAD_API_CALL PFNGLTEXCOORD2DVPROC glad_glTexCoord2dv; #define glTexCoord2dv glad_glTexCoord2dv GLAD_API_CALL PFNGLTEXCOORD2FPROC glad_glTexCoord2f; #define glTexCoord2f glad_glTexCoord2f GLAD_API_CALL PFNGLTEXCOORD2FVPROC glad_glTexCoord2fv; #define glTexCoord2fv glad_glTexCoord2fv GLAD_API_CALL PFNGLTEXCOORD2IPROC glad_glTexCoord2i; #define glTexCoord2i glad_glTexCoord2i GLAD_API_CALL PFNGLTEXCOORD2IVPROC glad_glTexCoord2iv; #define glTexCoord2iv glad_glTexCoord2iv GLAD_API_CALL PFNGLTEXCOORD2SPROC glad_glTexCoord2s; #define glTexCoord2s glad_glTexCoord2s GLAD_API_CALL PFNGLTEXCOORD2SVPROC glad_glTexCoord2sv; #define glTexCoord2sv glad_glTexCoord2sv GLAD_API_CALL PFNGLTEXCOORD3DPROC glad_glTexCoord3d; #define glTexCoord3d glad_glTexCoord3d GLAD_API_CALL PFNGLTEXCOORD3DVPROC glad_glTexCoord3dv; #define glTexCoord3dv glad_glTexCoord3dv GLAD_API_CALL PFNGLTEXCOORD3FPROC glad_glTexCoord3f; #define glTexCoord3f glad_glTexCoord3f GLAD_API_CALL PFNGLTEXCOORD3FVPROC glad_glTexCoord3fv; #define glTexCoord3fv glad_glTexCoord3fv GLAD_API_CALL PFNGLTEXCOORD3IPROC glad_glTexCoord3i; #define glTexCoord3i glad_glTexCoord3i GLAD_API_CALL PFNGLTEXCOORD3IVPROC glad_glTexCoord3iv; #define glTexCoord3iv glad_glTexCoord3iv GLAD_API_CALL PFNGLTEXCOORD3SPROC glad_glTexCoord3s; #define glTexCoord3s glad_glTexCoord3s GLAD_API_CALL PFNGLTEXCOORD3SVPROC glad_glTexCoord3sv; #define glTexCoord3sv glad_glTexCoord3sv GLAD_API_CALL PFNGLTEXCOORD4DPROC glad_glTexCoord4d; #define glTexCoord4d glad_glTexCoord4d GLAD_API_CALL PFNGLTEXCOORD4DVPROC glad_glTexCoord4dv; #define glTexCoord4dv glad_glTexCoord4dv GLAD_API_CALL PFNGLTEXCOORD4FPROC glad_glTexCoord4f; #define glTexCoord4f glad_glTexCoord4f GLAD_API_CALL PFNGLTEXCOORD4FVPROC glad_glTexCoord4fv; #define glTexCoord4fv glad_glTexCoord4fv GLAD_API_CALL PFNGLTEXCOORD4IPROC glad_glTexCoord4i; #define glTexCoord4i glad_glTexCoord4i GLAD_API_CALL PFNGLTEXCOORD4IVPROC glad_glTexCoord4iv; #define glTexCoord4iv glad_glTexCoord4iv GLAD_API_CALL PFNGLTEXCOORD4SPROC glad_glTexCoord4s; #define glTexCoord4s glad_glTexCoord4s GLAD_API_CALL PFNGLTEXCOORD4SVPROC glad_glTexCoord4sv; #define glTexCoord4sv glad_glTexCoord4sv GLAD_API_CALL PFNGLTEXCOORDPOINTERPROC glad_glTexCoordPointer; #define glTexCoordPointer glad_glTexCoordPointer GLAD_API_CALL PFNGLTEXENVFPROC glad_glTexEnvf; #define glTexEnvf glad_glTexEnvf GLAD_API_CALL PFNGLTEXENVFVPROC glad_glTexEnvfv; #define glTexEnvfv glad_glTexEnvfv GLAD_API_CALL PFNGLTEXENVIPROC glad_glTexEnvi; #define glTexEnvi glad_glTexEnvi GLAD_API_CALL PFNGLTEXENVIVPROC glad_glTexEnviv; #define glTexEnviv glad_glTexEnviv GLAD_API_CALL PFNGLTEXGENDPROC glad_glTexGend; #define glTexGend glad_glTexGend GLAD_API_CALL PFNGLTEXGENDVPROC glad_glTexGendv; #define glTexGendv glad_glTexGendv GLAD_API_CALL PFNGLTEXGENFPROC glad_glTexGenf; #define glTexGenf glad_glTexGenf GLAD_API_CALL PFNGLTEXGENFVPROC glad_glTexGenfv; #define glTexGenfv glad_glTexGenfv GLAD_API_CALL PFNGLTEXGENIPROC glad_glTexGeni; #define glTexGeni glad_glTexGeni GLAD_API_CALL PFNGLTEXGENIVPROC glad_glTexGeniv; #define glTexGeniv glad_glTexGeniv GLAD_API_CALL PFNGLTEXIMAGE1DPROC glad_glTexImage1D; #define glTexImage1D glad_glTexImage1D GLAD_API_CALL PFNGLTEXIMAGE2DPROC glad_glTexImage2D; #define glTexImage2D glad_glTexImage2D GLAD_API_CALL PFNGLTEXIMAGE3DPROC glad_glTexImage3D; #define glTexImage3D glad_glTexImage3D GLAD_API_CALL PFNGLTEXPARAMETERFPROC glad_glTexParameterf; #define glTexParameterf glad_glTexParameterf GLAD_API_CALL PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv; #define glTexParameterfv glad_glTexParameterfv GLAD_API_CALL PFNGLTEXPARAMETERIPROC glad_glTexParameteri; #define glTexParameteri glad_glTexParameteri GLAD_API_CALL PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv; #define glTexParameteriv glad_glTexParameteriv GLAD_API_CALL PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D; #define glTexSubImage1D glad_glTexSubImage1D GLAD_API_CALL PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D; #define glTexSubImage2D glad_glTexSubImage2D GLAD_API_CALL PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D; #define glTexSubImage3D glad_glTexSubImage3D GLAD_API_CALL PFNGLTRANSLATEDPROC glad_glTranslated; #define glTranslated glad_glTranslated GLAD_API_CALL PFNGLTRANSLATEFPROC glad_glTranslatef; #define glTranslatef glad_glTranslatef GLAD_API_CALL PFNGLUNIFORM1FPROC glad_glUniform1f; #define glUniform1f glad_glUniform1f GLAD_API_CALL PFNGLUNIFORM1FVPROC glad_glUniform1fv; #define glUniform1fv glad_glUniform1fv GLAD_API_CALL PFNGLUNIFORM1IPROC glad_glUniform1i; #define glUniform1i glad_glUniform1i GLAD_API_CALL PFNGLUNIFORM1IVPROC glad_glUniform1iv; #define glUniform1iv glad_glUniform1iv GLAD_API_CALL PFNGLUNIFORM2FPROC glad_glUniform2f; #define glUniform2f glad_glUniform2f GLAD_API_CALL PFNGLUNIFORM2FVPROC glad_glUniform2fv; #define glUniform2fv glad_glUniform2fv GLAD_API_CALL PFNGLUNIFORM2IPROC glad_glUniform2i; #define glUniform2i glad_glUniform2i GLAD_API_CALL PFNGLUNIFORM2IVPROC glad_glUniform2iv; #define glUniform2iv glad_glUniform2iv GLAD_API_CALL PFNGLUNIFORM3FPROC glad_glUniform3f; #define glUniform3f glad_glUniform3f GLAD_API_CALL PFNGLUNIFORM3FVPROC glad_glUniform3fv; #define glUniform3fv glad_glUniform3fv GLAD_API_CALL PFNGLUNIFORM3IPROC glad_glUniform3i; #define glUniform3i glad_glUniform3i GLAD_API_CALL PFNGLUNIFORM3IVPROC glad_glUniform3iv; #define glUniform3iv glad_glUniform3iv GLAD_API_CALL PFNGLUNIFORM4FPROC glad_glUniform4f; #define glUniform4f glad_glUniform4f GLAD_API_CALL PFNGLUNIFORM4FVPROC glad_glUniform4fv; #define glUniform4fv glad_glUniform4fv GLAD_API_CALL PFNGLUNIFORM4IPROC glad_glUniform4i; #define glUniform4i glad_glUniform4i GLAD_API_CALL PFNGLUNIFORM4IVPROC glad_glUniform4iv; #define glUniform4iv glad_glUniform4iv GLAD_API_CALL PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv; #define glUniformMatrix2fv glad_glUniformMatrix2fv GLAD_API_CALL PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv; #define glUniformMatrix3fv glad_glUniformMatrix3fv GLAD_API_CALL PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv; #define glUniformMatrix4fv glad_glUniformMatrix4fv GLAD_API_CALL PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer; #define glUnmapBuffer glad_glUnmapBuffer GLAD_API_CALL PFNGLUSEPROGRAMPROC glad_glUseProgram; #define glUseProgram glad_glUseProgram GLAD_API_CALL PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram; #define glValidateProgram glad_glValidateProgram GLAD_API_CALL PFNGLVERTEX2DPROC glad_glVertex2d; #define glVertex2d glad_glVertex2d GLAD_API_CALL PFNGLVERTEX2DVPROC glad_glVertex2dv; #define glVertex2dv glad_glVertex2dv GLAD_API_CALL PFNGLVERTEX2FPROC glad_glVertex2f; #define glVertex2f glad_glVertex2f GLAD_API_CALL PFNGLVERTEX2FVPROC glad_glVertex2fv; #define glVertex2fv glad_glVertex2fv GLAD_API_CALL PFNGLVERTEX2IPROC glad_glVertex2i; #define glVertex2i glad_glVertex2i GLAD_API_CALL PFNGLVERTEX2IVPROC glad_glVertex2iv; #define glVertex2iv glad_glVertex2iv GLAD_API_CALL PFNGLVERTEX2SPROC glad_glVertex2s; #define glVertex2s glad_glVertex2s GLAD_API_CALL PFNGLVERTEX2SVPROC glad_glVertex2sv; #define glVertex2sv glad_glVertex2sv GLAD_API_CALL PFNGLVERTEX3DPROC glad_glVertex3d; #define glVertex3d glad_glVertex3d GLAD_API_CALL PFNGLVERTEX3DVPROC glad_glVertex3dv; #define glVertex3dv glad_glVertex3dv GLAD_API_CALL PFNGLVERTEX3FPROC glad_glVertex3f; #define glVertex3f glad_glVertex3f GLAD_API_CALL PFNGLVERTEX3FVPROC glad_glVertex3fv; #define glVertex3fv glad_glVertex3fv GLAD_API_CALL PFNGLVERTEX3IPROC glad_glVertex3i; #define glVertex3i glad_glVertex3i GLAD_API_CALL PFNGLVERTEX3IVPROC glad_glVertex3iv; #define glVertex3iv glad_glVertex3iv GLAD_API_CALL PFNGLVERTEX3SPROC glad_glVertex3s; #define glVertex3s glad_glVertex3s GLAD_API_CALL PFNGLVERTEX3SVPROC glad_glVertex3sv; #define glVertex3sv glad_glVertex3sv GLAD_API_CALL PFNGLVERTEX4DPROC glad_glVertex4d; #define glVertex4d glad_glVertex4d GLAD_API_CALL PFNGLVERTEX4DVPROC glad_glVertex4dv; #define glVertex4dv glad_glVertex4dv GLAD_API_CALL PFNGLVERTEX4FPROC glad_glVertex4f; #define glVertex4f glad_glVertex4f GLAD_API_CALL PFNGLVERTEX4FVPROC glad_glVertex4fv; #define glVertex4fv glad_glVertex4fv GLAD_API_CALL PFNGLVERTEX4IPROC glad_glVertex4i; #define glVertex4i glad_glVertex4i GLAD_API_CALL PFNGLVERTEX4IVPROC glad_glVertex4iv; #define glVertex4iv glad_glVertex4iv GLAD_API_CALL PFNGLVERTEX4SPROC glad_glVertex4s; #define glVertex4s glad_glVertex4s GLAD_API_CALL PFNGLVERTEX4SVPROC glad_glVertex4sv; #define glVertex4sv glad_glVertex4sv GLAD_API_CALL PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d; #define glVertexAttrib1d glad_glVertexAttrib1d GLAD_API_CALL PFNGLVERTEXATTRIB1DARBPROC glad_glVertexAttrib1dARB; #define glVertexAttrib1dARB glad_glVertexAttrib1dARB GLAD_API_CALL PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv; #define glVertexAttrib1dv glad_glVertexAttrib1dv GLAD_API_CALL PFNGLVERTEXATTRIB1DVARBPROC glad_glVertexAttrib1dvARB; #define glVertexAttrib1dvARB glad_glVertexAttrib1dvARB GLAD_API_CALL PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f; #define glVertexAttrib1f glad_glVertexAttrib1f GLAD_API_CALL PFNGLVERTEXATTRIB1FARBPROC glad_glVertexAttrib1fARB; #define glVertexAttrib1fARB glad_glVertexAttrib1fARB GLAD_API_CALL PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv; #define glVertexAttrib1fv glad_glVertexAttrib1fv GLAD_API_CALL PFNGLVERTEXATTRIB1FVARBPROC glad_glVertexAttrib1fvARB; #define glVertexAttrib1fvARB glad_glVertexAttrib1fvARB GLAD_API_CALL PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s; #define glVertexAttrib1s glad_glVertexAttrib1s GLAD_API_CALL PFNGLVERTEXATTRIB1SARBPROC glad_glVertexAttrib1sARB; #define glVertexAttrib1sARB glad_glVertexAttrib1sARB GLAD_API_CALL PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv; #define glVertexAttrib1sv glad_glVertexAttrib1sv GLAD_API_CALL PFNGLVERTEXATTRIB1SVARBPROC glad_glVertexAttrib1svARB; #define glVertexAttrib1svARB glad_glVertexAttrib1svARB GLAD_API_CALL PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d; #define glVertexAttrib2d glad_glVertexAttrib2d GLAD_API_CALL PFNGLVERTEXATTRIB2DARBPROC glad_glVertexAttrib2dARB; #define glVertexAttrib2dARB glad_glVertexAttrib2dARB GLAD_API_CALL PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv; #define glVertexAttrib2dv glad_glVertexAttrib2dv GLAD_API_CALL PFNGLVERTEXATTRIB2DVARBPROC glad_glVertexAttrib2dvARB; #define glVertexAttrib2dvARB glad_glVertexAttrib2dvARB GLAD_API_CALL PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f; #define glVertexAttrib2f glad_glVertexAttrib2f GLAD_API_CALL PFNGLVERTEXATTRIB2FARBPROC glad_glVertexAttrib2fARB; #define glVertexAttrib2fARB glad_glVertexAttrib2fARB GLAD_API_CALL PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv; #define glVertexAttrib2fv glad_glVertexAttrib2fv GLAD_API_CALL PFNGLVERTEXATTRIB2FVARBPROC glad_glVertexAttrib2fvARB; #define glVertexAttrib2fvARB glad_glVertexAttrib2fvARB GLAD_API_CALL PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s; #define glVertexAttrib2s glad_glVertexAttrib2s GLAD_API_CALL PFNGLVERTEXATTRIB2SARBPROC glad_glVertexAttrib2sARB; #define glVertexAttrib2sARB glad_glVertexAttrib2sARB GLAD_API_CALL PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv; #define glVertexAttrib2sv glad_glVertexAttrib2sv GLAD_API_CALL PFNGLVERTEXATTRIB2SVARBPROC glad_glVertexAttrib2svARB; #define glVertexAttrib2svARB glad_glVertexAttrib2svARB GLAD_API_CALL PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d; #define glVertexAttrib3d glad_glVertexAttrib3d GLAD_API_CALL PFNGLVERTEXATTRIB3DARBPROC glad_glVertexAttrib3dARB; #define glVertexAttrib3dARB glad_glVertexAttrib3dARB GLAD_API_CALL PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv; #define glVertexAttrib3dv glad_glVertexAttrib3dv GLAD_API_CALL PFNGLVERTEXATTRIB3DVARBPROC glad_glVertexAttrib3dvARB; #define glVertexAttrib3dvARB glad_glVertexAttrib3dvARB GLAD_API_CALL PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f; #define glVertexAttrib3f glad_glVertexAttrib3f GLAD_API_CALL PFNGLVERTEXATTRIB3FARBPROC glad_glVertexAttrib3fARB; #define glVertexAttrib3fARB glad_glVertexAttrib3fARB GLAD_API_CALL PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv; #define glVertexAttrib3fv glad_glVertexAttrib3fv GLAD_API_CALL PFNGLVERTEXATTRIB3FVARBPROC glad_glVertexAttrib3fvARB; #define glVertexAttrib3fvARB glad_glVertexAttrib3fvARB GLAD_API_CALL PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s; #define glVertexAttrib3s glad_glVertexAttrib3s GLAD_API_CALL PFNGLVERTEXATTRIB3SARBPROC glad_glVertexAttrib3sARB; #define glVertexAttrib3sARB glad_glVertexAttrib3sARB GLAD_API_CALL PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv; #define glVertexAttrib3sv glad_glVertexAttrib3sv GLAD_API_CALL PFNGLVERTEXATTRIB3SVARBPROC glad_glVertexAttrib3svARB; #define glVertexAttrib3svARB glad_glVertexAttrib3svARB GLAD_API_CALL PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv; #define glVertexAttrib4Nbv glad_glVertexAttrib4Nbv GLAD_API_CALL PFNGLVERTEXATTRIB4NBVARBPROC glad_glVertexAttrib4NbvARB; #define glVertexAttrib4NbvARB glad_glVertexAttrib4NbvARB GLAD_API_CALL PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv; #define glVertexAttrib4Niv glad_glVertexAttrib4Niv GLAD_API_CALL PFNGLVERTEXATTRIB4NIVARBPROC glad_glVertexAttrib4NivARB; #define glVertexAttrib4NivARB glad_glVertexAttrib4NivARB GLAD_API_CALL PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv; #define glVertexAttrib4Nsv glad_glVertexAttrib4Nsv GLAD_API_CALL PFNGLVERTEXATTRIB4NSVARBPROC glad_glVertexAttrib4NsvARB; #define glVertexAttrib4NsvARB glad_glVertexAttrib4NsvARB GLAD_API_CALL PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub; #define glVertexAttrib4Nub glad_glVertexAttrib4Nub GLAD_API_CALL PFNGLVERTEXATTRIB4NUBARBPROC glad_glVertexAttrib4NubARB; #define glVertexAttrib4NubARB glad_glVertexAttrib4NubARB GLAD_API_CALL PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv; #define glVertexAttrib4Nubv glad_glVertexAttrib4Nubv GLAD_API_CALL PFNGLVERTEXATTRIB4NUBVARBPROC glad_glVertexAttrib4NubvARB; #define glVertexAttrib4NubvARB glad_glVertexAttrib4NubvARB GLAD_API_CALL PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv; #define glVertexAttrib4Nuiv glad_glVertexAttrib4Nuiv GLAD_API_CALL PFNGLVERTEXATTRIB4NUIVARBPROC glad_glVertexAttrib4NuivARB; #define glVertexAttrib4NuivARB glad_glVertexAttrib4NuivARB GLAD_API_CALL PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv; #define glVertexAttrib4Nusv glad_glVertexAttrib4Nusv GLAD_API_CALL PFNGLVERTEXATTRIB4NUSVARBPROC glad_glVertexAttrib4NusvARB; #define glVertexAttrib4NusvARB glad_glVertexAttrib4NusvARB GLAD_API_CALL PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv; #define glVertexAttrib4bv glad_glVertexAttrib4bv GLAD_API_CALL PFNGLVERTEXATTRIB4BVARBPROC glad_glVertexAttrib4bvARB; #define glVertexAttrib4bvARB glad_glVertexAttrib4bvARB GLAD_API_CALL PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d; #define glVertexAttrib4d glad_glVertexAttrib4d GLAD_API_CALL PFNGLVERTEXATTRIB4DARBPROC glad_glVertexAttrib4dARB; #define glVertexAttrib4dARB glad_glVertexAttrib4dARB GLAD_API_CALL PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv; #define glVertexAttrib4dv glad_glVertexAttrib4dv GLAD_API_CALL PFNGLVERTEXATTRIB4DVARBPROC glad_glVertexAttrib4dvARB; #define glVertexAttrib4dvARB glad_glVertexAttrib4dvARB GLAD_API_CALL PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f; #define glVertexAttrib4f glad_glVertexAttrib4f GLAD_API_CALL PFNGLVERTEXATTRIB4FARBPROC glad_glVertexAttrib4fARB; #define glVertexAttrib4fARB glad_glVertexAttrib4fARB GLAD_API_CALL PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv; #define glVertexAttrib4fv glad_glVertexAttrib4fv GLAD_API_CALL PFNGLVERTEXATTRIB4FVARBPROC glad_glVertexAttrib4fvARB; #define glVertexAttrib4fvARB glad_glVertexAttrib4fvARB GLAD_API_CALL PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv; #define glVertexAttrib4iv glad_glVertexAttrib4iv GLAD_API_CALL PFNGLVERTEXATTRIB4IVARBPROC glad_glVertexAttrib4ivARB; #define glVertexAttrib4ivARB glad_glVertexAttrib4ivARB GLAD_API_CALL PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s; #define glVertexAttrib4s glad_glVertexAttrib4s GLAD_API_CALL PFNGLVERTEXATTRIB4SARBPROC glad_glVertexAttrib4sARB; #define glVertexAttrib4sARB glad_glVertexAttrib4sARB GLAD_API_CALL PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv; #define glVertexAttrib4sv glad_glVertexAttrib4sv GLAD_API_CALL PFNGLVERTEXATTRIB4SVARBPROC glad_glVertexAttrib4svARB; #define glVertexAttrib4svARB glad_glVertexAttrib4svARB GLAD_API_CALL PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv; #define glVertexAttrib4ubv glad_glVertexAttrib4ubv GLAD_API_CALL PFNGLVERTEXATTRIB4UBVARBPROC glad_glVertexAttrib4ubvARB; #define glVertexAttrib4ubvARB glad_glVertexAttrib4ubvARB GLAD_API_CALL PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv; #define glVertexAttrib4uiv glad_glVertexAttrib4uiv GLAD_API_CALL PFNGLVERTEXATTRIB4UIVARBPROC glad_glVertexAttrib4uivARB; #define glVertexAttrib4uivARB glad_glVertexAttrib4uivARB GLAD_API_CALL PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv; #define glVertexAttrib4usv glad_glVertexAttrib4usv GLAD_API_CALL PFNGLVERTEXATTRIB4USVARBPROC glad_glVertexAttrib4usvARB; #define glVertexAttrib4usvARB glad_glVertexAttrib4usvARB GLAD_API_CALL PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer; #define glVertexAttribPointer glad_glVertexAttribPointer GLAD_API_CALL PFNGLVERTEXATTRIBPOINTERARBPROC glad_glVertexAttribPointerARB; #define glVertexAttribPointerARB glad_glVertexAttribPointerARB GLAD_API_CALL PFNGLVERTEXPOINTERPROC glad_glVertexPointer; #define glVertexPointer glad_glVertexPointer GLAD_API_CALL PFNGLVIEWPORTPROC glad_glViewport; #define glViewport glad_glViewport GLAD_API_CALL PFNGLWINDOWPOS2DPROC glad_glWindowPos2d; #define glWindowPos2d glad_glWindowPos2d GLAD_API_CALL PFNGLWINDOWPOS2DVPROC glad_glWindowPos2dv; #define glWindowPos2dv glad_glWindowPos2dv GLAD_API_CALL PFNGLWINDOWPOS2FPROC glad_glWindowPos2f; #define glWindowPos2f glad_glWindowPos2f GLAD_API_CALL PFNGLWINDOWPOS2FVPROC glad_glWindowPos2fv; #define glWindowPos2fv glad_glWindowPos2fv GLAD_API_CALL PFNGLWINDOWPOS2IPROC glad_glWindowPos2i; #define glWindowPos2i glad_glWindowPos2i GLAD_API_CALL PFNGLWINDOWPOS2IVPROC glad_glWindowPos2iv; #define glWindowPos2iv glad_glWindowPos2iv GLAD_API_CALL PFNGLWINDOWPOS2SPROC glad_glWindowPos2s; #define glWindowPos2s glad_glWindowPos2s GLAD_API_CALL PFNGLWINDOWPOS2SVPROC glad_glWindowPos2sv; #define glWindowPos2sv glad_glWindowPos2sv GLAD_API_CALL PFNGLWINDOWPOS3DPROC glad_glWindowPos3d; #define glWindowPos3d glad_glWindowPos3d GLAD_API_CALL PFNGLWINDOWPOS3DVPROC glad_glWindowPos3dv; #define glWindowPos3dv glad_glWindowPos3dv GLAD_API_CALL PFNGLWINDOWPOS3FPROC glad_glWindowPos3f; #define glWindowPos3f glad_glWindowPos3f GLAD_API_CALL PFNGLWINDOWPOS3FVPROC glad_glWindowPos3fv; #define glWindowPos3fv glad_glWindowPos3fv GLAD_API_CALL PFNGLWINDOWPOS3IPROC glad_glWindowPos3i; #define glWindowPos3i glad_glWindowPos3i GLAD_API_CALL PFNGLWINDOWPOS3IVPROC glad_glWindowPos3iv; #define glWindowPos3iv glad_glWindowPos3iv GLAD_API_CALL PFNGLWINDOWPOS3SPROC glad_glWindowPos3s; #define glWindowPos3s glad_glWindowPos3s GLAD_API_CALL PFNGLWINDOWPOS3SVPROC glad_glWindowPos3sv; #define glWindowPos3sv glad_glWindowPos3sv GLAD_API_CALL int gladLoadGLUserPtr( GLADuserptrloadfunc load, void *userptr); GLAD_API_CALL int gladLoadGL( GLADloadfunc load); #ifdef GLAD_GL GLAD_API_CALL int gladLoaderLoadGL(void); GLAD_API_CALL void gladLoaderUnloadGL(void); #endif #endif OpenCSG-1.8.2/src/occlusionQuery.cpp0000664000175000017500000000760615141675417017173 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2004-2026, Florian Kirsch, // Hasso-Plattner-Institute at the University of Potsdam, Germany // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // occlusionQuery.cpp // #include "opencsgConfig.h" #include "openglExt.h" #include "occlusionQuery.h" namespace OpenCSG { namespace OpenGL { class OcclusionQueryARB : public OcclusionQuery { public: OcclusionQueryARB(); virtual ~OcclusionQueryARB(); virtual void beginQuery(); virtual void endQuery(); virtual unsigned int getQueryResult(); private: friend OcclusionQuery* getOcclusionQuery(bool exactNumberNeeded); GLenum mQueryType; GLuint mQueryObject; }; OcclusionQueryARB::OcclusionQueryARB() : mQueryType(GL_SAMPLES_PASSED_ARB) { glGenQueriesARB(1, &mQueryObject); } OcclusionQueryARB::~OcclusionQueryARB() { glDeleteQueriesARB(1, &mQueryObject); } void OcclusionQueryARB::beginQuery() { glBeginQueryARB(mQueryType, mQueryObject); } void OcclusionQueryARB::endQuery() { glEndQueryARB(mQueryType); } unsigned int OcclusionQueryARB::getQueryResult() { GLuint fragmentCount; glGetQueryObjectuivARB(mQueryObject, GL_QUERY_RESULT_ARB, &fragmentCount); return fragmentCount; } class OcclusionQueryNV : public OcclusionQuery { public: OcclusionQueryNV(); virtual ~OcclusionQueryNV(); virtual void beginQuery(); virtual void endQuery(); virtual unsigned int getQueryResult(); private: GLuint mQueryObject; }; OcclusionQueryNV::OcclusionQueryNV() { glGenOcclusionQueriesNV(1, &mQueryObject); } OcclusionQueryNV::~OcclusionQueryNV() { glDeleteOcclusionQueriesNV(1, &mQueryObject); } void OcclusionQueryNV::beginQuery() { glBeginOcclusionQueryNV(mQueryObject); } void OcclusionQueryNV::endQuery() { glEndOcclusionQueryNV(); } unsigned int OcclusionQueryNV::getQueryResult() { GLuint fragmentCount; glGetOcclusionQueryuivNV(mQueryObject, GL_PIXEL_COUNT_NV, &fragmentCount); return fragmentCount; } OcclusionQuery* getOcclusionQuery(bool exactNumberNeeded) { if (!exactNumberNeeded && OPENCSG_HAS_EXT(ARB_occlusion_query2)) { OcclusionQueryARB* occlusionQuery = new OcclusionQueryARB; occlusionQuery->mQueryType = GL_ANY_SAMPLES_PASSED; return occlusionQuery; } if (OPENCSG_HAS_EXT(ARB_occlusion_query)) { OcclusionQueryARB* occlusionQuery = new OcclusionQueryARB; occlusionQuery->mQueryType = GL_SAMPLES_PASSED_ARB; return occlusionQuery; } if (OPENCSG_HAS_EXT(NV_occlusion_query)) { return new OcclusionQueryNV; } return 0; } } // namespace OpenGL } // namespace OpenCSG OpenCSG-1.8.2/src/batch.h0000664000175000017500000000360115141675417014664 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2002-2026, Florian Kirsch, // Hasso-Plattner-Institute at the University of Potsdam, Germany // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // batch.h // // object space optimization: If possible, several primitives are treated // as a single batch // #ifndef __OpenCSG__batch_h__ #define __OpenCSG__batch_h__ #include "opencsgConfig.h" #include #include namespace OpenCSG { class Primitive; /// a Batch is a list of primitives that do not overlap in screen space typedef std::vector Batch; class Batcher { public: /// subdivides an array of primitives into batches Batcher(const std::vector& primitives); /// returns all batches as constant reference const std::vector& batches() const; /// returns first batch std::vector::const_iterator begin() const; /// returns end of batches std::vector::const_iterator end() const; /// return number of batches std::size_t size() const; private: std::vector mBatches; }; } // namespace OpenCSG #endif // __OpenCSG__batch_h__ OpenCSG-1.8.2/src/occlusionQuery.h0000664000175000017500000000464115141675417016634 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2004-2026, Florian Kirsch, // Hasso-Plattner-Institute at the University of Potsdam, Germany // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // occlusionQuery.h // // wrappers parts of different occlusion-query extensions conveniently // #ifndef __OpenCSG__occlusion_query_h__ #define __OpenCSG__occlusion_query_h__ #include "opencsgConfig.h" namespace OpenCSG { namespace OpenGL { class OcclusionQuery { public: // abstract base class OcclusionQuery() {}; virtual ~OcclusionQuery() {}; /// begins an occlusion query virtual void beginQuery() = 0; /// stops an occlusion query virtual void endQuery() = 0; /// returns the number of fragments that have been put into /// the frame buffer between beginQuery() and endQuery(). /// if the parameter exactNumberNeeded of getOcclusionQuery() /// is false, the return value is just 0 or 1, depending /// whether any fragment has been rendered or not. virtual unsigned int getQueryResult() = 0; private: OcclusionQuery(const OcclusionQuery&); OcclusionQuery& operator=(const OcclusionQuery&); }; /// checks for OpenGL-extensions and returns a matching occlusion /// query object. may return 0 if occlusion queries are not /// supported by graphics hardware. /// /// when the occlusion query object is not needed anymore, /// it must be deleted! OcclusionQuery* getOcclusionQuery(bool exactNumberNeeded); } // namespace OpenGL } // namespace OpenCSG #endif // __OpenCSG__occlusion_query_h__ OpenCSG-1.8.2/src/primitiveHelper.h0000664000175000017500000000523615141675417016761 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2002-2026, Florian Kirsch, // Hasso-Plattner-Institute at the University of Potsdam, Germany // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // primitiveHelper.h // // trivial Primitive-related stuff // #ifndef __OpenCSG__primitive_helper_h__ #define __OpenCSG__primitive_helper_h__ #include "opencsgConfig.h" #include "area.h" #include namespace OpenCSG { class Primitive; namespace Algo { /// checks whether primitives intersect in xy direction bool intersectXY(const Primitive* a, const Primitive* b); /// checks whether primitives intersect in xyz direction bool intersectXYZ(const Primitive* a, const Primitive* b); /// checks whether the bounding box of primitive a is completely /// contained in the bounding box of primitive b bool containsXY(const Primitive* a, const Primitive* b); /// calculates maximum convexity of all primitives in array unsigned int getConvexity(const std::vector& primitives); } // namespace Algo namespace OpenGL { /// calculates depth complexity of the given primitives using the /// stencil buffer, in the bounding box given by area. /// Expects a clean stencil buffer, and does not clear /// the stencil buffer afterwards unsigned int calcMaxDepthComplexity(const std::vector& primitives, const PCArea& area); /// renders a rendering layer of the given primitives using the /// stencil buffer. The rendering layers are not ordered from /// front to back, so the ordering of the array matters! /// Expects a clean stencil buffer, and does not clear the stencil /// buffer afterwards. void renderLayer(unsigned int layer, const std::vector& primitives); } // namespace OpenGL } // namespace OpenCSG #endif // __OpenCSG__primitive_helper_h__ OpenCSG-1.8.2/src/settings.h0000664000175000017500000000254715141675417015453 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2006-2026, Florian Kirsch // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // settings.h // // global OpenCSG settings // #ifndef __OpenCSG__settings_h__ #define __OpenCSG__settings_h__ #include "opencsgConfig.h" #include #include namespace OpenCSG { /// redeclared from opencsg.h void setVertexShader(const std::string& vertexShader); const char* getVertexShader(); /// redeclared from opencsg.h void setOption(OptionType option, int newSetting); /// redeclared from opencsg.h int getOption(OptionType option); } // namespace OpenCSG #endif // __OpenCSG__settings_h__ OpenCSG-1.8.2/src/area.cpp0000664000175000017500000000302715141675417015050 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2004-2026, Florian Kirsch, // Hasso-Plattner-Institute at the University of Potsdam, Germany // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. #include "opencsgConfig.h" #include "area.h" #include "openglHelper.h" namespace OpenCSG { NDCVolume::operator PCArea() const { using OpenGL::canvasPos; float widthPixels = 0.5f * (canvasPos[2] - canvasPos[0]); float heightPixels = 0.5f * (canvasPos[3] - canvasPos[1]); int iminx = static_cast( (minx + 1.0f) * widthPixels ); int imaxx = static_cast( (maxx + 1.0f) * widthPixels ); int iminy = static_cast( (miny + 1.0f) * heightPixels ); int imaxy = static_cast( (maxy + 1.0f) * heightPixels ); return PCArea(iminx, iminy, imaxx, imaxy); } } // namespace OpenCSG OpenCSG-1.8.2/src/renderSCS.cpp0000664000175000017500000007440615141675417016001 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2002-2026, Florian Kirsch, // Hasso-Plattner-Institute at the University of Potsdam, Germany // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // renderSCS.cpp // // stuff specific for the SCS algorithm // #include "opencsgConfig.h" #include #include "opencsgRender.h" #include "batch.h" #include "channelManager.h" #include "context.h" #include "occlusionQuery.h" #include "openglHelper.h" #include "primitiveHelper.h" #include "scissorMemo.h" #include "sequencer.h" #include "settings.h" #include #include #include namespace OpenCSG { namespace { ScissorMemo* scissor; struct IdBufferId { GLubyte r; GLubyte g; GLubyte b; GLubyte a; GLubyte* vec() { return &r; } }; struct RenderData { IdBufferId bufferId; }; std::map gRenderInfo; RenderData* getRenderData(Primitive* primitive) { RenderData* dta = &(gRenderInfo.find(primitive))->second; return dta; } // Stores Ids in the alpha buffer only -> only 255 primitives are possible class SCSChannelManagerAlphaOnly : public ChannelManagerForBatches { public: virtual void merge(); }; void SCSChannelManagerAlphaOnly::merge() { ProjTextureSetup setup = FixedFunction; setupProjectiveTexture(setup); glEnable(GL_ALPHA_TEST); glEnable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glDepthMask(GL_TRUE); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); std::vector channels = occupied(); for (std::vector::const_iterator c = channels.begin(); c!=channels.end(); ++c) { setupTexEnv(*c); scissor->recall(*c); scissor->enableScissor(); const std::vector primitives = getPrimitives(*c); for (std::vector::const_iterator j = primitives.begin(); j != primitives.end(); ++j) { glCullFace((*j)->getOperation() == Intersection ? GL_BACK : GL_FRONT); RenderData* primitiveData = getRenderData(*j); GLubyte id = primitiveData->bufferId.a; // Here is an interesting bug, which happened on an ATI HD4670, but actually // might happen on every hardware. I am not sure whether it can be solved // correctly. // Problem is that in optimized mode with some compilers (VC6, Visual Studio 2003 // in particular), when setting the alpha func as follows: // glAlphaFunc(GL_EQUAL, static_cast(id) / 255.0f); // the division is optimized as multiplication with 1.0f/255.0f. // This is a fine and valid optimization. Unfortunately, the results // are not exactly the same as the direct division for some ids. // Which is apparently what the ATI driver is doing internally. // So with comparison with GL_EQUAL fails. // Fortunately the OpenGL standard enforces that the mapping of color byte // values to float fragment values be done by division. So if the // solution found below (just working at double precision) proves // to work once, it should work forever, such that a precompiling // lookup table containing the correct alpha reference values is // not required. However a bad feeling remains. // The SCSChannelManagerFragmentProgram path implemented below should fix this. double alpha = static_cast(id) / 255.0; GLfloat fAlpha = static_cast(alpha); glAlphaFunc(GL_EQUAL, fAlpha); (*j)->render(); } } scissor->disableScissor(); glDisable(GL_ALPHA_TEST); glDisable(GL_CULL_FACE); glDepthFunc(GL_LEQUAL); resetProjectiveTexture(setup); clear(); } // Stores Ids in the all components of the color buffer // -> in theory, 2^32-1 primitives are possible // ARB variant class SCSChannelManagerARBProgram : public ChannelManagerForBatches { public: SCSChannelManagerARBProgram(ProjTextureSetup); virtual Channel request(); virtual void merge(); private: ProjTextureSetup mProjTextureSetup; }; SCSChannelManagerARBProgram::SCSChannelManagerARBProgram(ProjTextureSetup setup) : mProjTextureSetup(setup) { } Channel SCSChannelManagerARBProgram::request() { ChannelManagerForBatches::request(); mCurrentChannel = AllChannels; mOccupiedChannels = mCurrentChannel; return mCurrentChannel; } // Emulates eye texgen static const char mergeARBVertexProgram[] = "!!ARBvp1.0 OPTION ARB_position_invariant;\n" "ATTRIB pos = vertex.position;\n" "ATTRIB col = vertex.color;\n" "OUTPUT outCol = result.color;\n" "OUTPUT outTex0 = result.texcoord[0];\n" "PARAM mvpmat[4] = { state.matrix.mvp };\n" "PARAM texmat[4] = { state.matrix.texture[0] };\n" "TEMP eye;\n" "TEMP tex;\n" "DP4 eye.x, mvpmat[0], pos;\n" "DP4 eye.y, mvpmat[1], pos;\n" "DP4 eye.z, mvpmat[2], pos;\n" "DP4 eye.w, mvpmat[3], pos;\n" "DP4 tex.x, texmat[0], eye;\n" "DP4 tex.y, texmat[1], eye;\n" "DP4 tex.z, texmat[2], eye;\n" "DP4 tex.w, texmat[3], eye;\n" "MOV outTex0, tex;\n" "MOV outCol, col;\n" "END"; // Subtract color from texture value, takes the absolute value // and adds all components into each channel of the result, scaled by 2.0f. // This way, all 32-bits of the color channel can be used // for an 'equal' alpha test, i.e, to check if value in texture // and color are equal. // Note that 1.0f/255.0f cannot be the result of the above computation. // Either the result is 0 (if all components were equal, disregarding // numerical errors), or larger/equal than 2.0f/255.0f. The alpha function // then is actually set to GL_LESS, 1.0f/255.0f. This is robust, // in contract to the GL_EQUAL in SCSChannelManagerAlphaOnly above. // The scaling by 2.0f is required for NVidia hardware, which considers // the alpha function GL_LESS, 0.5f/255.0f as GL_LESS, 0.0f for some reason. static const char mergeARBFragmentProgramRect[] = "!!ARBfp1.0\n" "TEMP temp;\n" "ATTRIB tex0 = fragment.texcoord[0];\n" "ATTRIB col0 = fragment.color;\n" "PARAM scaleByTwo = { 2.0, 2.0, 2.0, 2.0 };\n" "OUTPUT out = result.color;\n" "TXP temp, tex0, texture[0], RECT;\n" "SUB temp, temp, col0;\n" "ABS temp, temp;\n" "DP4 out, temp, scaleByTwo;\n" "END"; static const char mergeARBFragmentProgram2D[] = "!!ARBfp1.0\n" "TEMP temp;\n" "ATTRIB tex0 = fragment.texcoord[0];\n" "ATTRIB col0 = fragment.color;\n" "PARAM scaleByTwo = { 2.0, 2.0, 2.0, 2.0 };\n" "OUTPUT out = result.color;\n" "TXP temp, tex0, texture[0], 2D;\n" "SUB temp, temp, col0;\n" "ABS temp, temp;\n" "DP4 out, temp, scaleByTwo;\n" "END"; void SCSChannelManagerARBProgram::merge() { if (mProjTextureSetup == ARBShader) { GLuint vId = OpenGL::getARBVertexProgram(mergeARBVertexProgram, (sizeof(mergeARBVertexProgram) / sizeof(mergeARBVertexProgram[0])) - 1); glBindProgramARB(GL_VERTEX_PROGRAM_ARB, vId); glEnable(GL_VERTEX_PROGRAM_ARB); } GLuint fId = isRectangularTexture() ? OpenGL::getARBFragmentProgram(mergeARBFragmentProgramRect, (sizeof(mergeARBFragmentProgramRect) / sizeof(mergeARBFragmentProgramRect[0])) - 1) : OpenGL::getARBFragmentProgram(mergeARBFragmentProgram2D, (sizeof(mergeARBFragmentProgram2D) / sizeof(mergeARBFragmentProgram2D[0])) - 1); glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, fId); glEnable(GL_FRAGMENT_PROGRAM_ARB); setupProjectiveTexture(mProjTextureSetup); glEnable(GL_ALPHA_TEST); glEnable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glDepthMask(GL_TRUE); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glAlphaFunc(GL_LESS, 1.0f / 255.0f); std::vector channels; channels.push_back(AllChannels); for (std::vector::const_iterator c = channels.begin(); c!=channels.end(); ++c) { scissor->recall(*c); scissor->enableScissor(); const std::vector primitives = getPrimitives(*c); for (std::vector::const_iterator j = primitives.begin(); j != primitives.end(); ++j) { glCullFace((*j)->getOperation() == Intersection ? GL_BACK : GL_FRONT); RenderData* primitiveData = getRenderData(*j); GLubyte * id = primitiveData->bufferId.vec(); glColor4ubv(id); (*j)->render(); } } scissor->disableScissor(); glDisable(GL_ALPHA_TEST); glDisable(GL_CULL_FACE); glDepthFunc(GL_LEQUAL); glDisable(GL_FRAGMENT_PROGRAM_ARB); if (mProjTextureSetup == ARBShader) { glDisable(GL_VERTEX_PROGRAM_ARB); } resetProjectiveTexture(mProjTextureSetup); clear(); } // Stores Ids in the all components of the color buffer // -> in theory, 2^32-1 primitives are possible // GLSL variant class SCSChannelManagerGLSLProgram : public ChannelManagerForBatches { public: virtual Channel request(); virtual void merge(); }; Channel SCSChannelManagerGLSLProgram::request() { ChannelManagerForBatches::request(); mCurrentChannel = AllChannels; mOccupiedChannels = mCurrentChannel; return mCurrentChannel; } // Subtract color from texture value, and if the result is not 0 // (including some epsilon, which is less than 1.0/(256*256), // discards the fragment. // This way, all 32-bits of the color channel can be used // for an 'equal' alpha test, i.e, to check if value in texture // and color are equal. static const char mergeFragmentProgramRect[] = "#version 110\n" "#extension GL_ARB_texture_rectangle : enable\n" "uniform sampler2DRect texture0;\n" "uniform vec4 color;\n" "void main() {\n" " vec4 temp = texture2DRect(texture0, gl_FragCoord.xy);\n" " temp = temp - color;\n" " if (dot(temp, temp) > 0.000001)\n" " discard;\n" " gl_FragColor = color;\n" "}\n"; static const char mergeFragmentProgram2D[] = "#version 110\n" "uniform sampler2D texture0;\n" "uniform vec2 texSizeInv;\n" "uniform vec4 color;\n" "void main() {\n" " vec2 texCoord = vec2(gl_FragCoord.x * texSizeInv.x, gl_FragCoord.y * texSizeInv.y);\n" " vec4 temp = texture2D(texture0, texCoord);\n" " temp = temp - color;\n" " if (dot(temp, temp) > 0.000001)\n" " discard;\n" " gl_FragColor = color;\n" "}\n"; void SCSChannelManagerGLSLProgram::merge() { const int SCSIdOffset = 2; const char* programID = getVertexShader() + (isRectangularTexture() ? 1 : 0) + SCSIdOffset; GLuint glslProgram = isRectangularTexture() ? OpenGL::getGLSLProgram(programID, getVertexShader(), mergeFragmentProgramRect) : OpenGL::getGLSLProgram(programID, getVertexShader(), mergeFragmentProgram2D); GLint col = glGetUniformLocation(glslProgram, "color"); GLint texSizeInv = -1; if (!isRectangularTexture()) texSizeInv = glGetUniformLocation(glslProgram, "texSizeInv"); glUseProgram(glslProgram); ProjTextureSetup setup = GLSLProgram; setupProjectiveTexture(setup, texSizeInv); glDisable(GL_ALPHA_TEST); glEnable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glDepthMask(GL_TRUE); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); std::vector channels; channels.push_back(AllChannels); for (std::vector::const_iterator c = channels.begin(); c!=channels.end(); ++c) { scissor->recall(*c); scissor->enableScissor(); const std::vector primitives = getPrimitives(*c); for (std::vector::const_iterator j = primitives.begin(); j != primitives.end(); ++j) { glCullFace((*j)->getOperation() == Intersection ? GL_BACK : GL_FRONT); RenderData* primitiveData = getRenderData(*j); GLubyte * id = primitiveData->bufferId.vec(); glUniform4f(col, static_cast(static_cast(id[0]) / 255.0), static_cast(static_cast(id[1]) / 255.0), static_cast(static_cast(id[2]) / 255.0), static_cast(static_cast(id[3]) / 255.0)); (*j)->render(); } } scissor->disableScissor(); glDisable(GL_CULL_FACE); glDepthFunc(GL_LEQUAL); glUseProgram(0); resetProjectiveTexture(setup); clear(); } ChannelManagerForBatches* getChannelManager() { if (GLAD_GL_VERSION_2_0) { bool useGLSL = getVertexShader() != 0; if (useGLSL) return new SCSChannelManagerGLSLProgram; } // The ARB vertex program path has the following problem: // With Nouveau drivers on Linux and an NVidia GTX 710, the ARB_position_invariant // option appears to be buggy sometimes, and this causes z-buffer artifacts. // On the other hand, historical Intel drives failed to work for // fixed-function vertex setup together with ARB vertex programs. if ( OPENCSG_HAS_EXT(ARB_vertex_program) && OPENCSG_HAS_EXT(ARB_fragment_program) ) { std::string vendor; if (const char * v = (const char*)glGetString(GL_VENDOR)) vendor = v; bool isIntel = vendor.find("Intel") == 0; ProjTextureSetup setup = isIntel ? ARBShader : FixedFunction; return new SCSChannelManagerARBProgram(setup); } // The fallback path, using fixed function OpenGL, has its own problems: // Obviously, it does not support more than 255 primitives. More importantly, // due to the alpha test and the GL_EQUAL alpha function used here, due // to accuracy problems, the alpha test for some IDs may incorrectly fail. // Then, some primitives of the CSG share are completely missing. return new SCSChannelManagerAlphaOnly; } class IDGenerator { public: IDGenerator() : counter(0) {} IdBufferId newID() { ++counter; IdBufferId newId; newId.r = (counter >> 24) & 0xff; newId.g = (counter >> 16) & 0xff; newId.b = (counter >> 8) & 0xff; newId.a = (counter >> 0) & 0xff; return newId; } private: unsigned int counter; }; ChannelManagerForBatches* channelMgr; void renderIntersectedFront(const std::vector& primitives) { const std::size_t numberOfPrimitives = primitives.size(); glDepthMask(GL_TRUE); // optimization for only one shape if (numberOfPrimitives == 1) { channelMgr->renderToChannel(true); glDepthFunc(GL_GREATER); glCullFace(GL_BACK); glEnable(GL_CULL_FACE); RenderData * primitiveData = getRenderData(primitives[0]); GLubyte * id = primitiveData->bufferId.vec(); glColor4ubv(id); primitives[0]->render(); glDisable(GL_CULL_FACE); glDepthFunc(GL_LESS); return; } // draw furthest front face channelMgr->renderToChannel(true); glStencilMask(OpenGL::stencilMask); glDepthFunc(GL_GREATER); glCullFace(GL_BACK); glEnable(GL_CULL_FACE); { for (std::vector::const_iterator i = primitives.begin(); i != primitives.end(); ++i) { RenderData * primitiveData = getRenderData(*i); GLubyte * id = primitiveData->bufferId.vec(); glColor4ubv(id); (*i)->render(); } } // count back faces behind furthest front face channelMgr->renderToChannel(false); glStencilFunc(GL_ALWAYS, 0, OpenGL::stencilMask); glStencilOp(GL_KEEP, GL_KEEP, GL_INCR); glEnable(GL_STENCIL_TEST); glDepthMask(GL_FALSE); glCullFace(GL_FRONT); { for (std::vector::const_iterator i = primitives.begin(); i != primitives.end(); ++i) { (*i)->render(); } } // where #back faces behind furthest front face != #intersected shapes // ->reset fragment channelMgr->renderToChannel(true); glStencilFunc(GL_NOTEQUAL, static_cast(numberOfPrimitives), OpenGL::stencilMask); glDepthFunc(GL_ALWAYS); glDepthRange(0.0, 0.0); glDepthMask(GL_TRUE); glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO); glDisable(GL_CULL_FACE); glColor4ub(0, 0, 0, 0); OpenGL::drawQuad(); glDepthRange(0.0, 1.0); glDepthFunc(GL_LESS); glDisable(GL_STENCIL_TEST); } void subtractPrimitives(const std::vector& batches, const unsigned int depthComplexity = 0) { int setting = getOption(CameraOutsideOptimization); bool cameraInsideModel = (setting == OptimizationOff); glStencilMask(OpenGL::stencilMask); glEnable(GL_STENCIL_TEST); glEnable(GL_CULL_FACE); size_t numberOfBatches = batches.size(); BouncingSequencer bounce(numberOfBatches); SchoenfieldSequencer schoenfield(numberOfBatches); Sequencer * sequencer = 0; size_t numIterations; if (depthComplexity == 0) { sequencer = &schoenfield; numIterations = sequencer->size(); } else { sequencer = &bounce; numIterations = sequencer->sizeForDepthComplexity(depthComplexity); } unsigned int stencilref = 0; for (size_t i = 0; i < numIterations; ++i) { const Batch& batch = batches[sequencer->index(i)]; // create a distinct reference value ++stencilref; if (stencilref == OpenGL::stencilMax) { glClear(GL_STENCIL_BUFFER_BIT); stencilref = 1; } channelMgr->renderToChannel(false); glDepthMask(GL_FALSE ); glStencilFunc(GL_ALWAYS, stencilref, OpenGL::stencilMask); glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); if (cameraInsideModel) { glDepthFunc(GL_GREATER); glCullFace(GL_FRONT); for (Batch::const_iterator j = batch.begin(); j != batch.end(); ++j) { (*j)->render(); } glStencilFunc(GL_EQUAL, stencilref, OpenGL::stencilMask); glStencilOp(GL_ZERO, GL_ZERO, GL_KEEP); } glDepthFunc(GL_LESS); glCullFace(GL_BACK); { for (Batch::const_iterator j = batch.begin(); j != batch.end(); ++j) { (*j)->render(); } } // where front faces have been visible, render back faces channelMgr->renderToChannel(true); glDepthFunc(GL_GREATER); glDepthMask(GL_TRUE); glCullFace(GL_FRONT); glStencilFunc(GL_EQUAL, stencilref, OpenGL::stencilMask); glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO); { for (Batch::const_iterator j = batch.begin(); j != batch.end(); ++j) { RenderData * primitiveData = getRenderData(*j); GLubyte * id = primitiveData->bufferId.vec(); glColor4ubv(id); (*j)->render(); } } } glDisable(GL_STENCIL_TEST); } bool subtractPrimitivesWithOcclusionQueries(const std::vector& batches) { OpenGL::OcclusionQuery* occlusionTest = OpenGL::getOcclusionQuery(true); if (!occlusionTest) { return false; } const std::size_t numberOfBatches = batches.size(); int setting = getOption(CameraOutsideOptimization); bool cameraInsideModel = (setting == OptimizationOff); glStencilMask(OpenGL::stencilMask); glEnable(GL_STENCIL_TEST); glEnable(GL_CULL_FACE); std::vector fragmentcount(numberOfBatches, 0); unsigned int shapesWithoutUpdate = 0; SimpleSequencer sequencer(numberOfBatches); size_t numIterations = sequencer.size(); unsigned int stencilref = 0; for (size_t i = 0; i < numIterations; ++i) { size_t idx = sequencer.index(i); const Batch& batch = batches[idx]; // create a distinct reference value ++stencilref; if (stencilref == OpenGL::stencilMax) { glClear(GL_STENCIL_BUFFER_BIT); stencilref = 1; } channelMgr->renderToChannel(false); glDepthMask(GL_FALSE); glStencilFunc(GL_ALWAYS, stencilref, OpenGL::stencilMask); glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); occlusionTest->beginQuery(); if (cameraInsideModel) { glDepthFunc(GL_GREATER); glCullFace(GL_FRONT); { for (Batch::const_iterator j = batch.begin(); j != batch.end(); ++j) { (*j)->render(); } } glStencilFunc(GL_EQUAL, stencilref, OpenGL::stencilMask); glStencilOp(GL_ZERO, GL_ZERO, GL_KEEP); } glDepthFunc(GL_LESS); glCullFace(GL_BACK); { for (Batch::const_iterator j = batch.begin(); j != batch.end(); ++j) { (*j)->render(); } } occlusionTest->endQuery(); // the fragment count query could occur here, but benches show that // the algorithm is faster if the query is delayed. // where front faces have been visible, render back faces channelMgr->renderToChannel(true); glDepthFunc(GL_GREATER); glDepthMask(GL_TRUE); glCullFace(GL_FRONT); glStencilFunc(GL_EQUAL, stencilref, OpenGL::stencilMask); glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO); { for (Batch::const_iterator j = batch.begin(); j != batch.end(); ++j) { RenderData * primitiveData = getRenderData(*j); GLubyte * id = primitiveData->bufferId.vec(); glColor4ubv(id); (*j)->render(); } } unsigned int newFragmentCount = occlusionTest->getQueryResult(); if (newFragmentCount != fragmentcount[idx]) { fragmentcount[idx] = newFragmentCount; shapesWithoutUpdate = 0; } else { ++shapesWithoutUpdate; if (shapesWithoutUpdate >= numberOfBatches) break; } } delete occlusionTest; glDisable(GL_STENCIL_TEST); return true; } void renderIntersectedBack(const std::vector& primitives) { // where a back face of intersected shape is in front of any subtracted shape // mask fragment as invisible. Updating depth values is not necessary, so when // having IDs, this is kind of simple. channelMgr->renderToChannel(true); glEnable(GL_CULL_FACE); glCullFace(GL_FRONT); glDepthMask(GL_FALSE); glDepthFunc(GL_LESS); glColor4ub(0, 0, 0, 0); for (std::vector::const_iterator i = primitives.begin(); i != primitives.end(); ++i) { (*i)->render(); } glDepthMask(GL_TRUE); } } // unnamed namespace void renderSCS(const std::vector& primitives, DepthComplexityAlgorithm algorithm) { channelMgr = getChannelManager(); if (!channelMgr->init()) { delete channelMgr; return; } gRenderInfo.clear(); scissor = new ScissorMemo; std::vector intersected; intersected.reserve(primitives.size()); std::vector subtracted; subtracted.reserve(primitives.size()); { IDGenerator IDMaker; for (std::vector::const_iterator itr = primitives.begin(); itr != primitives.end(); ++itr) { { RenderData dta; dta.bufferId = IDMaker.newID(); gRenderInfo.insert(std::make_pair(*itr, dta)); } Operation operation= (*itr)->getOperation(); if (operation == Intersection) { intersected.push_back(*itr); } else if (operation == Subtraction) { subtracted.push_back(*itr); } } } Batcher subtractedBatches(subtracted); scissor->setIntersected(intersected); scissor->setCurrent(intersected); unsigned int depthComplexity = 0; if (algorithm == DepthComplexitySampling) { scissor->enableScissor(); glClear(GL_STENCIL_BUFFER_BIT); depthComplexity = (std::min)(OpenGL::calcMaxDepthComplexity(subtracted, scissor->getCurrentArea()), static_cast(subtractedBatches.size())); } channelMgr->request(); channelMgr->renderToChannel(true); scissor->enableScissor(); scissor->store(channelMgr->current()); glDepthMask(GL_TRUE); glStencilMask(OpenGL::stencilMask); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glClearDepth(0.0); // near clipping plane! essential for algorithm! glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); glClearDepth(1.0); renderIntersectedFront(intersected); if (!subtractedBatches.batches().empty()) { scissor->enableDepthBounds(); switch (algorithm) { case OcclusionQuery: if (subtractPrimitivesWithOcclusionQueries(subtractedBatches.batches())) break; // success // Maybe we just should give up here? // fall through case NoDepthComplexitySampling: subtractPrimitives(subtractedBatches.batches()); break; case DepthComplexitySampling: subtractPrimitives(subtractedBatches.batches(), depthComplexity); break; } scissor->disableDepthBounds(); } renderIntersectedBack(intersected); scissor->disableScissor(); channelMgr->store(channelMgr->current(), primitives, 0); channelMgr->free(); delete scissor; delete channelMgr; } } // namespace OpenCSG OpenCSG-1.8.2/src/channelManager.cpp0000664000175000017500000004377015141675417017054 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2002-2026, Florian Kirsch, // Hasso-Plattner-Institute at the University of Potsdam, Germany // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // channelManager.cpp // #include "opencsgConfig.h" #include "channelManager.h" #include "context.h" #include "offscreenBuffer.h" #include "openglHelper.h" #include "settings.h" #include #include namespace OpenCSG { bool ChannelManager::gInUse = false; namespace { int nextPow2(int value) { if(value <= 0) { return 0; } int result = 1; while(result < value) { result <<= 1; } return result; } void defaults() { glViewport(OpenGL::canvasPos[0], OpenGL::canvasPos[1], OpenGL::canvasPos[2], OpenGL::canvasPos[3]); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClearDepth(1.0); glClearStencil(0); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glDepthMask(GL_TRUE); glStencilMask(0xffffffff); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); glEnable(GL_DEPTH_TEST); } template class MaximumMemorizer { int mMax; int mSecondMax; int mCounter; public: MaximumMemorizer() : mMax(0), mSecondMax(-1), mCounter(0) { } void newValue(int v) { if (v>=mMax) { mMax = v; mSecondMax = -1; mCounter = 0; } else { if (v>mSecondMax) { mSecondMax = v; } if (++mCounter >= FRAMES) { mMax = mSecondMax; mSecondMax = -1; mCounter = 0; } } } int getMax() const { return mMax; } }; } // unnamed namespace ChannelManager::ChannelManager() : mOffscreenBuffer(0) , mInOffscreenBuffer(false) , mCurrentChannel(NoChannel) , mOccupiedChannels(NoChannel) { glPushAttrib(GL_ALL_ATTRIB_BITS); glDisable(GL_LIGHTING); glDisable(GL_TEXTURE_1D); glDisable(GL_TEXTURE_2D); if ( OPENCSG_HAS_EXT(ARB_texture_rectangle) || OPENCSG_HAS_EXT(EXT_texture_rectangle) || OPENCSG_HAS_EXT(NV_texture_rectangle)) glDisable(GL_TEXTURE_RECTANGLE_ARB); glDisable(GL_TEXTURE_3D); // OpenGL 1.2 - take this as given if (OPENCSG_HAS_EXT(ARB_texture_cube_map)) glDisable(GL_TEXTURE_CUBE_MAP_ARB); glDisable(GL_BLEND); glGetFloatv(GL_MODELVIEW_MATRIX, OpenGL::modelview); glGetFloatv(GL_PROJECTION_MATRIX, OpenGL::projection); glGetIntegerv(GL_VIEWPORT, OpenGL::canvasPos); if (glIsEnabled(GL_SCISSOR_TEST)) { glGetIntegerv(GL_SCISSOR_BOX, OpenGL::scissorPos); } else { OpenGL::scissorPos[0] = OpenGL::canvasPos[0]; OpenGL::scissorPos[1] = OpenGL::canvasPos[1]; OpenGL::scissorPos[2] = OpenGL::canvasPos[2]; OpenGL::scissorPos[3] = OpenGL::canvasPos[3]; } } bool ChannelManager::init() { assert(!gInUse); if (gInUse) return false; gInUse = true; OffscreenType newOffscreenType = static_cast(getOption(OffscreenSetting)); if ( newOffscreenType == OpenCSG::AutomaticOffscreenType || newOffscreenType == OpenCSG::FrameBufferObject ) { if (OPENCSG_HAS_EXT(ARB_framebuffer_object)) { newOffscreenType = OpenCSG::FrameBufferObjectARB; } else if ( OPENCSG_HAS_EXT(EXT_framebuffer_object) && OPENCSG_HAS_EXT(EXT_packed_depth_stencil) ) { newOffscreenType = OpenCSG::FrameBufferObjectEXT; } else { // At least one set of the above OpenGL extensions is required return false; } } mOffscreenBuffer = OpenGL::getOffscreenBuffer(newOffscreenType); if (!mOffscreenBuffer) { // Creating the offscreen buffer failed, maybe the OpenGL extension // for the specific offscreen buffer type is not supported return false; } if (!mOffscreenBuffer->ReadCurrent()) { return false; } const int dx = OpenGL::canvasPos[2] - OpenGL::canvasPos[0]; const int dy = OpenGL::canvasPos[3] - OpenGL::canvasPos[1]; int tx = dx; int ty = dy; // We don't need to enlarge the texture to the next largest power-of-two size if: // - the ARB_texture_non_power_of_two extension is supported // - or any of the texture rectangle extensions is supported // Negating this gives the following expression from hell: if ( !OPENCSG_HAS_EXT(ARB_texture_non_power_of_two) && !OPENCSG_HAS_EXT(ARB_texture_rectangle) && !OPENCSG_HAS_EXT(EXT_texture_rectangle) && !OPENCSG_HAS_EXT(NV_texture_rectangle) ) { // blow up the texture to legal power-of-two size :-( tx = nextPow2(dx); ty = nextPow2(dy); } // The following implements a heuristic that makes the offscreen buffer // smaller if the size of the buffer has been bigger than necessary // in x- or y- direction for resizeOffscreenBufferLimit frames. // // this permits to use OpenCSG for CSG rendering in different // canvases with different sizes without permanent expensive // resizing of the offscreen buffer for every frame. // // possible improvements: // - allow the user to define the resizeOffscreenBufferLimit? static const unsigned int resizeOffscreenBufferLimit = 64; static MaximumMemorizer sizeX; static MaximumMemorizer sizeY; // tx == ty == 0 happens if the window is minimized, in this case don't touch a thing if (tx != 0 && ty != 0) { sizeX.newValue(tx); sizeY.newValue(ty); } bool rebuild = false; Dimensions dims(sizeX.getMax(), sizeY.getMax()); if (!mOffscreenBuffer->IsInitialized()) { if (!mOffscreenBuffer->Initialize(dims)) { // Initializing the offscreen buffer failed, maybe the OpenGL extension // for the specific offscreen buffer type is not supported return false; } rebuild = true; } // tx == ty == 0 happens if the window is minimized, in this case don't touch a thing else if (tx != 0 && ty != 0 && ( mOffscreenBuffer->GetWidth() != dims.width || mOffscreenBuffer->GetHeight() != dims.height ) ) { if (!mOffscreenBuffer->Resize(dims)) { // Resizing the offscreen buffer failed, maybe the OpenGL extension // for the specific offscreen buffer type is not supported. More // likely this is a programming error in Resize(). return false; } rebuild = true; } if (rebuild) { // assert(gOffscreenBuffer->HasStencil()); mOffscreenBuffer->BeginCapture(); defaults(); glGetIntegerv(GL_STENCIL_BITS, &OpenGL::stencilBits); OpenGL::stencilMax = 1 << OpenGL::stencilBits; OpenGL::stencilMask = OpenGL::stencilMax - 1; mOffscreenBuffer->EndCapture(); mOffscreenBuffer->Bind(); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); } mInOffscreenBuffer = false; mCurrentChannel = NoChannel; mOccupiedChannels = NoChannel; return true; } ChannelManager::~ChannelManager() { glPopAttrib(); assert(gInUse); gInUse = false; } Channel ChannelManager::find() const { Channel channel = NoChannel; // find free channel if ((mOccupiedChannels & Alpha) == 0) { channel = Alpha; } else if (OPENCSG_HAS_EXT(ARB_texture_env_dot3) || GLAD_GL_VERSION_1_3) { if ((mOccupiedChannels & Red) == 0) { channel = Red; } else if ((mOccupiedChannels & Green) == 0) { channel = Green; } else if ((mOccupiedChannels & Blue) == 0) { channel = Blue; } } return channel; } Channel ChannelManager::request() { if (!mInOffscreenBuffer) { mOffscreenBuffer->BeginCapture(); mInOffscreenBuffer = true; mCurrentChannel = NoChannel; mOccupiedChannels = NoChannel; } mCurrentChannel = find(); mOccupiedChannels |= mCurrentChannel; return mCurrentChannel; } Channel ChannelManager::current() const { return mCurrentChannel; } std::vector ChannelManager::occupied() const { std::vector result; result.reserve(4); if ((mOccupiedChannels & Alpha) != 0) { result.push_back(Alpha); } if ((mOccupiedChannels & Red) != 0) { result.push_back(Red); } if ((mOccupiedChannels & Green) != 0) { result.push_back(Green); } if ((mOccupiedChannels & Blue) != 0) { result.push_back(Blue); } return result; } void ChannelManager::free() { if (mInOffscreenBuffer) { mOffscreenBuffer->EndCapture(); mInOffscreenBuffer = false; } merge(); } void ChannelManager::renderToChannel(bool on) { if (on) { switch (mCurrentChannel) { case NoChannel: glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); break; case Alpha: glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE); break; case Blue: glColorMask(GL_FALSE, GL_FALSE, GL_TRUE, GL_FALSE); break; case Green: glColorMask(GL_FALSE, GL_TRUE, GL_FALSE, GL_FALSE); break; case Red: glColorMask(GL_TRUE, GL_FALSE, GL_FALSE, GL_FALSE); break; case AllChannels: glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); break; } } else { glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); } } void ChannelManager::setupProjectiveTexture(ProjTextureSetup setup, GLint texSizeInv) { mOffscreenBuffer->Bind(); mOffscreenBuffer->EnableTextureTarget(); if (setup == FixedFunction) { static const float splane[4] = { 1.0f, 0.0f, 0.0f, 0.0f }; static const float tplane[4] = { 0.0f, 1.0f, 0.0f, 0.0f }; static const float rplane[4] = { 0.0f, 0.0f, 1.0f, 0.0f }; static const float qplane[4] = { 0.0f, 0.0f, 0.0f, 1.0f }; glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); glTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); glTexGenfv(GL_S, GL_EYE_PLANE, splane); glTexGenfv(GL_T, GL_EYE_PLANE, tplane); glTexGenfv(GL_R, GL_EYE_PLANE, rplane); glTexGenfv(GL_Q, GL_EYE_PLANE, qplane); glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); glEnable(GL_TEXTURE_GEN_R); glEnable(GL_TEXTURE_GEN_Q); } if (setup == FixedFunction || setup == ARBShader) { glMatrixMode(GL_TEXTURE); const int dx = OpenGL::canvasPos[2] - OpenGL::canvasPos[0]; const int dy = OpenGL::canvasPos[3] - OpenGL::canvasPos[1]; // with ARB_texture_rectangle texture coordinates range between // 0 and dx resp. dy float factorX = static_cast(dx); float factorY = static_cast(dy); // Otherwise, if the texture rectangle extension is not used: // Do not check for the non-power-of-two extension, but simply for // the texture format. This seems safer, since it should work always. if (!isRectangularTexture()) { // with ordinary pow-of-two texture coordinates are between 0 and 1 // but we must assure only the used part of the texture is taken. factorX /= static_cast(mOffscreenBuffer->GetWidth()); factorY /= static_cast(mOffscreenBuffer->GetHeight()); } float texCorrect[16] = { factorX, 0.0f, 0.0f, 0.0f, 0.0f, factorY, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f }; static const float p2ndc[16] = { 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.5f, 0.0f, 0.5f, 0.5f, 0.5f, 1.0f }; glPushMatrix(); glLoadMatrixf(texCorrect); glMultMatrixf(p2ndc); if (setup == FixedFunction) { glMultMatrixf(OpenGL::projection); glMultMatrixf(OpenGL::modelview); } glMatrixMode(GL_MODELVIEW); } else if (setup == GLSLProgram) { // If the texture rectangle extension is not used, the uniform // with the inverse texture size must be set. The value is used // in the 2d fragment shader to map pixel coordinates to texture // coordinates between 0 and 1. if (!isRectangularTexture()) { glUniform2f(texSizeInv, 1.0f / (std::max)(mOffscreenBuffer->GetWidth(), 1), 1.0f / (std::max)(mOffscreenBuffer->GetHeight(), 1)); } } } void ChannelManager::resetProjectiveTexture(ProjTextureSetup setup) { if (setup == FixedFunction) { glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); glDisable(GL_TEXTURE_GEN_R); glDisable(GL_TEXTURE_GEN_Q); } if (setup == FixedFunction || setup == ARBShader) { glMatrixMode(GL_TEXTURE); glPopMatrix(); glMatrixMode(GL_MODELVIEW); } mOffscreenBuffer->DisableTextureTarget(); } void ChannelManager::setupTexEnv(Channel channel) { if (channel == Alpha) { glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); } else { // replicate color into alpha if (OPENCSG_HAS_EXT(ARB_texture_env_dot3) || GLAD_GL_VERSION_1_3) { switch (channel) { case Red: glColor3f(1.0f, 0.5f, 0.5f); break; case Green: glColor3f(0.5f, 1.0f, 0.5f); break; case Blue: glColor3f(0.5f, 0.5f, 1.0f); break; default: // should not happen! assert(0); } } else { // should not happen! assert(0); } glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_DOT3_RGBA); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PRIMARY_COLOR); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR); } } bool ChannelManager::isRectangularTexture() const { return mOffscreenBuffer->GetTextureTarget() != GL_TEXTURE_2D; } ChannelManagerForBatches::ChannelManagerForBatches() : ChannelManager(), mPrimitives(std::vector, int> >(AllChannels + 1)) { } void ChannelManagerForBatches::store(Channel channel, const std::vector& primitives, int layer) { mPrimitives[channel] = std::make_pair(primitives, layer); } const std::vector ChannelManagerForBatches::getPrimitives(Channel channel) const { return mPrimitives[channel].first; } int ChannelManagerForBatches::getLayer(Channel channel) const { return mPrimitives[channel].second; } void ChannelManagerForBatches::clear() { mPrimitives = std::vector, int> >(AllChannels + 1); } } // namespace OpenCSG OpenCSG-1.8.2/src/openglHelper.h0000664000175000017500000000403015141675417016224 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2002-2026, Florian Kirsch, // Hasso-Plattner-Institute at the University of Potsdam, Germany // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // openglHelper.h // // trivial OpenGL stuff // #ifndef __OpenCSG__opengl_helper_h__ #define __OpenCSG__opengl_helper_h__ #include "opencsgConfig.h" #include "openglExt.h" #include "area.h" namespace OpenCSG { namespace OpenGL { // copy of the projection matrix during CSG computation extern GLfloat projection[16]; // copy of the modelview matrix during CSG computation extern GLfloat modelview[16]; // copy of the viewport size during CSG computation extern GLint canvasPos[4]; // number of stencil bits in the offscreen buffer extern GLint stencilBits; // the number where the stencil value would "wrap around" to zero extern unsigned int stencilMax; // stencilMax - 1 extern unsigned int stencilMask; // copy of the scissor settings for CSG computation extern GLint scissorPos[4]; // enables scissoring into area (given in pixel coordinates) void scissor(const PCArea& area); // renders a full screen quad void drawQuad(); } // namespace OpenGL } // namespace OpenCSG #endif // __OpenCSG__opengl_helper_h__ OpenCSG-1.8.2/src/frameBufferObjectExt.h0000664000175000017500000000734015141675417017643 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2010-2026, Florian Kirsch // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // frameBufferObjectExt.h // // frame buffer object class implementing the offscreen buffer interface // #ifndef __OpenCSG__frame_buffer_object_ext_h__ #define __OpenCSG__frame_buffer_object_ext_h__ #include "opencsgConfig.h" #include "offscreenBuffer.h" #include "openglExt.h" namespace OpenCSG { namespace OpenGL { class FrameBufferObjectExt : public OffscreenBuffer { public: /// ctor / dtor FrameBufferObjectExt(); virtual ~FrameBufferObjectExt(); /// Reads the currently bound FBO. virtual bool ReadCurrent(); /// Initializes the frame buffer object with the intended width and height. /// The frame buffer object is created with RGBA and combined depth/stencil buffer. virtual bool Initialize(Dimensions dims); /// checks whether Initialize has been called before or not virtual bool IsInitialized() const { return initialized; } /// Change the size of the frame buffer object. virtual bool Resize(Dimensions dims); /// Begin drawing to the frame buffer object. (i.e. use as "output" texture) virtual bool BeginCapture(); /// End drawing to the frame buffer object. virtual bool EndCapture(); /// Bind the frame buffer object to the active texture unit for use as an "input" texture virtual void Bind() const; /// Enables the texture target appropriate for this frame buffer object. virtual void EnableTextureTarget() const { if (initialized) glEnable(textureTarget); } /// Disables the texture target appropriate for this frame buffer object. virtual void DisableTextureTarget() const { if (initialized) glDisable(textureTarget); } /// Returns the texture target this texture is bound to. virtual unsigned int GetTextureTarget() const { return textureTarget; } /// Returns the width of the frame buffer object. virtual int GetWidth() const { return dimensions.width; } /// Returns the width of the frame buffer object. virtual int GetHeight() const { return dimensions.height; } private: FrameBufferObjectExt(const FrameBufferObjectExt&); FrameBufferObjectExt& operator=(const FrameBufferObjectExt&); // Width and height of the frame buffer object Dimensions dimensions; /// Texture stuff GLenum textureTarget; unsigned int textureID; unsigned int depthID; unsigned int framebufferID; int oldFramebufferID; bool initialized; /// Removes the frame buffer object OpenGL resources. bool Reset(); }; } // namespace OpenGL } // namespace OpenCSG #endif // __OpenCSG__frame_buffer_object_ext_h__ OpenCSG-1.8.2/src/scissorMemo.h0000664000175000017500000000656615141675417016123 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2002-2026, Florian Kirsch, // Hasso-Plattner-Institute at the University of Potsdam, Germany // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // scissorMemo.h // // handles scissor calculations // #ifndef __OpenCSG__scissor_memo_h__ #define __OpenCSG__scissor_memo_h__ #include "opencsgConfig.h" #include "area.h" #include "channelManager.h" #include namespace OpenCSG { class ScissorMemo { public: /// convenience class for handling scissoring. All areas /// are given in normal device coordinates [-1, 1] x [-1, 1]. ScissorMemo(); /// for each channel, the currently set area can be stored void store(Channel); /// restores the area for the channel void recall(Channel); /// enables scissoring of area void enableScissor() const; /// disables scissoring void disableScissor() const; /// checks if the depth bounds test is enabled bool isDepthBoundsTestEnabled() const; /// enables depth bounds test of volume (if supported by graphics hardware) void enableDepthBounds() const; /// enables depth bounds test of back of current volume (if supported by graphics hardware) void enableDepthBoundsBack() const; /// enables depth bounds test of front of current volume (if supported by graphics hardware) void enableDepthBoundsFront() const; /// disables depth bounds test of volume (if supported by graphics hardware) void disableDepthBounds() const; /// sets the maximum area of the intersected CSG-primitives /// by intersecting the bounding boxes of them. void setIntersected(const std::vector& primitives); /// sets the area of primitives whose visilibity is determined next. void setCurrent(const std::vector& primitives); /// returns the maximum area of the intersected CSG-primitives const NDCVolume& getIntersectedArea() const; /// returns the maximum area of the intersected CSG-primitives /// intersected with the currently used primitives const NDCVolume& getCurrentArea() const; protected: /// calculates rendering area by intersecting intersected /// and current. This is invoked implicetely. void calculateArea(); private: ScissorMemo(const ScissorMemo&); ScissorMemo& operator=(const ScissorMemo&); NDCVolume mIntersection; NDCVolume mCurrent; NDCVolume mArea; std::vector mScissor; bool mUseDepthBoundsTest; }; } // namespace OpenCSG #endif // __OpenCSG__scissor_memo_h__ OpenCSG-1.8.2/src/frameBufferObject.cpp0000664000175000017500000001173415141675417017517 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2006-2026, Florian Kirsch // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // frameBufferObject.cpp // #include "opencsgConfig.h" #include "frameBufferObject.h" namespace OpenCSG { namespace OpenGL { // ctor / dtor FrameBufferObject::FrameBufferObject() : textureTarget(GL_TEXTURE_2D), textureID(0), depthID(0), framebufferID(0), oldFramebufferID(0), initialized(false) { } FrameBufferObject::~FrameBufferObject() { Reset(); } bool FrameBufferObject::ReadCurrent() { bool haveFBO = OPENCSG_HAS_EXT(ARB_framebuffer_object) != 0; if (haveFBO) glGetIntegerv(GL_FRAMEBUFFER_BINDING, &oldFramebufferID); return haveFBO; } bool FrameBufferObject::Initialize(Dimensions dims) { bool haveFBO = OPENCSG_HAS_EXT(ARB_framebuffer_object) != 0; if (!haveFBO) return false; dimensions = dims; glGenFramebuffers(1, &framebufferID); glGenRenderbuffers(1, &depthID); glGenTextures(1, &textureID); glBindFramebuffer(GL_FRAMEBUFFER, framebufferID); GLenum target = GL_TEXTURE_2D; if ( !OPENCSG_HAS_EXT(ARB_texture_non_power_of_two) && ( OPENCSG_HAS_EXT(ARB_texture_rectangle) || OPENCSG_HAS_EXT(EXT_texture_rectangle) || OPENCSG_HAS_EXT(NV_texture_rectangle))) target = GL_TEXTURE_RECTANGLE_ARB; glBindTexture(target, textureID); glTexImage2D(target, 0, GL_RGBA8, GetWidth(), GetHeight(), 0, GL_RGBA, GL_INT, 0); glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, textureID, 0); glBindRenderbuffer(GL_RENDERBUFFER, depthID); glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_STENCIL, GetWidth(), GetHeight()); glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthID); glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, depthID); GLenum status; status = glCheckFramebufferStatus(GL_FRAMEBUFFER); if (status == GL_FRAMEBUFFER_UNSUPPORTED) { Reset(); return false; } glBindFramebuffer(GL_FRAMEBUFFER, oldFramebufferID); glBindTexture(target, 0); textureTarget = target; initialized = true; return true; } // Releases frame buffer objects bool FrameBufferObject::Reset() { if (textureID) { glDeleteTextures(1, &textureID); textureID = 0; } if (depthID) { glDeleteRenderbuffers(1, &depthID); depthID = 0; } if (framebufferID) { glDeleteFramebuffers(1, &framebufferID); framebufferID = 0; } dimensions = Dimensions(); initialized = false; return true; } // If new requested size differs, regenerate FBO texture objects bool FrameBufferObject::Resize(Dimensions dims) { if (dimensions == dims) { return true; } Reset(); return Initialize(dims); } // Binds the created frame buffer texture such we can render into it. bool FrameBufferObject::BeginCapture() { glBindFramebuffer(GL_FRAMEBUFFER, framebufferID); return true; } // Unbinds frame buffer texture. bool FrameBufferObject::EndCapture() { glBindFramebuffer(GL_FRAMEBUFFER, oldFramebufferID); return true; } // Sets the frame buffer texture as active texture object. void FrameBufferObject::Bind() const { glBindTexture(textureTarget, textureID); } } // namespace OpenGL } // namespace OpenCSG OpenCSG-1.8.2/README.md0000664000175000017500000000231215141675417014120 0ustar florianflorian# OpenCSG OpenCSG is a library that does image-based CSG rendering using OpenGL. It is written in C++ and supports most modern graphics hardware using Microsoft Windows or the Linux operating system. What is CSG, anyway? CSG is short for Constructive Solid Geometry and denotes an approach to model complex 3D-shapes using simpler ones. I.e., two shapes can be combined by taking the union of them, by intersecting them, or by subtracting one shape of the other. The most basic shapes, which are not result of such a CSG operation, are called primitives. Primitives must be solid, i.e., they must have a clearly defined interior and exterior. By construction, a CSG shape is also solid then. Image-based CSG rendering (also z-buffer CSG rendering) is a term for algorithms that render CSG shapes without an explicit calculation of the geometric boundary of a CSG shape. Such algorithms use frame-buffer settings of the graphics hardware, e.g., the depth and stencil buffer, to compose CSG shapes. OpenCSG implements a variety of those algorithms, namely the Goldfeather algorithm and the SCS algorithm, both of them in several variants. See the OpenCSG homepage for more information. OpenCSG-1.8.2/OpenCSG.dsw0000664000175000017500000000151615141675417014623 0ustar florianflorianMicrosoft Developer Studio Workspace File, Format Version 6.00 # WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE! ############################################################################### Project: "OpenCSG"=".\win32\OpenCSG.dsp" - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ }}} ############################################################################### Project: "OpenCSGexample"=".\example\OpenCSGexample.dsp" - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ Begin Project Dependency Project_Dep_Name OpenCSG End Project Dependency }}} ############################################################################### Global: Package=<5> {{{ }}} Package=<3> {{{ }}} ############################################################################### OpenCSG-1.8.2/build.txt0000664000175000017500000000424115141675417014504 0ustar florianflorianMicrosoft Visual Studio 2022 ---------------------------- The Visual Studio solution OpenCSG_vc2022.sln assumes that freeglut is put in a freeglut/ subdirecty in the OpenCSG installation directory. This works, for example, with the freeglut 3.0.0 MSVC package available from https://www.transmissionzero.co.uk/software/freeglut-devel The Visual Studio solutions automatically builds GLEW, the opencsg lib, and the example. The solution allows to create both 64- and 32-bit builds. To run the example, you must copy the freeglut.dll into the directory example/Release/ or example/Debug/ where the opencsgexample.exe has been built. Be sure to pick the correct 64- or 32-bit version of the dll. Linux and MacOSX ---------------- 1) As prerequisites, you must install OpenGL development packages, and, for the example application, glut. To create the makefiles, additionally you need CMake. 2) Just type: cmake CMakeLists.txt This will generate the makefiles in the src and example directory. To create makefiles with optimizations enabled, maybe type instead cmake -DCMAKE_BUILD_TYPE=Release CMakeLists.txt Then type: make 3) The OpenCSG library will have been build in src/, and the example "opencsgexample" will reside in the example/ directory. To run the opencsg example, you must ensure that libopencsg.so lib is in your LD_LIBRARY_PATH (e.G., one way to do this is to copy it to /usr/local/lib and running "ldconfig -v"). 'make install' is an automatic way to copy the build and the example into /usr/local (requires write access to /usr/local) Microsoft Visual Studio 6 ------------------------- The Visual Studio 6 solution OpenCSG.dsw assumes that the original GLUT for Windows is setup as described in https://user.xmission.com/~nate/glut.html The solution automatically builds the opencsg lib, and the example. Dev-C++ 5.11 ------------ As prerequisite, get the freeglut 3.0.0 MinGW Package from https://www.transmissionzero.co.uk/software/freeglut-devel/ and put it under freeglut into the opencsg directory. Open OpenCSG.dev Compile Ensure that freeglut.dll is in the same directory as the generated OpenCSG.exe, and start OpenCSG.exe. OpenCSG-1.8.2/changelog.txt0000664000175000017500000004005415142145311015320 0ustar florianflorian08.02.2026: Release 1.8.2 03.01.2026 Fixed: For SCS, when merging the color channel in the ARB shader path, probe for Intel hardware/drivers and use the ARB vertex program for vertex setup then. Otherwise, setup the vertices with the fixed function code path again. This change fixes the z-artifacts that happen with the Nouveau drivers on Linux. 09.03.2025: Release 1.8.1 08.03.2025: Reverted: For SCS, when merging the color channel, prefer the ARB shader program code path again. The fixed-function implementation fixed the z-artifacts, but traded in a different kind of rendering error with software OpenGL rendering on MacOS X. 06.03.2025: Fixed: Removed unused target for CMake, potentially causing build errors 04.03.2025 Fixed: Make new GLSL shaders API also work if the OpenGL supports version 2.0 or 2.1 only. This in particular fixes this API on MacOSX with openscad. 02.03.2025: Release 1.8.0 28.02.2025: Removed: old qmake-based make files. On non-Windows build platforms, use CMake instead. 28.02.2025: Changed: For SCS, implemented a performance optimization, namely shorter permutation embedding sequences. The primitives to be subtracted are processed in a specific order that allows for fewer subtraction operations than before. The performance gain can be up to 10%, even though it usually is less. 27.02.2025: Changed: For SCS, if there are less than 256 primitives, use the old fixed-function implementation to merge the color channel. It does not suffer from z-artifacts as the 32-bit Id-buffer algorithm, that can be observed with the Nouveau drivers on Linux. 23.02.2025: Added: API to set the GLSL vertex shader from the calling application. 22.02.2025: Added: GLSL shaders for the channel manager merge. Currently these are used by default, but the plan is to activate them only when the calling application providing a trivial vertex shader. 02.02.2025: Changed: Added CMake files to replace the old qmake files in the middle term. 18.01.2025: Release 1.7.0 12.01.2025: Changed: For SCS, with respect to the changes for the camera inside of the CSG model, restore the original behavior by default. The new algorithm is now the option that must be specifically activated. 04.01.2025: Fixed: Improve behavior when the camera is inside of the CSG model, for the SCS algorithm. A slightly slower way to compute the depth of the subtracted primitives has been implemented. As an option, the former, faster algorithm can be enabled. 01.01.2025: Fixed: The depth bounds test optimization in the Goldfeather algorithm was buggy, when using the old z-less parity test. It was incorrectly also applied when discarding fragments, i.e., when writing depth values 1.0 for the discarded fragments. 31.12.2024 Fixed: Improve behavior when the camera is inside of the CSG model, for the Goldfeather algorithm. The parity test now is computed by using a z-fail depth function, instead of z-pass. This is equivalent, but more robust, because for geometry behind the current z-buffer, depth-frustum culling usually does not happen. 15.09.2023 Release 1.6.0 09.09.2023 Changed: Favor ARB_texture_non_power_of_two over (ARB_)texture_rectangle 02.09.2023 Changed: For OpenGL extension checking, replaces GLEW by glad. This should improve portability on Linux, because this also means that there is no dependency on GLX anymore. 30.08.2023 Removed StencilManager (which was always deactivated before) 28.08.2023 Removed PBuffer support (always use FBOs instead) 20.04.2022 Release 1.5.1 13.04.2022 GCC 11/12 compile fixes 10.04.2022 Release 1.5.0 (license changed from GPLv2 to GPLv2 or newer) 30.03.2022 Resolved a couple of 64-bit warnings while testing Visual Studio 2019 29.09.2016 Release 1.4.2 22.09.2016 Fixed: For frame buffer objects, switch back to the correct prior FBO, instead of the FBO that was active when the OpenCSG FBO was initialized. This fixes issues with using OpenCSG with the QOpenGLWidget from Qt. 11.09.2016 Release 1.4.1 05.09.2016: Fixed: 32-bit Id-buffer for SCS algorithm on Intel hardware, by using ARB_vertex_program instead of the fixed function pipeline to setup texture coordinate generation. The latter apperently triggered a driver bug in the Intel OpenGL driver. 15.09.2014 Release 1.4.0 13.09.2014 Changed: On Linux and Mac, ignore the OpenCSG-provided GLEW and build link with the system provided GLEW instead. 11.09.2014 Fixed: Do not write into the color buffer during primitive visibility transfer. This bug made it impossible to use alpha blending on the final CSG geometry, because the geometry was already shaded by OpenCSG. 21.08.2014 Fixed: In the layered Goldfeather algorithms, do not hang forever if the maximum stencil width has been reached, i.e., if the depth complexity is larger than 255 17.08.2014 Added: 32-bit Id-buffer for SCS algorithm, which requires the ARB_fragment_program extension. This allows the SCS algorithm to process more than 255 primitives 11.05.2014 Release 1.3.3 02.04.2014 Fixed: Linux XVisualInfo * code path to create a PBuffer context, that would always crash. (thanks to David Binderman) 03.11.2013 Fixed: potential security issue in format string of fprintf, which caused errors when building with -Werror=format-security (thanks to Christian M. Amsss) 02.10.2012 Fixed: in opencsgexample, fixed glut.h / stdlib.h conflict in declaration of exit() 18.01.2012 Changed: Use vertex arrays instead of glBegin/glEnd for rendering quads 02.12.2011 Release 1.3.2 29.11.2011 Changed: Favor EXT frame buffer object extension over pbuffers (due to feedback from openscad users) 28.11.2011 Added: Version number to opencsg.h 27.11.2011 Added: MacOSX portibility fixes (thanks to Marius Kintel) 26.11.2011 Fixed: rendering artifacts at the border of primitives under Linux / ATI / Gallium3D that were caused by linear filtering of the FBO texture. Nearest filtering is required. 25.11.2011 Fixed: Quering width and heigth of a pbuffer under Linux / ATI / Gallium3D driver always returned 0. The query should not be required, anyway. 14.11.2011 Added: Support ARB_texture_rectangle extension for FBO path. This extension is used preferably instead of the former solution, that implicitely required the ARB_texture_non_power_of_two extension without checking for it. Fixed: In case ARB_texture_rectangle is not available and also not ARB_texture_non_power_of_two, the FBO is blown up to power-of-two, as in the pbuffer case. 11.11.2011 Fixed: Perform 0-ptr checks if no occlusion query object can be created. 10.11.2011 Added: Support for ARB_occlusion_query2 extension in the Goldfeather / occlusion query case. 05.09.2011 Fixed: For frame buffer objects, switch back to prior FBO instead of disabling FBO (thanks to Marius Kintel for the bug report). 09.06.2010 Release 1.3.1 06.06.2010 License: Added special linking exception for CGAL. 07.02.2010 Release 1.3.0 27.01.2010 Added: Allow to chose explicitely between ARB and EXT frame buffer objects Changed: In the automatic setting, ARB frame buffer objects have precedence over pbuffers over EXT frame buffer objects now. 21.01.2010 Changed: made offscreen buffer methods Initialize() / Resize() more intuitive. Initialize needs to be called only once after offscreen buffer construction; after Resize() calling Initialize() is not required anymore. 20.01.2010 Added: context management to allow MDI applications to use OpenCSG in each OpenGL window even without shared OpenGL contexts. This just maps a integer context identifier to a set of different internal offscreen buffer objects for each context. 16.01.2010 Fixed: rendering error in SCS algorithm due to imprecise float value provided to alpha test. 03.01.2010 Release 1.2.0 05.11.2009 Changed: frame buffer objects are now used by default (instead of pbuffers) 03.08.2009 Added: support for ARB frame buffer objects (in addition to EXT frame buffer objects) 22.07.2009 Fixed: uninitialized variable in framebuffer object path. Might have caused the visibility transfer to fail. 19.07.2009 Release 1.1.1 19.07.2009 Fixed: bad performance behaviour of Batcher when called with many primitives with standard bounding boxes. 07.02.2009 Fixed: removed -athlon-xp optimization in makefile, which was not portable obviously, in particular for x64 platforms. 30.09.2007 Changed: made a default and a legacy render() function for interface cleanup and more logical documentation in the header file. 23.09.2007 Added: made depth bounds optimization configurable, default off. 15.08.2007 Fixed: stencil mask was not reset after doing the parity test. Then, the stencil buffer was not fully reset in the next glClear(GL_STENCIL_BUFFER_BIT). Bug only manifested in layered Goldfeather algorithms with FBO. 08.08.2007 Added: Support for depth bounds extension for performance improvements. Currently, standard Goldfeather and all SCS algorithms use this functionality. 03.12.2006 Release 1.1.0 02.12.2006 Fixed: Free for mode string failed in debug mode in VC6, commented out. 30.11.2006 Changed: Renamed setOptioni -> setOption, getOptioni -> getOption. Changed: Refined offscreen buffer resizing. 29.11.2006 Fixed: Offscreen buffer resizing issue with alternating buffers of the resolution (x1, y1) / (x2, y2) where x1>x2 but y1 1024x512 -> 512x1024 -> ... (and similar series) 06.11.2003 Added: Detection of GL_FRONT_FACE OpenGL setting. This means that CSG rendering is now also correct if this setting is the non-default clockwise setting. 04.11.2003 Fixed: Stenciling was not disabled in SCS algorithm when subtracting no shapes. This could lead to obscure rendering errors when rendering the next CSG shape. 02.11.2003 Added: Heuristic that makes the pbuffer smaller if the size of the pbuffer has been bigger than necessary in x- or y- direction for a certain number of render-calles. This permits to use OpenCSG for CSG rendering in different canvases with different sizes without constant expensive resizing of the pbuffer for every frame. 01.10.2003 Fixed: linux: removed accidental linking against tcl/tk 23.09.2003 Release 0.9 OpenCSG-1.8.2/win32/0000775000175000017500000000000015141675417013605 5ustar florianflorianOpenCSG-1.8.2/win32/OpenCSG.dsp0000664000175000017500000001252415141675417015557 0ustar florianflorian# Microsoft Developer Studio Project File - Name="OpenCSG" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Static Library" 0x0104 CFG=OpenCSG - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "OpenCSG.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "OpenCSG.mak" CFG="OpenCSG - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "OpenCSG - Win32 Release" (based on "Win32 (x86) Static Library") !MESSAGE "OpenCSG - Win32 Debug" (based on "Win32 (x86) Static Library") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "OpenCSG - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "Release" # PROP Intermediate_Dir "Release" # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c # ADD CPP /nologo /W3 /GX /O2 /I ".." /I "../include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /FD /c # SUBTRACT CPP /YX /Yc /Yu # ADD BASE RSC /l 0x407 /d "NDEBUG" # ADD RSC /l 0x407 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo /out:"../lib/OpenCSG.lib" !ELSEIF "$(CFG)" == "OpenCSG - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "Debug" # PROP BASE Intermediate_Dir "Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "Debug" # PROP Intermediate_Dir "Debug" # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /GZ /c # ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I ".." /I "../include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /FD /GZ /c # SUBTRACT CPP /YX /Yc /Yu # ADD BASE RSC /l 0x407 /d "_DEBUG" # ADD RSC /l 0x407 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo /out:"../lib/OpenCSGd.lib" !ENDIF # Begin Target # Name "OpenCSG - Win32 Release" # Name "OpenCSG - Win32 Debug" # Begin Group "Source Files" # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" # Begin Source File SOURCE=..\src\area.cpp # End Source File # Begin Source File SOURCE=..\src\area.h # End Source File # Begin Source File SOURCE=..\src\batch.cpp # End Source File # Begin Source File SOURCE=..\src\batch.h # End Source File # Begin Source File SOURCE=..\src\channelManager.cpp # End Source File # Begin Source File SOURCE=..\src\channelManager.h # End Source File # Begin Source File SOURCE=..\src\context.cpp # End Source File # Begin Source File SOURCE=..\src\context.h # End Source File # Begin Source File SOURCE=..\src\frameBufferObject.cpp # End Source File # Begin Source File SOURCE=..\src\frameBufferObject.h # End Source File # Begin Source File SOURCE=..\src\frameBufferObjectExt.cpp # End Source File # Begin Source File SOURCE=..\src\frameBufferObjectExt.h # End Source File # Begin Source File SOURCE=..\src\glad\src\gl.cpp # End Source File # Begin Source File SOURCE=..\src\glad\include\glad\gl.h # End Source File # Begin Source File SOURCE=..\src\glad\include\KHR\khrplatform.h # End Source File # Begin Source File SOURCE=..\src\occlusionQuery.cpp # End Source File # Begin Source File SOURCE=..\src\occlusionQuery.h # End Source File # Begin Source File SOURCE=..\src\offscreenBuffer.h # End Source File # Begin Source File SOURCE=..\src\opencsgConfig.h # End Source File # Begin Source File SOURCE=..\src\opencsgRender.cpp # End Source File # Begin Source File SOURCE=..\src\opencsgRender.h # End Source File # Begin Source File SOURCE=..\src\openglExt.h # End Source File # Begin Source File SOURCE=..\src\openglHelper.cpp # End Source File # Begin Source File SOURCE=..\src\openglHelper.h # End Source File # Begin Source File SOURCE=..\src\primitive.cpp # End Source File # Begin Source File SOURCE=..\src\primitiveHelper.cpp # End Source File # Begin Source File SOURCE=..\src\primitiveHelper.h # End Source File # Begin Source File SOURCE=..\src\renderGoldfeather.cpp # End Source File # Begin Source File SOURCE=..\src\renderSCS.cpp # End Source File # Begin Source File SOURCE=..\src\scissorMemo.cpp # End Source File # Begin Source File SOURCE=..\src\scissorMemo.h # End Source File # Begin Source File SOURCE=..\src\sequencer.h # End Source File # Begin Source File SOURCE=..\src\settings.cpp # End Source File # Begin Source File SOURCE=..\src\settings.h # End Source File # End Group # Begin Group "Header Files" # PROP Default_Filter "h;hpp;hxx;hm;inl" # Begin Source File SOURCE=..\include\opencsg.h # End Source File # End Group # End Target # End Project OpenCSG-1.8.2/win32/OpenCSG.vcxproj0000664000175000017500000002712415141675417016466 0ustar florianflorian Debug Win32 Debug x64 Release Win32 Release x64 {BB6A8C4D-37B1-81CB-862A-BDDA0906D298} StaticLibrary false v143 StaticLibrary false v143 StaticLibrary false v143 StaticLibrary false v143 <_ProjectFileVersion>10.0.40219.1 ..\lib\ ..\lib\ .\Release\ .\Release\ ..\lib\ ..\lib\ .\Debug\ .\Debug\ OpenCSGd OpenCSGd MaxSpeed OnlyExplicitInline ..;../include;%(AdditionalIncludeDirectories) WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions) true MultiThreadedDLL true .\Release/OpenCSG.pch .\Release/ .\Release/ .\Release/ Level3 true Default ../lib/OpenCSG.lib true NDEBUG;%(PreprocessorDefinitions) 0x0407 MaxSpeed OnlyExplicitInline ..;../include;%(AdditionalIncludeDirectories) WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions) true MultiThreadedDLL true .\Release/OpenCSG.pch .\Release/ .\Release/ .\Release/ Level3 true Default ../lib/OpenCSG.lib true NDEBUG;%(PreprocessorDefinitions) 0x0407 Disabled ..;../include;%(AdditionalIncludeDirectories) WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions) EnableFastChecks MultiThreadedDebugDLL .\Debug/OpenCSG.pch .\Debug/ .\Debug/ .\Debug/ Level3 true EditAndContinue Default ../lib/OpenCSGd.lib true _DEBUG;%(PreprocessorDefinitions) 0x0407 Disabled ..;../include;%(AdditionalIncludeDirectories) WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions) EnableFastChecks MultiThreadedDebugDLL .\Debug/OpenCSG.pch .\Debug/ .\Debug/ .\Debug/ Level3 true ProgramDatabase Default ../lib/OpenCSGd.lib true _DEBUG;%(PreprocessorDefinitions) 0x0407 OpenCSG-1.8.2/CMakeLists.txt0000664000175000017500000000045015141675417015402 0ustar florianfloriancmake_minimum_required(VERSION 3.11) project(OpenCSG LANGUAGES CXX VERSION 1.8.2) option(BUILD_EXAMPLE "Build example program" ON) option(BUILD_SHARED_LIBS "Build using shared libraries" ON) include(GNUInstallDirs) add_subdirectory(src) if(BUILD_EXAMPLE) add_subdirectory(example) endif() OpenCSG-1.8.2/include/0000775000175000017500000000000015141675417014266 5ustar florianflorianOpenCSG-1.8.2/include/opencsg.h0000664000175000017500000003535715141675417016112 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2002-2026, Florian Kirsch, // Hasso-Plattner-Institute at the University of Potsdam, Germany // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // opencsg.h // // main include file for OpenCSG // #ifndef __OpenCSG__opencsg_h__ #define __OpenCSG__opencsg_h__ #include #include /// OpenCSG version. The version number has been introduced with version 1.3.2. /// Format is Major|Minor|Patch, each of them being 4-bit wide. #define OPENCSG_VERSION 0x0182 #define OPENCSG_VERSION_STRING "OpenCSG 1.8.2" namespace OpenCSG { enum Operation { Intersection, Subtraction }; /// Abstract base class for CSG primitives. /// From this class, derive concrete classes to do CSG rendering. class Primitive { public: Primitive(Operation, unsigned int convexity); virtual ~Primitive(); /// Sets the CSG operation. /// The operation specifies whether the primitive is intersected /// or subtracted. void setOperation(Operation); /// Returns the CSG operation. Operation getOperation() const; /// Sets the convexity. /// The convexity is the maximum number of front faces of the /// primitive at a single position. For example, the convexity /// of a sphere is 1, and of a torus is 2. Actually the convexity /// is only used in the Goldfeather algorithm. For this algorithm, /// a convexity too low may result in rendering errors, a convexity /// too high will reduce rendering performance. void setConvexity(unsigned int); /// Returns the convexity. unsigned int getConvexity() const; /// Sets the bounding box. /// The bounding box of the primitive is given in normalized device /// coordinates, i.e. after modelview and projection transformation. /// Setting it is not required, but allows for various performance /// optimizations. void setBoundingBox(float minx, float miny, float minz, float maxx, float maxy, float maxz); /// Returns the bounding box. void getBoundingBox(float& minx, float& miny, float& minz, float& maxx, float& maxy, float& maxz) const; /// render() is the abstract render method, to be implemented in /// derived classes. In the implementation, be sure not to alter /// the modelview or projection (glPushMatrix/glPopMatrix might be /// a good idea). Also do not alter colors in your render() method: /// OpenCSG uses them internally. For best performance, you should /// only transmit vertex positions; no normals, tex coords or /// whatever else. virtual void render() = 0; private: Operation mOperation; unsigned int mConvexity; float mMinx, mMiny, mMinz, mMaxx, mMaxy, mMaxz; }; /// The function render() performs CSG rendering. The function initializes /// the z-buffer with the z-values of the CSG product given as array of /// primitives. It does not alter the color buffer, so you have to shade /// the primitives using GL_EQUAL depth function afterwards. The content /// of the stencil buffer is destroyed when handling concave primitives or /// when using the DepthComplexitySampling strategy. /// /// render() respects the OpenGL settings of /// - scissor test (CSG calculating will only occur in the specified region) /// - stencil test, when only convex primitives are used and no layered /// algorithm is used. Most stenciling ops (increment / decrement /// / zero / one) will not be useful anyway. /// /// render() ignores /// - depth test (always GL_LESS) /// - alpha test (used internally) /// - cull face (used internally to distinguish intersected / subtracted /// primitives) /// /// The exact CSG algorithm can be specified using the setOption() function /// of which the possible parameters are described below. An overloaded /// version of the render() function is provided below, which takes /// some parameters for specifying Algorithm and DepthComplexityAlgorithm /// directly. void render(const std::vector& primitives); /// Sets a vertex shader that is used by OpenCSG for transforming the /// geometry. By default, or when an empty vertex shader is set, OpenCSG /// uses the fixed function pipeline. When setting a non-empty vertex /// shader, that shader is used. There is no need, and no possibility, /// to set a corresponding fragment shader. OpenCSG internally sets /// a matching fragment shader itself. /// The shader should only set the gl_Position of the input point. /// Usually it is something as: /** #version 110 void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; } **/ /// Important is that the shader should transform the vertices in /// exactly the same way as later, when the geometry is shaded /// using the GL_EQUAL depth function. void setVertexShader(const std::string& vertexShader); /// OpenCSG option for use with setOption() / getOption() below enum OptionType { AlgorithmSetting = 0, DepthComplexitySetting = 1, OffscreenSetting = 2, DepthBoundsOptimization = 3, CameraOutsideOptimization = 4, OptionTypeUnused = 5 }; /// Sets an OpenCSG option. /// The option parameter specifies which option to set. The newSetting /// is the new setting and should be one of the Algorithm, /// DepthComplexityAlgorithm, or OffscreenType enums below. void setOption(OptionType option, int newSetting); /// Returns the current setting of the provided option type. int getOption(OptionType option); /// The Algorithm specifies the method used for CSG rendering: /// - Goldfeather: This algorithm handles convex and concave primitives. /// It handles the case that the camera is inside of /// the CSG model better. Generally, it is also known /// to be more robust. /// - SCS : This algorithm handles only convex primitives. /// It is usually faster than Goldfeather. /// - Automatic : This setting currently choses Goldfeather if the /// primitive vector contains concave primitives, else it /// choses SCS. Also sets the DepthComplexityAlgorithm /// (NoDepthComplexitySampling for arrays with few /// primitives, else OcclusionQuery or at the last resort /// DepthComplexitySampling). This setting is the default. enum Algorithm { Automatic = 0, Goldfeather = 1, SCS = 2 }; /// The DepthComplexityAlgorithm specifies the strategy for profiting /// from depth complexity when performing the CSG rendering. /// - NoDepthComplexitySampling: Does not employ the depth complexity. /// This essentially makes the algorithm O(n), but with /// low constant costs. /// - DepthComplexitySampling: Calculates the depth complexity k using /// the stencil buffer. This makes algorithm O(n*k), but /// with high constant costs. In case of the Goldfeather, /// the literature denotes this as layered Goldfeather /// algorithm. /// - OcclusionQuery: Uses occlusion queries to profit implicitly from /// depth complexity without calculating it. This is /// especially useful for the SCS algorithm where this /// strategy is applied at shape level, resulting in a /// O(n*k') algorithm (where k' <= k), without significant /// constant overhead. This strategy requires hardware /// occlusion queries (i.E., the OpenGL-extension /// GL_ARB_occlusion_query or GL_NV_occlusion_query). enum DepthComplexityAlgorithm { NoDepthComplexitySampling = 0, OcclusionQuery = 1, DepthComplexitySampling = 2 }; /// The OffscreenType sets the type of offscreen buffer which is used for /// the internal calculations. /// - AutomaticOffscreenType: Chooses internally depending on available /// OpenGL extensions. If graphics hardware supports different /// extensions, with most precedence ARB frame buffer objects /// are used, then EXT frame buffer objects. /// - FrameBufferObject: Same as AutomaticOffscreenType. /// - PBuffer (2): Not supported anymore /// - FrameBufferObjectARB: Forces ARB frame buffer objects to be used. /// - FrameBufferObjectEXT: Forces EXT frame buffer objects to be used. enum OffscreenType { AutomaticOffscreenType = 0, FrameBufferObject = 1, FrameBufferObjectARB = 3, FrameBufferObjectEXT = 4 }; /// The Optimization flags set whether a specific kind of rendering per- /// formance optimization is enabled or not. This can be set for the /// following kind of optimizations: /// - DepthBoundsOptimization: Improves rendering performance by using /// the depth bounds check found on some graphics hardware. By default, /// this optimization is turned off! When you turn it on, you must /// provide correct bounding boxes for all primitives, in particular /// along the z-axis. /// - CameraOutsideOptimization: This setting enables rendering /// optimizations that are only valid if the camera is known to be /// outside of the CSG model. I.e., if the camera is inside of the /// CSG model and the setting is enabled, rendering errors occur /// that could be avoided otherwise. By default, this setting is /// enabled(!) for the SCS, but disabled for the Goldfeather algorithm. /// See the remarks for the two algorithms for details. /// For the Goldfeather algorithm, the setting controls how the parity /// is calculated. The parity value is the number of surfaces in front /// of the surface for that visibility is about to be determined. The /// textbook approach to determine it is to render all surfaces that /// are in front (z-pass). This has the drawback, though, that if the /// camera is inside of the CSG model, some surfaces could be clipped /// by the view frustum, resulting that rendering is not correct. The /// alternative approach is to render surfaces behind (z-fail). With /// that, clipping of the surfaces is much less likely to happen and /// easy to avoid. So this is the more robust setting and OpenCSG uses /// it by default. The performance of the two approaches is usually /// similar. If the camera is outside of the CSG model, you may enable /// the CameraOutsideOptimization setting to check if it somehow works /// better for your. /// In the SCS algorithm, the setting controls the workings in the /// subtraction phase of the algorithm. When subtracting a primitive /// relative to the current z-buffer, the default, textbook approach /// is to mark the visible, front-facing polygons of the primitive in /// the stencil buffer. (At these places then the z-buffer is updated /// with the back-facing polygons behind the z-buffer). This approach /// however fails if the front faces of the subtracted primitive are /// clipped. The alternative, more compatible approach renders the /// primitive even one more time to avoid this problem. That approach, /// in OpenCSG, is disabled by default, i.e., by default the /// CameraOutsideOptimization is enabled. This is for two reasons: /// * SCS still does not handle all cases correctly with the /// CameraOutsideOptimization that is disabled. In particular, /// if the front, intersected primitives are clipped by the view /// frustum, rendering is incorrect. An example is the pipe model /// in the example application. /// * The more compatible approach is also consistently slower. /// Each optimization can be independently set /// - OptimizationDefault to its default value /// - OptimizationForceOn on (does not check OpenGL extensions) /// - OptimizationOn on if required OpenGL extensions are supported, /// - OptimizationOff off enum Optimization { OptimizationDefault = 0, OptimizationForceOn = 1, OptimizationOn = 2, OptimizationOff = 3 }; /// Setting the context is required for applications rendering with /// OpenCSG in different OpenGL windows with OpenGL contexts that /// are not shared. This is needed for internal OpenGL resources, /// such as frame buffer objects, which are created in /// in the render() method and recycled when render() is called again. /// The resources are only valid in the OpenGL context they have /// been created (and in contexts shared with this context). /// To manage this, this function allows to set the identifier of /// resources, which is respected during the render() function. /// OpenGL resources are created/reused by the render() function /// per context. /// The value of context has no specific meaning for OpenCSG; /// it is only used as key in a dictionary to access the OpenGL /// resources. The default context is 0. void setContext(int context); /// Returns the current context. int getContext(); /// Releases the OpenGL resources allocated by OpenCSG for the current /// context. void freeResources(); } // namespace OpenCSG #endif // __OpenCSG__opencsg_h__ OpenCSG-1.8.2/version.txt0000664000175000017500000000001615141675417015066 0ustar florianflorianOpenCSG-1.8.2 OpenCSG-1.8.2/OpenCSG_vc2022.sln0000664000175000017500000000444115141675417015620 0ustar florianflorianMicrosoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 17 VisualStudioVersion = 17.5.318.41597 MinimumVisualStudioVersion = 10.0.40219.1 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "OpenCSG", "win32\OpenCSG.vcxproj", "{BB6A8C4D-37B1-81CB-862A-BDDA0906D298}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "OpenCSGexample", "example\OpenCSGexample.vcxproj", "{9E8633EF-69FE-BF99-A40F-B540D039FBFC}" ProjectSection(ProjectDependencies) = postProject {BB6A8C4D-37B1-81CB-862A-BDDA0906D298} = {BB6A8C4D-37B1-81CB-862A-BDDA0906D298} EndProjectSection EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Win32 = Debug|Win32 Debug|x64 = Debug|x64 Release|Win32 = Release|Win32 Release|x64 = Release|x64 EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {BB6A8C4D-37B1-81CB-862A-BDDA0906D298}.Debug|Win32.ActiveCfg = Debug|Win32 {BB6A8C4D-37B1-81CB-862A-BDDA0906D298}.Debug|Win32.Build.0 = Debug|Win32 {BB6A8C4D-37B1-81CB-862A-BDDA0906D298}.Debug|x64.ActiveCfg = Debug|x64 {BB6A8C4D-37B1-81CB-862A-BDDA0906D298}.Debug|x64.Build.0 = Debug|x64 {BB6A8C4D-37B1-81CB-862A-BDDA0906D298}.Release|Win32.ActiveCfg = Release|Win32 {BB6A8C4D-37B1-81CB-862A-BDDA0906D298}.Release|Win32.Build.0 = Release|Win32 {BB6A8C4D-37B1-81CB-862A-BDDA0906D298}.Release|x64.ActiveCfg = Release|x64 {BB6A8C4D-37B1-81CB-862A-BDDA0906D298}.Release|x64.Build.0 = Release|x64 {9E8633EF-69FE-BF99-A40F-B540D039FBFC}.Debug|Win32.ActiveCfg = Debug|Win32 {9E8633EF-69FE-BF99-A40F-B540D039FBFC}.Debug|Win32.Build.0 = Debug|Win32 {9E8633EF-69FE-BF99-A40F-B540D039FBFC}.Debug|x64.ActiveCfg = Debug|x64 {9E8633EF-69FE-BF99-A40F-B540D039FBFC}.Debug|x64.Build.0 = Debug|x64 {9E8633EF-69FE-BF99-A40F-B540D039FBFC}.Release|Win32.ActiveCfg = Release|Win32 {9E8633EF-69FE-BF99-A40F-B540D039FBFC}.Release|Win32.Build.0 = Release|Win32 {9E8633EF-69FE-BF99-A40F-B540D039FBFC}.Release|x64.ActiveCfg = Release|x64 {9E8633EF-69FE-BF99-A40F-B540D039FBFC}.Release|x64.Build.0 = Release|x64 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {06F4EF32-F0A2-426E-BB93-208DDE0341E4} EndGlobalSection EndGlobal OpenCSG-1.8.2/example/0000775000175000017500000000000015141675417014276 5ustar florianflorianOpenCSG-1.8.2/example/includeGl.h0000664000175000017500000000301415141675417016353 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2023-2026, Florian Kirsch // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // includeGl.h // // Includes glut.h. Note that this implicitely also includes GL/gl.h // This is because the example program no longer depend on GLEW // anymore and does not include glew.h. But including GL/gl.h // directly tends to be non-portable. // #ifndef __OpenCSG__include_gl_h__ #define __OpenCSG__include_gl_h__ #ifdef __APPLE__ #include #elif _WIN32 // glut include under windows, assuming that freeglut binary has been // directly put into the opencsg main directory (e.g., try to use the // freeglut 3.0.0 MSVC Package that is available from // https://www.transmissionzero.co.uk/software/freeglut-devel) #include <../freeglut/include/GL/glut.h> #else #include #endif #endif OpenCSG-1.8.2/example/OpenCSGexample.vcxproj0000664000175000017500000003404315141675417020531 0ustar florianflorian Debug Win32 Debug x64 Release Win32 Release x64 {9E8633EF-69FE-BF99-A40F-B540D039FBFC} Application false MultiByte v143 Application false MultiByte v143 Application false MultiByte v143 Application false MultiByte v143 <_ProjectFileVersion>10.0.40219.1 .\Debug\ .\Debug\ .\Debug\ .\Debug\ true true .\Release\ .\Release\ .\Release\ .\Release\ false false $(IncludePath) $(IncludePath) $(LibraryPath) $(LibraryPath) $(IncludePath) $(IncludePath) $(LibraryPath) $(LibraryPath) Disabled ../include;%(AdditionalIncludeDirectories) WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) EnableFastChecks MultiThreadedDebugDLL .\Debug/OpenCSGexample.pch .\Debug/ .\Debug/ .\Debug/ Level3 true EditAndContinue Default OpenCSGd.lib;glu32.lib;opengl32.lib;%(AdditionalDependencies) .\Debug/OpenCSGexample.exe true ../lib;../freeglut/lib;%(AdditionalLibraryDirectories) false true .\Debug/OpenCSGexample.pdb Console MachineX86 .\Debug/OpenCSGexample.tlb _DEBUG;%(PreprocessorDefinitions) 0x0407 Disabled ../include;%(AdditionalIncludeDirectories) WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) EnableFastChecks MultiThreadedDebugDLL .\Debug/OpenCSGexample.pch .\Debug/ .\Debug/ .\Debug/ Level3 true ProgramDatabase Default OpenCSGd.lib;glu32.lib;opengl32.lib;%(AdditionalDependencies) .\Debug/OpenCSGexample.exe true ../lib;../freeglut/lib/x64;%(AdditionalLibraryDirectories) false true .\Debug/OpenCSGexample.pdb Console .\Debug/OpenCSGexample.tlb _DEBUG;%(PreprocessorDefinitions) 0x0407 MaxSpeed OnlyExplicitInline ../include;%(AdditionalIncludeDirectories) WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) true MultiThreadedDLL true .\Release/OpenCSGexample.pch .\Release/ .\Release/ .\Release/ Level3 true Default OpenCSG.lib;glu32.lib;opengl32.lib;%(AdditionalDependencies) .\Release/OpenCSGexample.exe true ../lib;../freeglut/lib;%(AdditionalLibraryDirectories) true .\Release/OpenCSGexample.map Console MachineX86 false libcmt .\Release/OpenCSGexample.tlb NDEBUG;%(PreprocessorDefinitions) 0x0407 MaxSpeed OnlyExplicitInline ../include;%(AdditionalIncludeDirectories) WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) true MultiThreadedDLL true .\Release/OpenCSGexample.pch .\Release/ .\Release/ .\Release/ Level3 true Default OpenCSG.lib;glu32.lib;opengl32.lib;%(AdditionalDependencies) .\Release/OpenCSGexample.exe true ../lib;../freeglut/lib/x64;%(AdditionalLibraryDirectories) true .\Release/OpenCSGexample.map Console false libcmt .\Release/OpenCSGexample.tlb NDEBUG;%(PreprocessorDefinitions) 0x0407 OpenCSG-1.8.2/example/displaylistPrimitive.h0000664000175000017500000000353115141675417020703 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2002-2026, Florian Kirsch, // Hasso-Plattner-Institute at the University of Potsdam, Germany // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // displaylistPrimitive.h // // example for a primitive which renders itself using a display list // #ifndef __OpenCSG__displaylistprimitive_h__ #define __OpenCSG__displaylistprimitive_h__ #include namespace OpenCSG { class DisplayListPrimitive : public Primitive { public: /// An object of this class contains the OpenGL id of a display /// list that is compiled by the application. render() just invokes /// this display list. /// Operation and convexity are just forwarded to the base Primitive class. DisplayListPrimitive(unsigned int displayListId_, Operation, unsigned int convexity); /// Sets the display list id void setDisplayListId(unsigned int); /// Returns the display list id unsigned int getDisplayListId() const; /// Calls the display list. virtual void render(); private: unsigned int mDisplayListId; }; } // namespace OpenCSG #endif OpenCSG-1.8.2/example/OpenCSGexample.dsp0000664000175000017500000000727615141675417017634 0ustar florianflorian# Microsoft Developer Studio Project File - Name="OpenCSGexample" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Console Application" 0x0103 CFG=OpenCSGexample - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "OpenCSGexample.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "OpenCSGexample.mak" CFG="OpenCSGexample - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "OpenCSGexample - Win32 Release" (based on "Win32 (x86) Console Application") !MESSAGE "OpenCSGexample - Win32 Debug" (based on "Win32 (x86) Console Application") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "OpenCSGexample - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "Release" # PROP Intermediate_Dir "Release" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c # ADD CPP /nologo /W3 /GX /O2 /I "../include" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FR /YX /FD /c # ADD BASE RSC /l 0x407 /d "NDEBUG" # ADD RSC /l 0x407 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 # ADD LINK32 OpenCSG.lib glu32.lib glut32.lib opengl32.lib kernel32.lib user32.lib gdi32.lib /nologo /subsystem:console /profile /map /machine:I386 /libpath:"../lib" /libpath:"../glew/lib" !ELSEIF "$(CFG)" == "OpenCSGexample - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "Debug" # PROP BASE Intermediate_Dir "Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "Debug" # PROP Intermediate_Dir "Debug" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c # ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "../include" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FR /YX /FD /GZ /c # ADD BASE RSC /l 0x407 /d "_DEBUG" # ADD RSC /l 0x407 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept # ADD LINK32 OpenCSGd.lib glu32.lib glut32.lib opengl32.lib kernel32.lib user32.lib gdi32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"../lib" /libpath:"../glew/lib" !ENDIF # Begin Target # Name "OpenCSGexample - Win32 Release" # Name "OpenCSGexample - Win32 Debug" # Begin Source File SOURCE=.\displaylistPrimitive.cpp # End Source File # Begin Source File SOURCE=.\displaylistPrimitive.h # End Source File # Begin Source File SOURCE=.\includeGl.h # End Source File # Begin Source File SOURCE=.\main.cpp # End Source File # End Target # End Project OpenCSG-1.8.2/example/CMakeLists.txt0000664000175000017500000000101715141675417017035 0ustar florianflorianadd_executable(opencsgexample WIN32 MACOSX_BUNDLE displaylistPrimitive.cpp displaylistPrimitive.h includeGl.h main.cpp ) find_package(OpenGL REQUIRED) find_package(GLUT REQUIRED) target_include_directories(opencsgexample PRIVATE "${CMAKE_SOURCE_DIR}/include" ) target_link_libraries(opencsgexample PRIVATE opencsg ${OPENGL_LIBRARIES} ${GLUT_LIBRARIES} ) install(TARGETS opencsgexample BUNDLE DESTINATION ${CMAKE_INSTALL_PREFIX}/Applications RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} ) OpenCSG-1.8.2/example/main.cpp0000664000175000017500000006124415141675417015735 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2002-2026, Florian Kirsch, // Hasso-Plattner-Institute at the University of Potsdam, Germany // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // main.cpp // // simple example program for OpenCSG using Glut // #include #include "displaylistPrimitive.h" #include #include #include #include // include glut.h after stdlib.h to avoid conflict in declaration // of exit() with Visual Studio 2010 #include "includeGl.h" enum { BENCH_START, CSG_BASIC, CSG_WIDGET, CSG_GRID2D, CSG_GRID3D, CSG_CUBERACK, CSG_PIPE, CSG_CONCAVE, ALGO_AUTOMATIC, GF_STANDARD, GF_DC, GF_OQ, SCS_STANDARD, SCS_DC, SCS_OQ, CAM_OUTSIDE_DEFAULT, CAM_OUTSIDE_PERF, CAM_OUTSIDE_NOPERF, CAM_INSIDE, CAM_INSIDE_DEFAULT, GLSL_FIXED_FUNCTION, GLSL_FTRANSFORM, GLSL_MVP_COMBINED, GLSL_MVP_SEPARATE }; std::vector primitives; std::vector primitives2; std::vector primitives3; bool spin = true; bool inside = false; float rot = 0.0f; std::ostringstream fpsStream; std::vector displaylistGarbagePile; bool benchmode = false; bool benchSettingFrameOne = false; bool skipCubeRack = false; int benchShape = BENCH_START; int benchAlgorithm = GF_STANDARD; int benchPerfOption = CAM_OUTSIDE_DEFAULT; void clearPrimitives(std::vector & p) { for (std::vector::const_iterator it = p.begin(); it != p.end(); ++it) { OpenCSG::DisplayListPrimitive* primitive = static_cast(*it); GLuint id = primitive->getDisplayListId(); if (std::find(displaylistGarbagePile.begin(), displaylistGarbagePile.end(), id) == displaylistGarbagePile.end()) { glDeleteLists(1, id); displaylistGarbagePile.push_back(id); } delete primitive; } p.clear(); } void clearPrimitives() { displaylistGarbagePile.clear(); clearPrimitives(primitives); clearPrimitives(primitives2); clearPrimitives(primitives3); displaylistGarbagePile.clear(); } void solidCylinder(GLdouble radius, GLdouble height, GLint slices, GLint stacks) { GLUquadricObj* qobj = gluNewQuadric(); gluCylinder(qobj, radius, radius, height, slices, stacks); glScalef(-1.0f, 1.0f, -1.0f); gluDisk(qobj, 0.0, radius, slices, stacks); glScalef(-1.0f, 1.0f, -1.0f); glTranslatef(0.0f, 0.0f, static_cast(height)); gluDisk(qobj, 0.0, radius, slices, stacks); gluDeleteQuadric(qobj); } void setBasicShape() { clearPrimitives(); GLuint id1 = glGenLists(1); glNewList(id1, GL_COMPILE); glPushMatrix(); glTranslatef(-0.25f, 0.0f, 0.0f); glutSolidSphere(1.0, 20, 20); glPopMatrix(); glEndList(); GLuint id2 = glGenLists(1); glNewList(id2, GL_COMPILE); glPushMatrix(); glTranslatef(0.25f, 0.0f, 0.0f); glutSolidSphere(1.0, 20, 20); glPopMatrix(); glEndList(); GLuint id3 = glGenLists(1); glNewList(id3, GL_COMPILE); glPushMatrix(); glTranslatef(0.0f, 0.0f, 0.5f); glScalef(0.5f, 0.5f, 2.0f); glutSolidSphere(1.0, 20, 20); glPopMatrix(); glEndList(); primitives.push_back(new OpenCSG::DisplayListPrimitive(id1, OpenCSG::Intersection, 1)); primitives.push_back(new OpenCSG::DisplayListPrimitive(id2, OpenCSG::Intersection, 1)); primitives.push_back(new OpenCSG::DisplayListPrimitive(id3, OpenCSG::Subtraction, 1)); } void setWidget() { clearPrimitives(); GLuint id1 = glGenLists(1); glNewList(id1, GL_COMPILE); glutSolidSphere(1.2, 20, 20); glEndList(); GLuint id2 = glGenLists(1); glNewList(id2, GL_COMPILE); glutSolidCube(1.8); glEndList(); GLuint id3 = glGenLists(1); glNewList(id3, GL_COMPILE); glPushMatrix(); glTranslatef(0.0f, 0.0f, -1.25f); solidCylinder(0.6, 2.5, 20, 20); glPopMatrix(); glEndList(); GLuint id4 = glGenLists(1); glNewList(id4, GL_COMPILE); glPushMatrix(); glRotatef(90.0f, 0.0f, 1.0f, 0.0f); glTranslatef(0.0f, 0.0f, -1.25f); solidCylinder(0.6, 2.5, 20, 20); glPopMatrix(); glEndList(); GLuint id5 = glGenLists(1); glNewList(id5, GL_COMPILE); glPushMatrix(); glRotatef(90.0f, 1.0f, 0.0f, 0.0f); glTranslatef(0.0f, 0.0f, -1.25f); solidCylinder(0.6, 2.5, 20, 20); glPopMatrix(); glEndList(); primitives.push_back(new OpenCSG::DisplayListPrimitive(id1, OpenCSG::Intersection, 1)); primitives.push_back(new OpenCSG::DisplayListPrimitive(id2, OpenCSG::Intersection, 1)); primitives.push_back(new OpenCSG::DisplayListPrimitive(id3, OpenCSG::Subtraction, 1)); primitives.push_back(new OpenCSG::DisplayListPrimitive(id4, OpenCSG::Subtraction, 1)); primitives.push_back(new OpenCSG::DisplayListPrimitive(id5, OpenCSG::Subtraction, 1)); } void setGrid2D() { clearPrimitives(); GLuint id1 = glGenLists(1); glNewList(id1, GL_COMPILE); glPushMatrix(); glScalef(1.0f, 0.2f, 1.0f); glTranslatef(0.0f, -1.25f, 0.0f); glutSolidCube(2.5); glPopMatrix(); glEndList(); primitives.push_back(new OpenCSG::DisplayListPrimitive(id1, OpenCSG::Intersection, 1)); for (int x=-2; x<=2; ++x) { for (int z=-2; z<=2; ++z) { GLuint id = glGenLists(1); glNewList(id, GL_COMPILE); glPushMatrix(); glTranslatef(x*0.5f, 0.0f, z*0.5f); glutSolidSphere(0.22, 15, 15); glPopMatrix(); glEndList(); primitives.push_back(new OpenCSG::DisplayListPrimitive(id, OpenCSG::Subtraction, 1)); } } } void setGrid3D() { clearPrimitives(); GLuint id1 = glGenLists(1); glNewList(id1, GL_COMPILE); glutSolidCube(2.0); glEndList(); primitives.push_back(new OpenCSG::DisplayListPrimitive(id1, OpenCSG::Intersection, 1)); for (int x=-1; x<=1; ++x) { for (int y=-1; y<=1; ++y) { for (int z=-1; z<=1; ++z) { GLuint id = glGenLists(1); glNewList(id, GL_COMPILE); glPushMatrix(); glTranslatef(static_cast(x), static_cast(y), static_cast(z)); glutSolidSphere(0.58, 20, 20); glPopMatrix(); glEndList(); primitives.push_back(new OpenCSG::DisplayListPrimitive(id, OpenCSG::Subtraction, 1)); } } } } void setCubeRack() { clearPrimitives(); GLuint id1 = glGenLists(1); glNewList(id1, GL_COMPILE); glutSolidCube(2.0); glEndList(); primitives.push_back(new OpenCSG::DisplayListPrimitive(id1, OpenCSG::Intersection, 1)); // mx*x / my*y / mz*z loop all numbers in [-3, 3] in the following order: // 3, -3, 2, -2, 1, -1, 0. Compared to the trivial ordering, this makes // the CSG rendering less depending on the camera orientation. for (int x=3; x>=0; --x) { for (int y=3; y>=0; --y) { for (int z=3; z>=0; --z) { for (int mx=-1; mx<=1 && mx<=x; mx+=2) { for (int my=-1; my<=1 && my<=y; my+=2) { for (int mz=-1; mz<=1 && mz<=z; mz+=2) { GLuint id = glGenLists(1); glNewList(id, GL_COMPILE); glPushMatrix(); glTranslatef(float(x*mx)/6.0f, float(y*my)/6.0f, float(z*mz)/6.0f); glutSolidSphere(0.58, 20, 20); glPopMatrix(); glEndList(); primitives.push_back(new OpenCSG::DisplayListPrimitive(id, OpenCSG::Subtraction, 1)); } } } } } } } void setPipe() { clearPrimitives(); GLuint id1 = glGenLists(1); glNewList(id1, GL_COMPILE); glPushMatrix(); glTranslatef(0.0f, 0.0f, -2.5f); solidCylinder(0.6, 2.5, 20, 20); glPopMatrix(); glEndList(); GLuint id2 = glGenLists(1); glNewList(id2, GL_COMPILE); glPushMatrix(); glTranslatef(0.0f, 0.0f, -2.51f); solidCylinder(0.5, 2.52, 20, 20); glPopMatrix(); glEndList(); GLuint id3 = glGenLists(1); glNewList(id3, GL_COMPILE); glPushMatrix(); glRotatef(90.0f, 0.0f, 1.0f, 0.0f); glTranslatef(0.0f, 0.0f, -2.5f); solidCylinder(0.6, 2.5, 20, 20); glPopMatrix(); glEndList(); GLuint id4 = glGenLists(1); glNewList(id4, GL_COMPILE); glPushMatrix(); glRotatef(90.0f, 0.0f, 1.0f, 0.0f); glTranslatef(0.0f, 0.0f, -2.51f); solidCylinder(0.5, 2.52, 20, 20); glPopMatrix(); glEndList(); GLuint id5 = glGenLists(1); glNewList(id5, GL_COMPILE); glutSolidSphere(0.6, 20, 20); glEndList(); GLuint id6 = glGenLists(1); glNewList(id6, GL_COMPILE); glutSolidSphere(0.5, 20, 20); glEndList(); GLuint id7 = glGenLists(1); glNewList(id7, GL_COMPILE); glPushMatrix(); glTranslatef(-0.8f, 1.0f, -0.8f); glutSolidCube(2.0); glPopMatrix(); glEndList(); primitives.push_back(new OpenCSG::DisplayListPrimitive(id1, OpenCSG::Intersection, 1)); primitives.push_back(new OpenCSG::DisplayListPrimitive(id2, OpenCSG::Subtraction, 1)); primitives.push_back(new OpenCSG::DisplayListPrimitive(id4, OpenCSG::Subtraction, 1)); primitives.push_back(new OpenCSG::DisplayListPrimitive(id7, OpenCSG::Subtraction, 1)); primitives2.push_back(new OpenCSG::DisplayListPrimitive(id3, OpenCSG::Intersection, 1)); primitives2.push_back(new OpenCSG::DisplayListPrimitive(id2, OpenCSG::Subtraction, 1)); primitives2.push_back(new OpenCSG::DisplayListPrimitive(id4, OpenCSG::Subtraction, 1)); primitives2.push_back(new OpenCSG::DisplayListPrimitive(id7, OpenCSG::Subtraction, 1)); primitives3.push_back(new OpenCSG::DisplayListPrimitive(id5, OpenCSG::Intersection, 1)); primitives3.push_back(new OpenCSG::DisplayListPrimitive(id6, OpenCSG::Subtraction, 1)); primitives3.push_back(new OpenCSG::DisplayListPrimitive(id2, OpenCSG::Subtraction, 1)); primitives3.push_back(new OpenCSG::DisplayListPrimitive(id4, OpenCSG::Subtraction, 1)); primitives3.push_back(new OpenCSG::DisplayListPrimitive(id7, OpenCSG::Subtraction, 1)); } void setConcave() { clearPrimitives(); GLuint id1 = glGenLists(1); glNewList(id1, GL_COMPILE); glutSolidTorus(0.6, 1.0, 25, 25); glEndList(); primitives.push_back(new OpenCSG::DisplayListPrimitive(id1, OpenCSG::Intersection, 2)); for (unsigned int i=0; i<4; ++i) { GLuint id = glGenLists(1); glNewList(id, GL_COMPILE); glPushMatrix(); glRotatef(90.0f, 0.0f, 1.0f, 0.0f); glRotatef(i*90.0f + 45.0f, 1.0f, 0.0f, 0.0f); glTranslatef(0.0f, 1.0f, 0.0f); glutSolidTorus(0.3, 0.6, 15, 15); glPopMatrix(); glEndList(); primitives.push_back(new OpenCSG::DisplayListPrimitive(id, OpenCSG::Subtraction, 2)); } GLuint id3 = glGenLists(1); glNewList(id3, GL_COMPILE); glPushMatrix(); glRotatef(90.0f, 0.0f, 1.0f, 0.0f); glTranslatef(0.0f, 0.0f, -1.65f); solidCylinder(0.3, 3.3, 20, 20); glPopMatrix(); glEndList(); primitives.push_back(new OpenCSG::DisplayListPrimitive(id3, OpenCSG::Subtraction, 1)); GLuint id4 = glGenLists(1); glNewList(id4, GL_COMPILE); glPushMatrix(); glRotatef(90.0f, 1.0f, 0.0f, 0.0f); glTranslatef(0.0f, 0.0f, -1.65f); solidCylinder(0.3, 3.3, 20, 20); glPopMatrix(); glEndList(); primitives.push_back(new OpenCSG::DisplayListPrimitive(id4, OpenCSG::Subtraction, 1)); } void renderfps() { glDisable(GL_DEPTH_TEST); glLoadIdentity(); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glColor3f(0.0f, 0.0f, 0.0f); glRasterPos2f(-1.0f, -1.0f); glDisable(GL_LIGHTING); std::string s = fpsStream.str(); for (unsigned int i=0; i::const_iterator itr; for (itr = primitives.begin(); itr != primitives.end(); ++itr) { (*itr)->render(); } for (itr = primitives2.begin(); itr != primitives2.end(); ++itr) { (*itr)->render(); } for (itr = primitives3.begin(); itr != primitives3.end(); ++itr) { (*itr)->render(); } glDepthFunc(GL_LESS); if (!benchmode) renderfps(); glutSwapBuffers(); } namespace { const std::string ftransformShader = "#version 110\n" "void main() {\n" " gl_Position = ftransform();\n" "}\n"; const std::string mvpCombinedShader = "#version 110\n" "void main() {\n" " gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n" "}\n"; const std::string mvpSeparateShader = "#version 110\n" "void main() {\n" " gl_Position = gl_ProjectionMatrix * gl_ModelViewMatrix * gl_Vertex;\n" "}\n"; } void menu(int value) { switch (value) { case CSG_BASIC: setBasicShape(); break; case CSG_WIDGET: setWidget(); break; case CSG_GRID2D: setGrid2D(); break; case CSG_GRID3D: setGrid3D(); break; case CSG_CUBERACK: setCubeRack(); break; case CSG_PIPE: setPipe(); break; case CSG_CONCAVE: setConcave(); break; case ALGO_AUTOMATIC: OpenCSG::setOption(OpenCSG::AlgorithmSetting, OpenCSG::Automatic); break; case GF_STANDARD: OpenCSG::setOption(OpenCSG::AlgorithmSetting, OpenCSG::Goldfeather); OpenCSG::setOption(OpenCSG::DepthComplexitySetting, OpenCSG::NoDepthComplexitySampling); break; case GF_DC: OpenCSG::setOption(OpenCSG::AlgorithmSetting, OpenCSG::Goldfeather); OpenCSG::setOption(OpenCSG::DepthComplexitySetting, OpenCSG::DepthComplexitySampling); break; case GF_OQ: OpenCSG::setOption(OpenCSG::AlgorithmSetting, OpenCSG::Goldfeather); OpenCSG::setOption(OpenCSG::DepthComplexitySetting, OpenCSG::OcclusionQuery); break; case SCS_STANDARD: OpenCSG::setOption(OpenCSG::AlgorithmSetting, OpenCSG::SCS); OpenCSG::setOption(OpenCSG::DepthComplexitySetting, OpenCSG::NoDepthComplexitySampling); break; case SCS_DC: OpenCSG::setOption(OpenCSG::AlgorithmSetting, OpenCSG::SCS); OpenCSG::setOption(OpenCSG::DepthComplexitySetting, OpenCSG::DepthComplexitySampling); break; case SCS_OQ: OpenCSG::setOption(OpenCSG::AlgorithmSetting, OpenCSG::SCS); OpenCSG::setOption(OpenCSG::DepthComplexitySetting, OpenCSG::OcclusionQuery); break; case CAM_OUTSIDE_DEFAULT: inside = false; OpenCSG::setOption(OpenCSG::CameraOutsideOptimization, OpenCSG::OptimizationDefault); break; case CAM_OUTSIDE_PERF: inside = false; OpenCSG::setOption(OpenCSG::CameraOutsideOptimization, OpenCSG::OptimizationOn); break; case CAM_OUTSIDE_NOPERF: inside = false; OpenCSG::setOption(OpenCSG::CameraOutsideOptimization, OpenCSG::OptimizationOff); break; case CAM_INSIDE: inside = true; OpenCSG::setOption(OpenCSG::CameraOutsideOptimization, OpenCSG::OptimizationOff); break; case CAM_INSIDE_DEFAULT: inside = true; OpenCSG::setOption(OpenCSG::CameraOutsideOptimization, OpenCSG::OptimizationDefault); break; case GLSL_FIXED_FUNCTION: OpenCSG::setVertexShader(""); break; case GLSL_FTRANSFORM: OpenCSG::setVertexShader(ftransformShader); break; case GLSL_MVP_COMBINED: OpenCSG::setVertexShader(mvpCombinedShader); break; case GLSL_MVP_SEPARATE: OpenCSG::setVertexShader(mvpSeparateShader); break; default: break; } display(); } void printNewBenchTableHeadline() { const char* optionName = ""; switch (benchPerfOption) { case CAM_OUTSIDE_DEFAULT: optionName = "Default performance"; break; case CAM_OUTSIDE_PERF: optionName = "Fast performance (at the expense of compatibility)"; break; case CAM_OUTSIDE_NOPERF: optionName = "Slower performance (but more compatible)"; break; } fprintf(stdout, "\n%s", optionName); fprintf(stdout, "\n Goldfeather DC OQ SCS DC OQ"); } void printNewBenchLine() { const char* shapeName = ""; switch (benchShape) { case CSG_BASIC: shapeName = " Simple"; break; case CSG_WIDGET: shapeName = " Widget"; break; case CSG_GRID2D: shapeName = " 2D-Grid"; break; case CSG_GRID3D: shapeName = " 3D-Grid"; break; case CSG_CUBERACK: shapeName = "Cuberack"; break; case CSG_PIPE: shapeName = " Pipe"; break; case CSG_CONCAVE: shapeName = " Concave"; break; } fprintf(stdout, "\n%s:", shapeName); } void applyBenchSetting() { menu(benchAlgorithm); menu(benchShape); menu(benchPerfOption); benchSettingFrameOne = true; } void nextBenchSetting() { if (benchShape == BENCH_START) { rot = 0.0f; benchShape = CSG_BASIC; benchAlgorithm = GF_STANDARD; benchPerfOption = CAM_OUTSIDE_DEFAULT; printNewBenchTableHeadline(); printNewBenchLine(); applyBenchSetting(); return; } ++benchAlgorithm; if ( (benchShape != CSG_CONCAVE && benchAlgorithm <= SCS_OQ) || (benchShape == CSG_CONCAVE && benchAlgorithm <= GF_OQ)) { applyBenchSetting(); return; } benchAlgorithm = GF_STANDARD; ++benchShape; if (skipCubeRack && (benchShape == CSG_CUBERACK)) ++benchShape; if (benchShape <= CSG_CONCAVE) { printNewBenchLine(); applyBenchSetting(); return; } fprintf(stdout, "\n"); benchShape = CSG_BASIC; ++benchPerfOption; if (benchPerfOption <= CAM_OUTSIDE_NOPERF) { printNewBenchTableHeadline(); printNewBenchLine(); applyBenchSetting(); return; } benchmode = false; } void idle() { static int ancient = 0; static int last = 0; static int msec = 0; static int numFramesRendered = 0; last = msec; msec = glutGet(GLUT_ELAPSED_TIME); if (spin) { rot += static_cast(msec-last) / 10.0f; } if (benchSettingFrameOne) { rot = 0; benchSettingFrameOne = false; last = msec; ancient = msec; numFramesRendered = 0; } if (rot >= 360.0f) { while (rot >= 360.0f) rot -= 360.0f; if (benchmode) { float correctedFps = static_cast(numFramesRendered) * 1000.0f / static_cast(msec - ancient); fprintf(stdout, "% 11.2f", correctedFps); // On a configuration that already chokes on the smaller models, do not bench the cube rack (it is far slower) if (correctedFps < 60.0f) skipCubeRack = true; nextBenchSetting(); rot = 0.0f; ancient = msec; numFramesRendered = 0; } } if (!benchmode) { if (last / 1000 != msec / 1000) { float correctedFps = static_cast(numFramesRendered) * 1000.0f / static_cast(msec - ancient); fpsStream.str(""); fpsStream << "fps: " << correctedFps << std::ends; ancient = msec; numFramesRendered = 0; } } display(); ++numFramesRendered; } void key(unsigned char k, int, int) { switch (k) { case ' ': spin = !spin; break; case 'b': skipCubeRack = false; benchmode = true; benchShape = BENCH_START; nextBenchSetting(); fpsStream.str(""); break; default: break; } display(); } void init() { // gray background glClearColor(0.9f, 0.9f, 0.9f, 1.0f); // Enable two OpenGL lights GLfloat light_diffuse[] = { 1.0f, 0.0f, 0.0f, 1.0f}; // Red diffuse light GLfloat light_position0[] = {-1.0f, -1.0f, -1.0f, 0.0f}; // Infinite light location GLfloat light_position1[] = { 1.0f, 1.0f, 1.0f, 0.0f}; // Infinite light location glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse); glLightfv(GL_LIGHT0, GL_POSITION, light_position0); glEnable(GL_LIGHT0); glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse); glLightfv(GL_LIGHT1, GL_POSITION, light_position1); glEnable(GL_LIGHT1); glEnable(GL_LIGHTING); glEnable(GL_NORMALIZE); // Use depth buffering for hidden surface elimination glEnable(GL_DEPTH_TEST); // Setup the view of the CSG shape glMatrixMode(GL_PROJECTION); gluPerspective(40.0, 1.0, 0.2, 10.0); glMatrixMode(GL_MODELVIEW); // starting CSG shape setWidget(); } int main(int argc, char **argv) { glutInit(&argc, argv); glutInitWindowSize(512, 512); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_STENCIL); glutCreateWindow("OpenCSG example application"); int menuShape = glutCreateMenu(menu); glutAddMenuEntry("Simple", CSG_BASIC); glutAddMenuEntry("Widget", CSG_WIDGET); glutAddMenuEntry("2D-Grid", CSG_GRID2D); glutAddMenuEntry("3D-Grid", CSG_GRID3D); glutAddMenuEntry("Cuberack", CSG_CUBERACK); glutAddMenuEntry("Pipe", CSG_PIPE); glutAddMenuEntry("Concave", CSG_CONCAVE); int menuAlgorithm = glutCreateMenu(menu); glutAddMenuEntry("Automatic", ALGO_AUTOMATIC); glutAddMenuEntry("Goldfeather standard", GF_STANDARD); glutAddMenuEntry("Goldfeather depth complexity sampling", GF_DC); glutAddMenuEntry("Goldfeather occlusion query", GF_OQ); glutAddMenuEntry("SCS standard", SCS_STANDARD); glutAddMenuEntry("SCS depth complexity sampling", SCS_DC); glutAddMenuEntry("SCS occlusion query", SCS_OQ); int menuCamera = glutCreateMenu(menu); glutAddMenuEntry("Camera outside (default performance optimizations)", CAM_OUTSIDE_DEFAULT); glutAddMenuEntry("Camera outside (with performance optimizations)", CAM_OUTSIDE_PERF); glutAddMenuEntry("Camera outside (without performance optimizations)", CAM_OUTSIDE_NOPERF); glutAddMenuEntry("Camera inside (default performance optimizations)", CAM_INSIDE_DEFAULT); glutAddMenuEntry("Camera inside (without performance optimizations)", CAM_INSIDE); int menuGLSL = glutCreateMenu(menu); glutAddMenuEntry("Fixed function", GLSL_FIXED_FUNCTION); glutAddMenuEntry("ftransform()", GLSL_FTRANSFORM); glutAddMenuEntry("gl_ModelViewProjectionMatrix * gl_Vertex", GLSL_MVP_COMBINED); glutAddMenuEntry("gl_ProjectionMatrix * gl_ModelViewMatrix * gl_Vertex", GLSL_MVP_SEPARATE); glutCreateMenu(menu); glutAddSubMenu("CSG Shapes", menuShape); glutAddSubMenu("CSG Algorithms", menuAlgorithm); glutAddSubMenu("Camera", menuCamera); glutAddSubMenu("Vertex Shader", menuGLSL); // connect to right mouse button glutAttachMenu(GLUT_RIGHT_BUTTON); glutDisplayFunc(display); glutKeyboardFunc(key); glutIdleFunc(idle); init(); glutMainLoop(); return 0; } OpenCSG-1.8.2/example/displaylistPrimitive.cpp0000664000175000017500000000277215141675417021244 0ustar florianflorian// OpenCSG - library for image-based CSG rendering for OpenGL // Copyright (C) 2002-2026, Florian Kirsch, // Hasso-Plattner-Institute at the University of Potsdam, Germany // // This library is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110 - 1301 USA. // // displaylistPrimitive.h // // example for a primitive which renders itself using a display list // #include "displaylistPrimitive.h" #include "includeGl.h" namespace OpenCSG { DisplayListPrimitive::DisplayListPrimitive(unsigned int i, Operation o, unsigned int c) : Primitive(o, c) { mDisplayListId = i; } void DisplayListPrimitive::setDisplayListId(unsigned int i) { mDisplayListId = i; } unsigned int DisplayListPrimitive::getDisplayListId() const { return mDisplayListId; } void DisplayListPrimitive::render() { glCallList(mDisplayListId); } } OpenCSG-1.8.2/copying.txt0000664000175000017500000000070615141675417015057 0ustar florianflorianOpenCSG is available under the GNU General Public License, either version 2, or since OpenCSG version 1.5.0 - at your option - any later version. Please read these files for the full licenses. doc/license/gpl-2.0.txt doc/license/gpl-3.0.txt Note that OpenCSG comes with code that is not copyrighted by me, in particular GLEW (http://glew.sourceforge.net) These libraries are licensed under the terms of their respective authors. 2025, Florian Kirsch OpenCSG-1.8.2/doc/0000775000175000017500000000000015141675417013410 5ustar florianflorianOpenCSG-1.8.2/doc/index.html0000664000175000017500000007701515141675417015417 0ustar florianflorian OpenCSG - The CSG rendering library
OpenCSG logo

OpenCSG

The CSG rendering library

News    Introduction    Benefits    Prerequisites    Usage    Download    References    Background    Publications    FAQ    License    		OpenGL logo

Latest release: OpenCSG 1.8.2 (08-Feb-2026)

Introduction

OpenCSG is a library that does image-based CSG rendering using OpenGL. It is written in C++ and supports most modern graphics hardware using Microsoft Windows or the Linux operating system. The current version is OpenCSG-1.8.2.

What is CSG, anyway? CSG is short for Constructive Solid Geometry and denotes an approach to model complex 3D-shapes using simpler ones. I.e., two shapes can be combined by taking the union of them, by intersecting them, or by subtracting one shape of the other. The most basic shapes, which are not result of such a CSG operation, are called primitives. Primitives must be solid, i.e., they must have a clearly defined interior and exterior. By construction, a CSG shape is also solid then.

Image-based CSG rendering (also z-buffer CSG rendering) is a term for algorithms that render CSG shapes without an explicit calculation of the geometric boundary of a CSG shape. Such algorithms use frame-buffer settings of the graphics hardware, e.g., the depth and stencil buffer, to compose CSG shapes. OpenCSG implements a variety of those algorithms, namely the Goldfeather algorithm and the SCS algorithm, both of them in several variants.

CSG grid

Benefits

CSG is often used as fundamental modeling technique in CAD/CAM applications. Here, image-based CSG rendering is the key to interactively manipulate CSG shapes. Since OpenCSG renders even complex CSG shapes fast, it can be advantageously used in such applications.

Raytracers such as PovRay have used CSG for shape modeling since long ago. Interactive modeling toolkits for such raytracers normally just ignore CSG commands, though. OpenCSG represents a valuable addition for such applications.

Before OpenCSG, CSG rendering has been hardly used in interactive applications, since the necessary algorithms are complicated and error-prone. By providing a free library that is easy to use, fast, and portable, OpenCSG has helped making CSG rendering more mainstream than it was in the past.

CSG columns

Prerequisites

The OpenCSG library requires OpenGL and graphics hardware that runs OpenGL well. Note that OpenGL ES is currently not supported. The OpenGL implementation must provide frame buffer objects.

Frame buffer objects are a more recent extension for OpenGL. They are easy to develop for, and can be nowadays considered mature. They are also part of OpenGL 3.0. Beginning with OpenCSG 1.2.0, they are used by default.

In older versions, PBuffers were required to run OpenCSG. PBuffers are probably deprecated nowadays, and since OpenCSG version 1.6.0, they are no longer supported.

OpenCSG is written in C++ 98, uses namespaces and requires the STL. It compiles with all reasonable C++ compilers such as gcc, Clang, or Microsoft Visual Studio. Workspaces for Visual Studio 2022, Visual C++ 6. and Dev-C++ 5.11 are provided. Under Linux, any gcc compiler starting from version 3.0 will work.

OpenCSG has been sucessfully run on Intel and AMD CPUs. Generally, NVidia and AMD graphics hardware is well supported, and hardware where OpenCSG successfully has been run on includes everything that has been produced in the last 15 years.

On graphics hardware from Intel, OpenCSG did not work so well in the past. Recent OpenCSG versions contain fixes and workarounds for some bugs reported for Intel hardware. It seems that most issues have been fixed now. Still, generally, use the most recent graphics drivers, in particular for older HD 3000 or HD 4000 hardware. Also, the (non-default) Goldfeather rendering path generally appears to produce more robust rendering results compared to the SCS rendering path.

CSG convace shape

Usage

The interface of OpenCSG is very easy to use. There is only a single abstract class called OpenCSG::Primitive. A Primitive object has an attribute Operation that denotes whether the primitive is intersected or subtracted. To use OpenCSG, create a derived concrete primitive class by implementing the render() method.

To actually do the CSG rendering, there is the function OpenCSG::render() that takes a std::vector<Primitive*> as argument. The render function evaluates the CSG expression given by the array of primitives and initializes the z-buffer with the proper values for the CSG expression. The color buffer remains unchanged, so afterwards, you must shade the primitives in the array using a GL_EQUAL depth function.

Note that the render function does not evaluate a generic CSG tree that also would contain unions of CSG shapes. It has been shown that a generic CSG tree can be converted into an equivalent set of CSG expressions that the render function can handle. OpenCSG does not contain the functionality for this conversion since, after all, it is a rendering library.

Here is the complete interface of OpenCSG:

namespace OpenCSG {

  enum Operation { Intersection, Subtraction };

  class Primitive {
  public:
   Primitive(Operation, unsigned int convexity);
   virtual ~Primitive();

   void setOperation(Operation);
   Operation getOperation() const;

   void setConvexity(unsigned int);
   unsigned int getConvexity() const;

   void setBoundingBox(float minx, float miny, float minz,
     float maxx, float maxy, float maxz);
   void getBoundingBox(float& minx, float& miny, float& minz,
     float& maxx, float& maxy, float& maxz) const;

   virtual void render() = 0;
  };

  enum OptionType {
   AlgorithmSetting,
   DepthComplexitySetting,
   OffscreenSetting,
   DepthBoundsOptimization,
   CameraOutsideOptimization,
  };

  void setOption(OptionType option, int newSetting);
  int getOption(OptionType option);

  enum Algorithm { Automatic, Goldfeather, SCS };
  enum DepthComplexityAlgorithm { NoDepthComplexitySampling, OcclusionQuery, DepthComplexitySampling };
  enum OffscreenType { AutomaticOffscreenType, FrameBufferObject, FrameBufferObjectARB, FrameBufferObjectEXT };
  enum Optimization { OptimizationDefault, OptimizationForceOn, OptimizationOn, OptimizationOff };

  void render(const std::vector<Primitive*>& primitives);

  void setVertexShader(const std::string& vertexShader);

  void setContext(int context);
  int getContext();
  void freeResources();
}

The convexity of a primitive is the maximum number of front (or back) faces of the primitive at a single position. For example, the convexity of a sphere is one and the convexity of a torus is two. Actually the convexity attribute is currently only used in the standard Goldfeather algorithm. For this algorithm, a convexity too low may result in rendering errors, a convexity too high will reduce rendering performance. The other Goldfeather variants render primitives of any convexity correctly without analyzing the convexity attribute. The SCS algorithms, on the other hand, can only handle primitives that have a convexity of one, else they produce rendering errors. Hence, SCS algorithms do not check this attribute.

The bounding box of the primitive can be provided using normal device coordinates, i.e., after transforming the primitive with modelview and projection transformation. It is not necessary to set the bounding box, but it allows for various performance optimizations.

The abstract render method of the primitive is implemented in a derived class. Your implementation must not alter the modelview or projection matrix (use glPushMatrix / glPopMatrix if in doubt). Also you must not change the primary color in your implementation, since OpenCSG uses it internally (in all rendering algorithms). For best performance, you should only transmit vertex positions; no normals, texture coordinates, or whatever else.

The render function performs, as said above, z-shading of a CSG expression. The content of the stencil buffer is destroyed when handling concave primitives or when using the DepthComplexitySampling strategy.

Optionally, with setVertexShader the code of a GLSL vertex shader can be provided to OpenCSG, that is used by OpenCSG for transforming the geometry. By default, or when an empty vertex shader is set, OpenCSG uses the fixed function pipeline. When setting a non-empty vertex shader, that shader is used. There is no need, and no possibility, to set a corresponding fragment shader. OpenCSG internally sets a matching fragment shader itself.

The intent is that the shader can transform the vertices in exactly the same way as later, when the geometry is shaded by the caller using the GL_EQUAL depth function. This approach is needed to avoid z-artifacts when using GLSL.

Using the functions setOption() / getOption() you can control and ask for certain settings used when rendering a CSG expression. You can specify the Algorithm, the method of depth complexity usage and the type of offscreen buffer.

The Algorithm parameter specifies the method used for CSG rendering. Besides Goldfeather and SCS, you can also choose Automatic: This setting chooses the Goldfeather algorithm if the primitive array contains concave primitives, else it chooses SCS. The automatic setting also sets the DepthComplexityAlgorithm (NoDepthComplexitySampling for arrays with few primitives, else OcclusionQuery or at the last resort DepthComplexitySampling).

Aforesaid means that it is not possible to do CSG rendering of concave primitives and preserving the stencil buffer.

If the Automatic setting is not used, the DepthComplexityAlgorithm parameter specifies the strategy for profiting from depth complexity.

  • NoDepthComplexitySampling: Does not employ the depth complexity. This essentially makes the algorithm O(n), but with low constant costs.
  • DepthComplexitySampling: Calculates the depth complexity k using the stencil buffer. This makes the algorithm O(n*k), but with high constant costs. In case of the Goldfeather algorithm, the literature denotes this as layered Goldfeather algorithm.
  • OcclusionQuery: Uses occlusion queries to profit implicitly from depth complexity without calculating it. This is especially useful for the SCS algorithm where this strategy is applied at shape level, resulting in a O(n*k') algorithm (where k' <= k), without significant constant overhead. This strategy requires hardware occlusion queries, i.E., the OpenGL extensions GL_ARB_occlusion_query, eventually GL_ARB_occlusion_query2, or GL_NV_occlusion_query.

The offscreen type specifies what kind of offscreen buffer OpenCSG uses for internal CSG calculations. This setting is kind of obsolete with the removal of the PBuffer option, that was removed in version 1.6.0. The default AutomaticOffscreenType, and also the setting FrameBufferObject preferably use, if the required OpenGL extensions are available, FrameBufferObjectARB, then FrameBufferObjectEXT. The remaining settings FrameBufferObjectARB, and FrameBufferObjectEXT directly map to the usage of the corresponding OpenGL extension.

The depth bounds optimization improves the rendering performance by using the OpenGL extension GL_EXT_depth_bounds_test to restrict rendering to only the depth range indicated by the bounding box of a primitive. This optimization is, by default, turned off. If you enable it, ensure that the z-ranges of the bounding boxes are large enough, otherwise they will not be correctly rendered. The gains you will get from this optimization is probably only small.

The CameraOutsideOptimization setting enables rendering optimizations that are only valid if the camera is known to be outside of the CSG model. I.e., if the camera is inside of the CSG model and the setting is enabled, rendering errors occur that could be avoided otherwise. By default, this setting is enabled(!) for the SCS, but disabled for the Goldfeather algorithm. See the following remarks on the two algorithms for details:

For the Goldfeather algorithm, the setting controls the way that the parity value for a surface is calculated, which is the number of surfaces in front of the candidate surface in question. The textbook approach to determine it is to render all surfaces that are in front (z-pass). This has the drawback, though, that if the camera is inside of the CSG model, some surfaces could be clipped by the view frustum, resulting that rendering is incorrect. The alternative approach is to render surfaces behind (z-fail). With that, incorrect clipping of the surfaces is much less likely to happen and easy to avoid. So this is the more robust setting. Since 1.7.0, z-fail is implemented in OpenCSG and done by default. The performance of the two settings is usually similar. If your camera is outside of the CSG model, you may enable the optimization to check if it works better for you. The setting is also a chicken bit in case the new z-fail setting shows unexpected problems.

In the SCS algorithm, the setting controls the workings in the subtraction phase of the algorithm. When subtracting a primitive relative to the current z-buffer, the textbook approach is to mark the visible, front-facing polygons of the primitive in the stencil buffer. (At these places then the z-buffer is updated with the back-facing polygons behind the z-buffer). This approach however fails if the front faces of the subtracted primitive are clipped. The alternative, more compatible approach renders the primitive even one more time to avoid this problem. Due to the additional rendering pass, this approach is a bit slower. Since 1.7.0, OpenCSG implements this more robust approach. But it does not use it by default, mainly because not all kinds of rendering errors, related to the camera being inside the CSG model, are addressed by it.

OpenCSG creates, and reuses between different render() calls, various OpenGL resources such as frame buffer objects. This may be a problem in MDI applications with several OpenGL windows, of which the OpenGL contexts are not shared. In this case, OpenGL resources allocated in one OpenGL context cannot be reused with another context, so OpenCSG would produce rendering errors. To solve this, the OpenCSG context can be set to some unique integer identifier of the OpenGL window. OpenCSG then creates/uses OpenGL resources in the render() function per context. The function freeResources() frees OpenGL resources for the currently active OpenCSG context.

CSG grid

Download

Download OpenCSG-1.8.2.tar.gz. The archive has no dependencies that must be provided externally. The only library that OpenCSG depends on, and which it comes with, is Glad. Glad is used to load OpenGL function pointers and for OpenGL extension checking. Note that other helper libraries, i.e., RenderTexture and GLEW, are no longer part of OpenCSG since version 1.6.0. OpenCSG comes with CMake files for Linux and with project files for Visual Studio 2022, Visual C++ 6, and Dev-C++ 5. It is released under the GPL version 2 or newer.

Older versions are still available for download:
   OpenCSG-1.8.1
   OpenCSG-1.8.0
   OpenCSG-1.7.0
   OpenCSG-1.6.0
   OpenCSG-1.5.1
   OpenCSG-1.5.0
OpenCSG version 1.4.2 and before were GPL version 2 only.
   OpenCSG-1.4.2
   OpenCSG-1.4.1
   OpenCSG-1.4.0
   OpenCSG-1.3.3
   OpenCSG-1.3.2
   OpenCSG-1.3.1
   OpenCSG-1.3.0
   OpenCSG-1.2.0
   OpenCSG-1.1.1
   OpenCSG-1.1.0
   OpenCSG-1.0.2
   OpenCSG-1.0.1
   OpenCSG-1.0.0
   OpenCSG-0.9.2
   OpenCSG-0.9.1
   OpenCSG-0.9

Development snapshots may be pulled from github.

CSG columns

References

Currently, I know of the following applications making use of OpenCSG:

Icon for OpenSCAD OpenSCAD is a software for creating solid 3D CAD objects by means of a scripting language. It supports interactive preview of the CSG geometry as well as exporting the final geometry as 3D model. There are precompiled binaries for Linux, Windows, and MacOS X.
Ayam-Icon Ayam is a 3D modelling environment for the RenderMan interface, running on Unix, Win32, and Mac OS X. Since version 1.8, Ayam provides the plugin aycsg for real-time CSG preview of complex CSG hierarchies using OpenCSG as rendering library.
Image-based View Frustum Application Screenshot Image-based Visual Frustum Intersection. A scientific project to reconstruct and visualize the 3D shape of an object, based on some projections of the object gathered by camera's around. The algorithm is capable of dealing with refractive distortions when the object is inside a water bowl.
Icon for KoraX CSG-Editor koraX's CSG Editor (web archive link). This editor for MS Windows allows to compose textured CSG shapes from a set of predefined primitives. The application contains a very good online help that depicts nicely what CSG is about, and that furthermore contains some tutorial how to create 1) a graphical widget and 2) a pipe.
CSG concave shape

Background

I have developed the algorithms for OpenCSG in my time as research assistent at HPI at the University Potsdam. In this time the following publications about OpenCSG and about image-based CSG rendering have been written:

WSCG04-Icon

F. Kirsch, J. Döllner: Rendering Techniques for Hardware-Accelerated Image-Based CSG. Journal of WSCG, 12(2):221-228, 2004.

This paper gives an introduction to image-based CSG rendering and describes the two techniques that are used in OpenCSG to accelerate rendering compared to older implementations: Visibility transfer using textures and occlusion queries for the SCS algorithm.

OpenCSG-Icon

F. Kirsch, J. Döllner: OpenCSG: A Library for Image-Based CSG Rendering. Proceedings of the FREENIX / Open Source Track, 2005 USENIX Annual Technical Conference, 129-140, 2005.

This paper describes OpenCSG itself. It concentrates on the API, explaining internal implementation details only as shortly as possible. It also outlines possible non-obvious uses of OpenCSG.

Dissertation-Icon

F. Kirsch: Entwurf und Implementierung eines computergraphischen Systems zur Integration komplexer, echtzeitfhiger 3D-Renderingverfahren. Published online, URN: urn:nbn:de:kobv:517-opus-6079, 2005.

My doctoral dissertation (in german) describes an approach for integration and combination of several rendering techniques using a scene graph system. As such, it contains a long chapter covering CSG rendering.

CSG columns

FAQ

  1. Can I render a shape with different colors? The documentation says I must not change the primary color in the function of my class for primitives, since OpenCSG uses the color for internal purposes.

    You can shade your shapes with whatever color you want. While your primitive objects for use in OpenCSG must not use the primary color, after calculating z-values with OpenCSG you are free to render the same geometry with primary colors.

  2. Does OpenCSG require a stencil buffer?

    You must setup a stencil buffer in your application when rendering concave primitives or when using DepthComplexitySampling. Internally, the stencil buffer is always needed in OpenCSG when rendering into the offscreen frame buffer object.

  3. Can OpenCSG calculate the geometry of a CSG expression?

    No, unfortunately this is not possible using image-based CSG algorithms (at least not in a trivial way). If you require this, have a look at other libraries such as the GTS library.

  4. My camera is inside of the CSG model, and rendering is not correct. What can I do?

    Since version 1.7.0, if the camera is inside of subtracted primitives, the Goldfeather algorithm in OpenCSG should handle these cases correctly. You must ensure that the back sides of the subtracted primitives are not clipped by the view frustum. For more information, read the documentation on the CameraOutsideOptimization setting.

  5. What are the dependencies of the example program?

    The OpenCSG example requires GLUT or FreeGLUT. One of these libraries is likely pre-installed with your favorite linux installation. Visual Studio users should compile or download FreeGLUT, or with older versions of Visual Studio they may install GLUT for Windows. Dev-C++ users can install the precompiled GLUT for Mingw32.

  6. Is there any relationship between this OpenCSG and the AI company OpenCSG?

    No. The CSG rendering library OpenCSG is an independent project and has no affiliation with the Beijing-based AI company of the same name.

CSG columns

License

OpenCSG is copyrighted by Florian Kirsch and by the Hasso-Plattner-Institute at the University of Potsdam (HPI), Germany.

Since version 1.5.0, you can license OpenCSG by terms of the GNU GPL, version 2 or later. This means that you may release applications or libraries that use (parts of) OpenCSG (a) only if you release the complete source code of your application or library and (b) only if you release it under the GPL license. Versions before 1.5.0 could be licensed under the GPL version 2 only.

Note that OpenCSG comes with code that is not under copyright of the HPI or Florian Kirsch. This is the code generated from Glad. This code is licensed under the terms described in the generated source files, and at the Glad github repository.

CSG columns

© 2002-2026, Florian Kirsch, e-mail: mail at opencsg dot org,
2002-2005 Hasso-Plattner-Institute Potsdam.
Last change: 08-Feb-2026

OpenCSG-1.8.2/doc/license/0000775000175000017500000000000015141675417015032 5ustar florianflorianOpenCSG-1.8.2/doc/license/gpl-3.0.txt0000664000175000017500000010451515141675417016661 0ustar florianflorian GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read . OpenCSG-1.8.2/doc/license/gpl-2.0.txt0000664000175000017500000004325415141675417016662 0ustar florianflorian GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. OpenCSG-1.8.2/doc/publications.html0000664000175000017500000001350315141675417016774 0ustar florianflorian Publications related to OpenCSG
OpenCSG logo

Publications related to OpenCSG

Back to main page    		OpenGL logo

Florian Kirsch and Jürgen Döllner:
Rendering Techniques for Hardware-Accelerated Image-Based CSG

Journal of WSCG, 12(2):221-228, 2004.

Abstract: Image-based CSG rendering algorithms for standard graphics hardware rely on multipass rendering that includes reading and writing large amounts of pixel data from and to the frame buffer. Since the performance of this data path has hardly improved over the last years, we describe new implementation techniques that efficiently use modern graphics hardware.

1) The render-to-texture ability is used to temporarily store shape visibility, avoiding the expensive copy of z-buffer content to external memory. Shape visibility is encoded discretely instead of using depth values. Hence, the technique is also not susceptible to artifacts in contrast to previously described methods.

2) We present an image-based technique for calculating the depth complexity of a CSG shape that avoids reading and analyzing pixel data from the frame buffer.

Both techniques optimize various CSG rendering algorithms, namely the Goldfeather and the layered Goldfeather algorithm, and the Sequenced-Convex-Subtraction (SCS) algorithm. This way, these image-based CSG algorithms now operate accelerated by graphics hardware and, therefore, represent a significant improvement towards real-time image-based CSG rendering for complex models.

Download:

 WSCG04-Image

Florian Kirsch and Jürgen Döllner:
OpenCSG: A Library for Image-Based CSG Rendering

Proceedings of the FREENIX / Open Source Track, 2005 USENIX Annual Technical Conference, 129-140, 2005.

Abstract: We present the design and implementation of a real-time 3D graphics library for Constructive Solid Geometry (CSG). This major approach of 3D modeling has not been supported by real-time computer graphics until recently.

We describe two essential image-based CSG rendering algorithms and an API that provides a compact access to their complex functionality and implementation. As an important feature, the CSG library seamlessly integrates application-defined 3D shapes as primitives of CSG operations to ensure high adaptability and openness. We also outline optimization techniques to improve the performance in the case of complex CSG models. A number of use cases demonstrate potential applications of the library.

Download:

 Bumpmapped, shadowed CSG widget

Florian Kirsch:
Entwurf und Implementierung eines computergraphischen Systems zur Integration komplexer, echtzeitfhiger 3D-Renderingverfahren

Published online, URN: urn:nbn:de:kobv:517-opus-6079, 2005.

In my doctoral dissertation, I discuss how to integrate a variety of different rendering algorithms, such as shadow mapping, reflection algorithms, bump mapping, CSG rendering, etc., into a scene graph system. The goal is to be able to use and combine several of those algorithms at the same time. To simplify this task for the programmer using the scene graph, the rendering effects are specified in the scene graph in a declarative way, without notion of settings of the graphics hardware or of the required rendering algorithms. Those are, consequently, derived internally by the library for evaluating the scene graph.

In practice, this means that using this system I have combined all algorithms provided by OpenCSG with different flavors of shadow mapping, stenciled and textured reflections, environment mapping and bump mapping.

Download

 OpenCSG Logo

© 2006-2026, Florian Kirsch, e-mail: mail at opencsg dot org,
Last change: 03-Jan-2026

OpenCSG-1.8.2/doc/img/0000775000175000017500000000000015141675417014164 5ustar florianflorianOpenCSG-1.8.2/doc/img/koraxcsg.jpg0000664000175000017500000000624015141675417016511 0ustar florianflorianJFIFddDucky!Adobed    #%'%#//33//@@@@@@@@@@@@@@@&&0##0+.'''.+550055@@?@@@@@@@@@@@@q" 012!3@#C !1AQ"2aq4 0BRr#Cb3s$!1 20Q3@Aq"B םSw鹡](Fpцpцq*KcXo0:x Wuȩ͒ v;Ԡ5c7.~ss82?V"\&~V&-kӬԡw 59Wc> ʙvNw-iXתV1l[琽@"=r$?GxdG7Ml꩸h7R: )VoFL,W :((((sPp)Jt ]~]uUW2U 9$}P WH /W#ܰd4&լV} :ڐ؁z"xz o>⣏=45C]45],5CZGXKAAjN QqZ&>jifd:UIb*ЃBy m\G&i4WCRi5v& 5V Z5hjաCRH5"࿩8?O+?a^% %NKsm9.rLrS5_57'`IĬs}t ?ӉZȭ8VJӉZq)8%MGϦ-SZ(tJ0a#UJR~)b#P,&bGcS+dU-σ ?b` g)^$K f[ӧD70}#d 2XRug^׾}zO^_>{'ׯ}D^׾}z`9mD*p}v:#<*mdp"j4L78-Aee;{4kQ ê";G u1tl5]tLPAlwS$]Pz2ۤ4gB 5U%DΛI+o-fz3]3kZv d)#T3X1p!'g -vXtPe `ʆ nD`( "wx~}o' wYQp7IHo7**A%X@j9 cOI%1Ë@rHW岻5Ofi|6| УE_BX;$lt |J$xz5ݳp-l4W]lj닒߅1r phW4R& qQ܍b|T .VF~M`KM8m)r{x~՞6 t)t8od:M%K11Nfab#n4V"6 ՅiUF=Tp O0(EcUZwAbr_A \ib\t f\ylN,V^FK*MEd#&pt8P{zKH݁ʿX%45$H/\ƒJ|L90Q㧷uTq^{DjPxNSL㺀vSĠR/- pHYs   IDATxyy'ꮾ\ EP$EHm:v֮#L;1ᘑ',ۂW6]yVXXHY-2AJD @@ $><]Y/2 Y]]~c H k _رc}+Kvڵk0ƒ$T(>>Ŧ |g ܂5{T*$&!z~7CE\a5?!@{DQf,ξ^p i,z,?$D |? 췿 `;9%"1v1@ECo9#˲(z({?wRl;h,dE ,̟ Qfw…, _ő'岢(DS)>^`a!!qūW-o?,d $ _믯 R)صډYX<3_Öw$I2{+dYj4ܤ^|///w|꥗E7ӽ\4 Be9zg,fHT=;3~׿~i=bÂ@[Yg?{tO#OQ vo@f9{UCaRPˊFEfȊ1rOŋO8!bREQE!'p"$ Jb+=WH - "p֭8~g\zlDC̾IY}_{ohp 1{{T".k^E ̂ K̯w'-ܹs'Dzð y'ͬ,dY6dYh39q}QQ4M\\tI$YXTÙ#Ŋr,KS+ ?u|SO=e:I'wo"{04 O:d[fh $ lqB(&xg"#rـ~Xvfb1GT\V\tSȲb|`AE222LRY,_{K6lF x9u_}[:0#$I/!XЁ`*0Pc~"&5C4M3 %4G?-w?,VD/-7\l窓 uTZ-$EUo@1C,>:_nYӏ[$I¾vp!$<0ߠQ3ܹ@ bpʗz"IFW<lN^˿KPk7րXx5fȽk5Hf7ҭdxA@4-IaԚBqa4Mќj+O8t?rʕ+W0?1Z4W9Y6M"__vд,˓$wf\,jObH,FD eX4l/J^T2~dE.L4Jt'z,޹13s஻/;v7(bQL$OsO-YrMP7w$IbQ$MQFGGzkzxfDQG6Rts8 ?G4K}{ΏЉ02F#ճ# EgɎ; 0KisF , bD"p8NKKRg;HF"[G",'hZJ.` Y8.u3nH]o)SSyYpwhȀ EQHǡWnԘɲ&˪$![ $YtܹSfӆX.#R9ZrXb b9RFwY^ZXrTH$TN˘;Q  EwMCrEԶ-sL&z*n 7ܿ'14ªjhnv[pw34 T |c88W \Q0zs$ǛvKcX1 ^|@gfYB v.+WP E&UYSдgHmV[{%$IRK%UV3*v[:: eЙ2ϏVmpҒP"w-;Os!rf +p3D =IGՄkKSZzzzv}SQ#T-j8P( (ꆏPp})0Cfi222b$5o3(*73VQHGn]V'Sc>4y&yc*Eɞ={6&4 hMpH G)L̩] vI`D u0]g.-fщanQyYԗm0e:0+w'ȓEY̢dbbh??荶fH,Z~[%IS,tԥ7 4'ANAɓt7#݅ (UUfHȡCf0]zIY@uAYSвLɲY~W?cc ` Bif\L4_Ɖ3g|^m۶@Hy;6ȋ%1v*JbQB>_dO:5˨sJT?яL|H<կ R,-+ ûE4St֕3~JviHcaX6ӃhR4f/W._6W<_~/B\bNCW!J;' sL(Mh"Q$`|^65_D?텹7%3LjcEޖR,bM}OOY={_B]XW~ ͪx Z?X2Chvv֊dV'":b6{K$cn]BaP0ZB.0f׬Fjh~qGyw~ Ipkg{?>14{X2( ]mx,[hE4r71? rԒcKo&eEsܫ>S[(Xy/m'E}l6k݇{{),|P HCUc8qCgr3LiX8Ro~eixĉg|;;cO>ꫯZ/JqW4@f ݕIE"[ｗ#aDgaR6+6G|r__[ܜV.cY>9;֑#PL$z #-yAN"iJR,_>q?ٟpγ>|!D40,Xl(%>D:m?p8<<<, dE *,k|LF1hSH>fHKKrlBG@fAfSi~q8th?P8 !PÝHj(r\0LX/+JOO/ #dCbi===P,#P8l(٢ O:g_boXX5"pW9?BM}U Ju{;* ( Xě5+7)p2[^睧_~_ T.Uן9];,3q{ Ӄz]ՓAl6K$(ApzFU 6J.;/K; Fe6^" ETҊEZ?\x1ISSbmR @6(:3SׂBT$fR\W5!q\hd|\Ay><6Ɛlӑ >pD e/0Uϓ3wdJɌJ"4=B3Xu!3k6CZ%0CfQk\@Lrs XD:8}}t(ǿio(X,e%b#D ܍T(@ؖsab1&fg!:FTAޟ@$&S*tfXD*BH;vBu󐢸!__>@XI܌ B*(^^\;e v(jK޳r+,@  $.22`1;XfjEY2%wL æ,7#$Ύ ‚I,n~#[GG-H$ѮM2DaaK FZX=i>(0xNNrX<T++/EB]*pOgב޳T1lfrF1!9o"@ s~pldEeϤ\,.-.&!1UZa@[6_g\Y) ~_ZŊo1Ko87ťgWn_Jb%+|zg/_KA*f4^us"r4'}; h9P( k#z{}~Wϟ?ܹ σ:ٱڱЏ;T[-}gA aÖ$%S][ZVY\.,SiKI$)?Nn"fwuױcVɄ}H`ʂ!RuybH@"G^SB%oƥRb mdhP*] &Yȇ?as@x=օӀ YRVzs:s\/%ivPmBX(7mŶD[PoouC ɲ,Im}С@'7Xؘ%b-tZiF ScI.|\a jr(s1azo4F8&'\`q-W3Bc"LɅ`!VλzME ÍfYJXS[co&Ym!woqX``QPU6R! I)X3y&v{1+iksg}DQUU/:,T0 Urĉ'NLVf`;v찴f2^]Ս4ǼU"?[Get1PW/tq<8giAFSU~Ӷ=iqcU4b1#-)J!//%_@W78X߿޲ošlq9eI "?nJMq #hcygp,x'nʼn(ceņO5`H wp0es9@^#P봊b^^ bH؍P4 O"rޡh2 >r1xJQ7>XtZؓGˀqѝ֑B&iEV/-`5|ɀ\ldۜr/-&tPѤ  ,|x|hhB&s2PdYh44P%шbeMb8DF.pd##~ F4 7<]ai:d:E1Κt۰D|^5+"Q"?} 1 PX?u^KKZ4_BrN culqb [BYv!Y@8fxv[|~DbjjJ2 4\Aر1񩱱J>ggYe{}ns (.-Y[c+Jz?VEVб";<\D"N-[hF[792"BbxB+^9y2PM,:ķə. +,~x>iDfzeIm^dBa|foW+6(ppn|TpK~4dh:i'EUUiQ4 lye'&rrKiAmibK`4̓a:]F7s~3I<Փ"V*VUUunnniii% Eolhz[z@YLLL,--"R k׮}+_1O_S| f9(2( ~ӑ3$A-Ӝɕ4-CQTj_zdbzZ=CEQ:A`qEK `Y ],m9Bh'X p 2J%;R-?r4ytzph(AF47'R>w)IdY6+U2C~E K!u+M}DmІw~yVz8J(RRC'HTB@h٫:P]//-dC44eVh"QTB^ 26>T*U2jSyJU&&δ6X<{Ç-$i鱨ׯ\.ק[5AM}嶦RDUIPTCCQ3H\xA˶s@QW-GmG\j촢Ġ{z* $_ H0$l,l0\̧ qӸ6"jI#09Xb$,% 1,+à7&5656F\ H0 nUhMofq9w--/ʨF` -a`Ge''r!qyEZbhbi ōe6bT }},I{.`p*C2 TJ,0-܊p0ǭQgDQm5nэ `*3,y|rnȐW"qetqYH$ X !c5fcHǒ#ZE Q󭾙,[>_ResW|*i5E:֣wTCcl~; ?r2 Bv\j47GlgbMSEQxecD,p-z__Y{i#FYX~뷞xEoGb,OweYbΔ)d+TvkRC(f5_ڠx|jS T Ue01mj?'`1 /|Ane ,v4j ի {RR(iE6ϲp!Ę>3:8hpE ɝo`Q/>O8 EHM381PK9>d=уDIc8Ңŧd'"ds8"}}Lt3Đfg*Ӌf Rזj 7hyz5{XIR͜-F#D$/tk&sm$Ϛ1&9+f 8pO?MM bWdDz77qyϗ 3 wmx)Ƀef!|p7'[՟^l bЖ-f/<c5!I;D^⣣w]60Nl ~oD"wyiRht|?tL̀ ;ƇbL/ƈ՟e*ٖhQ IbdY*"cI6]}`bl'SY\޽JeR!\748퐔2wXt/bw(WsOYR~f-L˄A&%U+ɟ͍4i+>9UJEӴ,O>MpGu-H1!y_!UM0҂Cq >TWw&j[LQ-EPC!Z O9Df*M5q6_Ta/>BlkɔC`jC4 hUmQoo-Iq!b=nԙe@LJnYIrf= 6YZ]hwi3.g2F[ݻRoR-KT%KOH0ǕZN" *N~O;Gpp"T,~k>@,:Y[i$b:qSD(4
  • Xhdx}3<.& YTEҤe}eR&M .u5Ӵ^CF[{Fbq䗾%㰿 >>֕kcNLeYhĉzv([*I$, [zpG&uBYs|ojJFqpW]{O"ɨ;2V ;"MB_3^oz|"t]?\`bmqij6m5W׀[:"ttȑ#iԔ̊)JsZ[iBjej  HX I,R  $YT q܅Ԗ\HV콚pѸ#w{=Ev?ܢ]NFwC'NH6f/Z :l*0EEAFRے%Z~KQjAgn4EI-@'ϲЊMg@7OЯz{3ES-\@o/P&p]>dz`qai3^f:"1:('4²r4inP]>gxo.P`%ZlG4q w#XXX z7_$\P[:m߷h,oS'qsL XA`XV]\\ѥUc&X ,_mJU1i~R)KӊOH+|{N V dZZZX @  0.5,^z%{$_˽0M$WUF.IKvP>f+޲'qB NoL/H#?w,櫦L,$Ux[:M(e({ Фs$}Cx,S5M$PZsue I4pK]]6e`K/F#LfGOO!1CcPZdٴ/1f9*Ƙ1bY,š@vBlcEU=??(00)4uOI¬BCzMyQ/k~ayC? 16g 7%gѻfY (@ү QU=+X*hz<~ '*,Z0VD${yN?9W@Ct[HՊIr+Fv(`Q_~n6&xޮ4@:Xp4=z牜+ X5RRVCQ(+ܺukt'+&lڢwkJ0OqyqfQQ|s+ pDŽWaQQHblq(IjSr{8SСC*9o[4.sŢU$D<40փ{Dm)0W,Um`1|;zQu6\q$6'\(y1^Fƭ-" ǎmL?y$4MPlBgݢ7O^nɅ(N䢭:?3SC(x(>t~Cm͝, /:R)FEq0>:) Jܴ-Q8L ›(n=(qS֍C֟J!-2l,/g޺Q>x`&(Neq%33Rv-"$E|cC^\4/B$ nk `1^ 6V kѣ+] #/rK٬H??d2eQ=ev%BdQ%?BuHD.e2ޜCEQy|&RuZS&3 o{p=jjlr)[fWkG;Y= 01qODž;9s楗^f< <$a rgE !_ƽ0K1R~=Haa8,vC`mZ~s?}W!`2A& X@zӌVg|;`177777O^pA^X QYVe<N(q/u_4,޸a~c׻ Dkȉ#͐'j/IZ]Ȉ6 9bnq[Br'{@)*Ei0[,U_<ϛbYv`oqrE,ZLx~+" #3˾*^=uޢ†*"tLrDɗ>O㤃ﺏ3Fiz:cWX|%|axQxd},KbMJo)F?AYӘ1_.#J, ,U-]E-ڧggURkRh\םxɸh V@'-q1[,Ӗ[ΒbjDUضvjJe[inŋǏsUJ7v Q#`4R6Jډvt| ;;)J&E֩uh+9W5CfՈ>Xl!"b~VplM]ӌo%O9uz!n,[X}Qʙʡd#-zlàڃ7PV9j :)SGbYOcl,4'EyDz_BN`Fazj|6XwrQC|u[81 wZA7*4EŕsvC8nqw{Mt0t`a$#+y. <kؾ`b ,gxnqqnq110`fyuSV,~ֲ<  +_n)qo^0}:yeX4hľkS99jX+|kIvQ7'eRitO=>)MU*-|xFziE]3i8j> 1pd^ABmCv r|ɲ~qBEՙˈlcX;@tjдqb<b\ ѹ!Z`Ϧx*A)MtSYX쇕ꇍEy-ObVÛ|': ,ɗ/PYO٫)XN~;O F̓E զiPg(Q5nڈ;s]w ! ynYM$' Ml W>`\˓(-+3mӴΧ@M`QEn3 0LSf*6ȨQTF *Gߛ+BF;!/w0 㞴m >EE!$ ;z}s;1) L`QCC5f Xij]A AoB2rWz@v#X0:DZ,<4-i7rv]y+XihK}E1ka.Bf Xu7S41۶m~:D(*\{ UU0>M ³,,mYyж8H̗Jh9˚ IDAT0fNZZrl`ID ṔX3Uj 90Oڵk޾>QUK6 ](ĸO`!.,M/sIԚv.GQ=$E/Zļ9b[(6 :LcKKwb6nD4olݺu֭G9r^3X<&/jDp8RG|+jQDА[_QH Đ<7r9Ʌ&IBnXthPjqn4VpG8}>pQnH`nx2}WLL uJbu5~#ZA wGzHo<|J6kG Idv='!Eץ ħFn6 'ଃ:By5QMuř+b҆qn8` q,xlrWyN4vA,k[Ż͆TpmAkFD/Eu9-N+E5I^L<&j%bZw'D*2{C!Mb[Qm}zs,`-XwlEӭ}Y/uEsl> 0>E*H ]E)l0sqD}EQOAf!v%lVݢk15|@bK"!*NyyXto7/ݼI((bYFT"Ց1n~F*l5bCXtu7dI^,EQS+UIf*\7HM:psr Ȗd+˲JʪfC{ndr^y[,+Uղ j^Hi(R+ i[zD `%\^^&֛2uñddZ}{1z288s`4:xQ jfzv֫V,߼IX^,xK*e2ݥ[*cFGkQ9MBn(D^괝+ZGYطo߱cLjbkOO+5hnD}/i.+CϜhP<>rRU\G|i_\QJ~qW=&J|RZ6,ǎVL}cn `,6w" m%;5%JSJ&=‚Ŷ_Z'N]vơBAcd۱ch(EiBbעN/Gthl߾}Ǐ lX(_N|[|1@J%V|$#h 7 )zw̡pXg z{h kZ)kThɌuE(l߄׫HwA. %I? UgΜ4M&2j48An1+$A$Rg-m!" ޻~b{`H؁Ӵ=A-zZCm,{a-žlrI3׽7Ǫ%FnG F0ς`r,fW.j 8?OثYs%hq41nc<a, r>S)*ei`.MY$Yv8*4Ԕ9!uMiRhr ?EK[j~wޟg@JiEX1orK)r! %tTPݸ 6f6fɻظ6ƞ8w,vQޱkeo {684!D) ZI54gY^uջΞ=kt(k1JDžc2W} qc630hj,gbx<ަYm`OChhG 4Xb1'[B |͸6!f-2?SG n u:#oH/'i Oh iYX1:u`zZ'DѬ Ƙ(d<; iqilsFBQN[r]w s#]b~!jzte%C h%*IEPM3ƾ}]dnbEk GQv+4 !m]W߮Ph d2̭PHKR]Eh4Ҹ9S*:`K߄B\J&:2W*Z1bk̲,,6΍ `KJ*t f"D 0L ÁŢq?4iB .bqo,e9iEtL12@gS!^3jldt!J8#&ޜ$\N0t3O Dm`AueYYQdM_W^%²l . y W%3Le+TE Rm4aEQޝl!Ծ1*YV1_6qjݬN4MwƋU_ݻws_Z\pa0XmȇWLB( !Px{لžH>"1r{|8 ܌sdIjW[.CCՊJ7J_*N&䖗sɤ@QT56BnXbMى\hXgf ˊBͻQ%U59շ &1G jq|KqͲVR/,,q{ 0j".0t[2nxeY+=AW.6Eⲡ۰fChIВ,60>XE!ral+90saE9Lv#3 VFJ|?-MN$a&lCv$L>6 ]a4ޙLӦ(?R,^T)\,=/t$Xн_tLI&s4"Na8&oBJ&}4bybM"M:>D\lM`@$rë o),I];m/  Ӂ`{_>f)٠k,qEt c$? AGrA4nrd-_HfH2\-KMF"f.C5*NʰXV1.-!%E_(Wc"`je CQ iC!\nUZky#[::xLj1 62_,LֵuT;C-ʡ-ͲNhS-i6HEؗ,a yQ&X< W\ ũJk.iCL;5QQڅtdFvE;E)g7yoʴhDXw]⍦XnCn{E+pl /GHM%r54 ~2M9oV>w;o?|sm É B]ʲy޾nQ y9>1|ʹVWE~n˧N>?D+ Loo wK&)RMB2LPꗛ]-Sn!x9Tma}̂l˸rzbzw!jr+jZ Y4]e:vTERUX?갸,;+BZa)Z2MkbԜWҵkUq}svvMNOO3U4atiaRi,CeyRށ<3G̵B̢F}7~óիk_,OČL2}}]:wn00v#tҽnքQi멧zgHqm?^n;nXB{:,t)Xhu Pi@XnCr__TdԠ6Đ~.X0ao8y,UjgUb@oi`=ƂtOO@ԴL2j7#mJZo:zc0ara0ǩƸfX؞ dfiG85`| );TI|3oy7O<3wXU2ǩ]lYlZ{| El5̔nkIZjF *6XLJ2e}lk&aqbnY+m y.tgiNj D]xQXHֆ PD^#0Md %EA~fM Mk+I7|d(uU ,4S!>g1N8FZbB1-7v[R] \c9 yfQv"gIB2T=jl+ iVJ8.šj9-C}9.;#a ,t+.%)$5H]9%>c閝WurγC75鶵]CW%3"n'nYS8JhtFjY1Nx+xF>{XH!DV:Sf(汀'kMDצNAXJnѝU/}D; նzes"dKɰ\K}28+|F9DɁbJO$ٖL6-W`p^|]U=)- Hk>a@̆Bq5œGڜ]` %BXS[TQE`cpo:=h̐5AF)SUU-SϐM}<0_@XUe{%+$4((JsV>vʡ+B{X,d4,8e0"3ŬHҖaB۳aY%"LlG$#D1xEu&"tu3Qht̀`4?z [_ũLf6W^%O n"/.ɝE\A!=8dgj{ DlYܻ| iz*GB! cZyZC={|np:=\k߽{ŋ>c1.Q.e?]ݤ.~ Rwu_s9 rԁdSr[|Ȫ~rKN" 7nt25EH|[эbIud[jv9x`ih9WeP<>Lx7QkRϘF /J7Y^#;T/`"azhM338,:}>p@aj;6 Y:Ag(_.SfO]s{c+C]kJ'ƫ!6Iw(YS{|qN9Y}H 6g-C4akQ''1 [57F\8btڰә >!dUlV=laZtM.EY'A;B BCݙe.=8dey^hLUں<˵zeLki]x)JKEKojjhr7U9 o o_,WkGh=1YD(Gr[Ռnq͎Ҳ_]|B-֑6òw_ 󌏏wq#VLفjv'DqTBwo)kݮiÛQUTřKeU<śb,f [d, nĽޙ(ZuLXFeƢQ@hYSF6;hK&~K%)e2dVZ)ԘҴ`uި2}4-q!x}$2:SE@ȵ~ޓomӋ G |EJv~@>VZH~Š}̌RY5M!aO,3hOQV[ng !^{8`bB>?H+*n8;l̯6l)}JNqNGUgyBD瞜ɓjh\h33_VwC`Ϟ=|:JNbڵ]q\gV+uN4#\ Zsֲ3ZZdѭi<@YUm9P"!yBww _T-d[&B"Wh|DAbp8[\TW Ǖ1֫ޡ IDAT`l \tXӨ`0o|QbqPh0]@8d#TxaxWj'N_sG^^M#c TP$m <-r8Iԧq/@4m^C u/Eٸ=ElNԒW{<[ M˺+٬A7/8_AuwT&Bl[p*킚D Ա n5l [#3f&wfg[aY%\{m2T90XLl>:5@¤tSFnBA Ԇ3ΙkKbV  '{x|qDQ TT3͞Ȏ;eIoӝmkKK"^$ h#_넇#t1Nh9bMC4DxB>}-VE"ѫ_ >۵ihTu- (q5uW/]B?hl-֜!V+ZT2IU@G۩C:^;z7(={Z\Sq:dC3h>Ykiy~ej\4mqKbg3dQ{͖:Exl^euN-/i.lPU[TXNHu1 dƍ_k=ˠ~OIjtCS4GE>"dK\a[j?E-u,Pbφ@Xkz<6\wޙ3'NNkJ3ߞAK/]÷~4*ijI^UU Y04{է\NLfĦ,2ƶ-71,$v[F얅z9Eq=dD5w݈PBЦkgB.8Sz) "[ iY>}^KB!\}/|[VDڸ̄s9u$d'TeYIŃhڱ}jHsٳdNL400?` 3Vᜩ ǩEvcDRQFGȢȑ//痖V] r+>TBT*J%Ix7Iwy端jrZnh\lN#[BUnjT!4BmO1(DZz9qKSY.JL6Ma ]db_?$ܸqcvv6H2 n۷5#TU[a!diiiffC 0,pujJT̆ I]ffb18@F.57z{{8&"3GsE.!sssl>l1. jϏr(bɜ{ｊiT@ @PzHa~==^)gt!s7`+,`i!xj/!PX_}TB _=5ᅛ7-Pʮ @J*muH$O+MeڇL*I`*LfȖ'FIr89Sg~vAlzzYTJ%fVluЍ>xngR0@m!/!vPŲNolYw16?Y@"8w&͔J!\UK8@ȂɢRmd?#G8~LFkxmX,f@kуƖSQieYR)Rtx6Ek;F-7]GW7/9Q 0Pu'N@&#O/ΓN:`"U(D<KZSJbAHǫr]10kYl'Y+XbWgnoS'!քv.*,<B 90Bm FI b6e9,0 F=~c1/,nj,n,(F WgiQ\^zTW}@7۪Ȣξ:9[td*-B |ޮ.3I#ƻg$xwwvɅnA7`pQ-Cj'8 rr_#H+Ȃ8,IRa1 Fkŋ{ֲ\N)Jl ) zj"Su0V0,-YZ#5nkj7Bȥn=uY-={Ws33H<1#yMr /7 d40 ap"#u̙3ϟ |4CU2Ǽ! P:06+ \Hl:Lf#{AHĭG#5W;,Wd)5M_19->ۧNwh,?J?<ܜGTUV^SEvDB~AX4` F'+(/-٭w YڈRj0؈YoB5f!`vHAzFv@U3g.heј,DWedz%+<#Ŀڟ.]tj+`P͘ijRe`BH!IoqAB2mdv\c/?qX(4Ld`dq }Jyg]1,&@R,jΊ>4qj[inH޸FN DIMZU/!WmJmqH(-d6ۖH_Vuƅ/f0dE#>r+==q9xtbnHӜ;w5axqGfM_@yb˲Y.JBǵtVYz\2"H?,-ٙBG__إK=]]Ey0νoZHR >)B,EbGDi9H a؊d1H|G/]??}z/x^fۗg>CǧxJMm:ߩK/!$@@OC/\r׾}g,Wjeq4͞ bVpbDգpzu:ʲi\ Qרmzn>e6+6s83+Yt91,vՅ}RdP)0bqPE㙆+):hc"\s'y-07q}Qmn 1$ КZzkTµi.ٲ?Ϧ wpWG= !uKiA T8nD1^VRDz8g' ޥS{q~ wHS!^:yGLHa)7'#fi&#? ZW0,TƸ~J&T|sf9ulje9BEUE1[^4ܱMMeY1wE&M m/ޜ)jxl.EejE4 K0,M V2]WX6oa50+~e- 뢣HS[ˬQwn8{,ղȹ푦ֵCIDAThq{jB ƙX?JMlYݷjY$5-iZi DٳuSz|AQm^>)<ϳbOHPvf~JbT9 ݡؠRw5j;mj혷'PEܹsh,.-҄jJ$2lfpaMDdy0 bFQ>g|yTi)n8Xڏr&@P&q fN6Db1yDq[$rlhd<-Mmؽxyt ,8 .,Ν?i@m{dn቉?{ݣ/05(IAI2rvnnK=TuG>}'`Ӄd෾u~jL=:B5cǎMOO/8 M'[ٻw(f-d+.Ӏ03矷jp!yϵk~[" ~x?4{vƘ\zU7`pebtK,pjkqq SE!͛bqskÇ- TO|)a$oo3rɰUH}w3MhF aq\1a`lde I)q\=B.i_62= Y#ǎٝHO1՟y5rqqo'=*ؤXm/:l|ۆ N}g/?z+Wx3Gn^m>fV0lQlz¸,Yܐ`llR[D( BB̲`ҖF022bwevw/$SufY00K8g?~Ȅp8bKQ۝Y" e+G)/Z Ö:Gz ,Laא8 I!IK毤Nau)BODH]#!~`:uqpd eW !rܻ4 f`nY>^~eܖUXkcO>yQ]!M;;cV=ǏW*JR. b2,of``ŭȳa3O=wvcN>m6%F"dV,elWR5?nOO9s% Eo# B'$IgoVdծƅX!KwO#G\֙o׮gzo/;sFK  ̲h^|ER?#'3"Bh$U#dc(ƾ?_ZÌ)Y4Dz/hMyi_hX|}駍|SN"$IT5￟ ,Lo;|- 3_I Y"&Ct*EAv20p/=}_N*(]N% .|+Wݷk倃R}FG>|NR\#}M{^33`Uh4fBWj00,o2_B݃j3ckY9-\.{3Bh6&V̜ǘ,c9v [_yKǏYKʆ% 4ʨg O22.``dUkppW5ǚ&Rb_rI` F&qAC4Kd:k,Ylhccc<BTӴ=~;vf`dnnÓcccccc}N_#YlKdPyeqK?ƖŦ]Flᓁ#Uع #-;,f 'f71>ٿ$/y@81 }|nTT Ѓbd+r쓕,,44$ 88tii<;?sST$GG(lpdLLNred,Z\̎ЭOMNWoo;=\^{||x𫬶,. \^Ѱ^^LO? KL lnO,.N`+.,-q.-xppČNP\MLmlklͻ=<\\r<<1|z{|Rћ{|=l "><2Ǽ]@(zܡPc3x FH@ЁN[`Yx ƍ>ٹjpa c894!HQ&.b:[PCz"&|x4 7,[qz@!]c  a37\qV8Yc 2ĂCțzD)Xm O[&9T+FR63͖y<6iRl$#>>d)b3BАMOaf66]ZfTFD1Y]H \3!H! 8y"hB8g!`qB \pLhquhzZ4g4ǎt C3q N"oP))4vZ-dln$tRi rXU>8=Xu) <)i? -ft)FDp|Ȁ8!U0<أ PU0 4`$@j>ƃ$}@prZUn~:i͈h 숂#> /+G3܁(D-p3뇏6Ze'3P[5nJ*;&tז 2]AV]Y= ?WW@aVgH@E(448w$HB-d!×ʗ?{?psUZZ9,v|clkX7X'i9tfXҰt]p~f{0  r1veGz`` 8lW2v`Q` pF`5]) 'rM` 0vPkv}6`Ζq0.W ^0 7c2 fU 3U0U ZP[lxZuUа `1f6E;|qePPH`x 8X@_pepǃ8`  fZTeUhycUpO}uQ0PrXI"``PU9/)Yu\&Co`MaWzo0U R5t w}4  ~Gn_){  [ZGMpz\AY ЊӉup` P/Q]V惗F UEX')XwV_P A/l`s*e  b6 ,)iȚ[v@@q =9N_ xp!ptx:}q @#Z_a6e y F{S*"n\ 508~pic`0w2,1 %AGb=:xY1'spdl_ t9 })iyPDiq!ZpZUbJR0C&`P(֟UUbh;@ i᭳y_!Bh, 'Jf8Zulu` A` v# =@@{G 5hsl>`5]*`W:BP e&A Ӣ:&}@ {Pb{C;萮~dO ^7]8KvVUw*C R4:lI$Eku[KQW ^Ł1aq J$.wʪ?A` Ơg7Q~ @ ;t{52J^`ոkU `-a1¿=3'">@(S@b˽tN@@ $6vS( !`Ŧ"aݖjǥU! @$:IS"!*k˰QU8`ծ`ӕ P*|6 #Yƻ"< qbw  w`ȳ! c,qȅiQ\'>5l6L̿ĩq(f#]{+ejP֌0kU,,\"6!'̐ YW\&1 8L>CL&.i qϟu'a cL Ѝ|<%̼ȼ̈Fm U)$Ҍl4,şձg "02ASŠAUN{&03r'kl2*C-H|Ƒ#L"f| "DSM .a4=cG*',TnM&G&}ƈ4w=Э:b03 =4-1(sKbW@ի\'_bmu@ *+5xGtEO!M}o q\ 5Eel;#NFguM\,~P 1>t3ENHdؔ3srPP,[ a83NQEQFbS  ?n OK~ZnKEQFmtp4SQ^>vLp.DVDY|.gT5e^爮銮KD5P>1FkKlnm^ٔQ$5JbGS~M[>RPH~hPN5qC _Ǟ0n8d`g0@ tPSCNP۞H3dP.8I~@ Y 0 p#N @ Ogh1  < 5 h.HJLNP_;OpenCSG-1.8.2/doc/img/conc.gif0000664000175000017500000001426115141675417015601 0ustar florianflorianGIF89add24RT,~T|y|pdg_y|WIRTTzȄ\|$fT7h2LnTXXT4 |Db<04LXX4x`pp8|TarX4zD@p0씶NL hr`T^L\T=?\~dvdqt ||Tj,j<`,Gfdsvt NL``l4L$q4n<$ltD\~$44rtT~,LD,pDddt$Lz|VTdD0DTLdTT\cfd4Ldp tzC9morl(b8JL\Ln$,~\~|t VL\jl!m,ddH*\ȰÇ'Nqkʞ=:z9HɃNtJ&E?),aKW8g"8{!;JtD^g3th g2;pꔔE*1˝y-u,b0{j%e|&e-bIA0C+4fZc0 >.`h x@]ndbC"BAc?PD0SvʔlpA&6.1[Bh01^䦀&f; 7(Dz}8J ǤDxIaGtIlls=k h=+~^۫q7b-F 9x1*!jbKre \cx+ 2p #A$|9>+5Vd|  ^7KF6&3Y`@% .$,ljb] c~jYԊ8eLm8D0LD/1jcfU _VZN2]aM& G ~b؃6~A*>gm{+,(Ӭ:( :xk3 PcM+5>y焳s]QmuH&-yƽa,ghZ|ˇ D?9m?0ܷcb6;.^}(!KC Bv` $C *5(NM]Bu4-#7b^ޞ [pV#T ]aZb y9O%- ajHw#WLӗrW1v (y+?\F2 >1?gm`g#dWK/ vY g xz+1x0 ̙pYD(6.VEbgj;fN%,\Q$4'L1tAl 7/r'fry.$nk/.r6p}k^at*.;|zfP J]ŵ G* 0X>X$9 dpPCsV#0v m3B*M *p0dXYSvg70 04@ >wY@V*2,@,jmctUz ?="_z!JTxRgp  9`p>>0s7,pnpmN mրwGEPkDo!cMS @0 ^p<0H< FQd5h5fl%^uxzhh  y7rE>dlEHBGuG0<<`ph ؈b(4@ @lXjy`k;Hv\֊;@(A;0'0u * 菍،?g@ bx۳K۳n%E{EY`|Ȥ])jhX: K3:G A\C,P Р [#0w0g_)j` mkmHdPkKb5y t?[P Z}渑vܑ]WʢS D5y=[nꐹd_@PQbP{i]抆 PS P{y6ȶP j@)`6@+?\p3Ly֛̘PjܠQ\`ٰ l; h$Q \ 4ֺLeIplІ n<:{8Jp8 ',Fj0҄yF &j EIWț:ט0: p ><025Q6Dn׏@}@ʻ^Eٳ,Р  S0?`myW@kx݆hСϖpǠȊ-Ep+[а lɢ[h΀ }\ Ȯpڭ ]ۊ}E E}dP 鏋E1:E,z-? ȵM-X,,5> Bśҭ"+Mh) cx73 Q\] MӮ,x%[:[ ~ g`i%90‬ŀm؛KgK3xTʈ8րl^%mX˰ݳ+|؉8}P qI5b P8\!N7Mm#.K Prޓ^D @UQkAkJnC^w%@=*1{?@ >5`8M\ =NȞŐgPmMWN0I ݟ9Q\Ey]0409^ok60v6ijpk,@IP $f&_e~ )3nή7s 2x)Q#@mM{ 5(1 '8 _xٰ 1 [ pFpJ8̨e~7aȸ<@ &@q4 PIA00v~y3sF syiیjI\ uo @qV7.ڭzON Cr? ɿ 0|D RP~Y7 `Oqi`.ϓ'xF@ ߂0afQ,V<Ȗs(:RH%MD7$b=}I':t+R;OpenCSG-1.8.2/doc/img/ayam-splash-icon.jpg0000664000175000017500000001367115141675417020043 0ustar florianflorianJFIFHCREATOR: XV Version 3.10a Rev: 12/29/94 Quality = 85, Smoothing = 0 C  !"$"$Cj" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?o h:\2/"aX2z.?кf ؎t  ! ~^i##7hZBbWY r~u/#0-4W$񣒧'*#PAS=VsgXG+XOCbxQqAdg]HfwHVO1{zsҭκp/|Pehs)>eQ !U-R59&X3(6[EtIUv)uNrzuң\i71#軙O^qW_YD\ًWB~s cCn 2xİxHn-j_20d(1`sj0Avdxs_]SOFT?3'q)IxWQաuu+t? ΁pTg)d>ka#`0d NLqUOimYqyo$Gg unHJF7%ə{_w&nBF0љY@[ʂG5{u+roM҅RHQa8䷙\g%+b8# ᢇ*FC.2G |KhpXobsbw\φeKhRGdSf3OҮ[x;YK-'}h|ppGZ.fkdt8jF#*u OM9k_\_ B0YC̥-Xq"p}H"Yu_ ɥhjVX"% =wsbIH<@o`r[m&bB,I[30:9co?KHM-36sWv6ObM9CuqGLO]i%`l3Ԏ*E\{kr2ZQZAac~+ & j 8ڃTwZigÀ<~[/\UC?1~1Q=ˇu$]ͧJ$"".Dmݷ;3V>lWJ5DQc8'.N\z=[🏼_}b-OG/t`Z)%gQ] 5_5@~Uj19tf|li,VA5/8r:npOs^|6vIS@b1Oz(G\[H}q/Z{wYAԜץetvl$_0;n7'kF;Wq`:%]Qq֚V/E  |8$LAª9V"m99`Ԟ1@2NNn#򤸸XFw6i%"ΖOu-ʆ-jgI4HDeWKHzүk E\qoZ}}9Yj7;\n>k1-5ꑛ QHe=;_ޡBsYG - gS-ڦH>[#J^:^kŦ|NK7*mDEpZsPrc/C>J!5<ՙ */?]EurH?w?Swϊuoֲ]uH1r4iEI7AR8HO]7<_Dډ3vg\DO@AZ_ |$Ѵ*XͼG}˥ք#&9SJnUy,eRai9g) d?݁9ku l"$،sVBYJƬIBlwYagC{S]V0'`(M2DL ?zW!x3W.lcɚy8]2[^F% 8!=^eOu/] P#<'<{UC 5{(B9ל,c>?+A48nlg_pMdzXZɔݡV]g5zn|H|e{rXyg 鏼tD ~yTqroU^GWnS胩3͜2W>c-le'ֱNTѐq+W5:hGhIސQZR:in/$=zVπ|)x/ ژ~V'ھy f1^#?NvNOcK :ϙ%UAYj,}RU=ugOyzկۜ׳iNi˧hZ}f%n;Iw2.RGi ?,F:ZuZܫ-VmOQJMހV{~JH?+PA#>a k oybJ-t*#8TrP޴4Xiv>/_^+4S[ API_? | ~)ҵ;z4$Z8p(f\(4祝']ׄ/mt6w{$Ac{nO\eöx^3-C#Ͻw" aX4ƖkیM%w nkԞ>[Enq>,-t{/K%ƣ2L%=yx&*y|ߏZcN,of{rķ;ͩvlMYKcث-J|*G#m8Eg?4c z\} {nwjtzy B|c_X#_tymr.JS}5=ښR}aQHqӓQ0A>GŽ]eK_l\ aeg#moݣFpTz w;J̭z&XgktYeE#b@f¾:MCRohd1WWzLWث#)Fx{׆џxVD5Q4>{9F*8zOihrciJ.n</aS8=pxG,It,7bNf|*w:Z#vF !0Rň ߎ дasnEZ e%M=4zj5*FM/S^ RK}$q%~s]7xo5ddYg q;h-Ub"\T`H{Ŏϫ!wxׄu={zTŞ>&~gn~_ ukTU̸DUymx7'^k{5P숣x?on{ۍʑd?~x_!S\9O$;`=݆z{?+'l桼 2F-!I.7Π瑴mNRlRmz*;WSea $yz;[o*#Vzs+RC)y9zz{7:+5ݛl|7lύ 76r|זhz'٭Z86ZF]ͺ*w^NFN}jEٝ^H٣_ xÞ*Am#-fܤrv7B3>շ}e$(c.F9kh12:av'>A+ōO6j@J߼A?>دW )^rT8k súgX#q$NE?\lWU]]j$d6~Wjw橅 qN3s^~4m3PX %IoN)V]Us?bb?P m9YQ8!H T@ ŻɸnTN V74*FX`0Oֺx N[V1P䌃qo=2$ҕi0_}v{ޒ}N]QTti5&L/č0 *~3ۃK4[IDǙ W8~)RMMCYw ƣF;. ."NGoMVkˁu!2>?y?oϩ[K [Ug.1ŃZwV0h!d5˜Jb~VRӂnFнm0Y=$Vv϶Gj5_t!yQ}83ӰkEƸu༉0!N"$Px$  dddg#NqrH _,.ȪH2R0q:~IFvi)5xek M1'! wy}F46&yX 3ԐcM񽱿]B3.{RaLdr I9gYOMծ[K"tM#)$\ʄ8F%a)&eQ_ =n*_y\#sϽyӤ JWp JA/Q$g8Ȳ-eJDB=_xrqԞi4[%ɼcaM2람,!N6LVRg o*"3H́rNz~tۣkmIppyA׼Whqsl֗ !+By$iQlS+OpenCSG-1.8.2/doc/img/openscad.png0000664000175000017500000006375415141675417016505 0ustar florianflorianPNG  IHDR0ߎ pHYs^ IDATxilWvV͜$lԚZ$dERI`8 H#&@$v ɆF˒$= w5qV~|ݒqh@U=u{ { Zॗ^/~m>">+/~&exxx=|'8}( qQ֯|><~51F":{ gSbf4 =|]G6 {YH"C.^Ҷ~0o//띝pMD嗯\6Y};Z^k=<> .mo#A@@4 ߾w' C/6d{Pj wR@@4CO>ޝ] uZ_ug>CW?E*ͳ{ ־ '`έKh޽.ei4.,QH߁?c|ף~/k6"hyS"TZ,uf᧟z.4sst !O}hSUe DY(>9XVl"|Əgfq7"#"ȊV_W|Pd~ '.u9+ ĸ8F빢Sͦ[j͋KS駯H #֚^|mW^`sg8C?~h} ~<mI#a۶"j 2 0W|ςh8gƂcH31ò?ys|HgYU֏=~M@D O{ޟlV3PUǯD&Em[YJ>6Z{n\&H4:iDxRZik~;jRYYAp=o:z Vpm>_ΉTbigҨ)q%r[}j Ghyxpʲ޶Nc{D|>pwʲ(k LRGib5imRDx!_Dp~<}^ћGt8G~x2sn=iRWmqڧ_x:S-(19cTD|@Q[OӶ{Ea>:m޴ix9U] 1goys{.F([q;m-Kjc/HDBBLUeur<~?M{EXVZ]Uuc>pdA$2GA,ga D\y 1("SIb*D: 7GDi{7Fk${8,kX,ZY_Ԧ7KҊ&m"*Eh5Z U,%jMjkMg1 aٯINOƗ.cD>6>Xz#&ӂ Yu+WN9;9,At!2W"DklVQP 8k&"14lVRhrI \]oӏ罾Hw'n,[iU7L!kp6dYcN'wNeMӈm @ ɲ4MSއ"tyY{yIbq5EݩYHtsQavzzOlnm~>wxӇ{uM["Dvl6vX,;x]]דt||:n" W^ 12"ZkK~F)QLg!B!~{"mK&aD0Z%θ8gUhlNEq㱫-ǿ>01[gyyp8/RJ)*Jk[,ltwgsk{s"#>8k֘c]7Jif>9%.I]gu5?M!ɟvpccJyy^!S,wx<}BDӻ}?lOg'nDd[q6ݺuk|zZEfkk~, @"LY9A`6ZtSO|јːbqgOV;{~9\bx_7x~r|z:I5Z+񗏅ePZyI!F. ߶\d2||:k"J)k{\+"EQVbl/ib p(MU4Ms=k 3 5Z+̤9˳ɲ<4{o7 ._J;?x1,y&s]X~`k6ᬬZ"BfY,l~tx8B 0X|X,eӴ!^1%(ʺn  Y,{9$KvYxN9fkXUR9yYmgmc+EDR&3}[>F {ۛv64Ęx݅SIIj'MӜK1,nd}T$Q ‚PXPI!"D 3;g771rpEVδnBiZD0$I4M]ףш/ioi۶)"4F߼y{B~/Of'c\/_٩PVO?{G1ƃh}权ʁaBSםcD@DͱnUf_OBR ?HE:Kb y{{DKL*!6`榩J)QJBhǧ`e]КYqDͲ\L""qk6_31I7޸Y'DҬMM폽yLk(BLDe-pQXmU/pN|j}g^9Z;ÄcYvwwR1,MVgν~7xڕh8QQic"JZɤ1F啗۶EDR&Ii9ֹ4M|V%};e8'RtŢu^tc۶m廻}Gt{Ώ7`Fh #?ݭ/0Kd"!$!E`|6Y5M #iuXՄ*]]X.u.q̑hH UJub=/6ö-UYU,gNf] d2][$kQ[d~֝ZmM۶]"HKїo_ \T絲"Qz4IeijL&IdYJ3[kݿWU1&i$IUE1'JjQ D|=sHk),umB)3 76ֻJ,ˬJڹ, z<>1F}}JiH{zi4R:Pu6+ﯵ[H)uW?4kw$EExLOm/^u=g"RJc1r$HHUU7FB N$(Bԏ#uz6Z)RMS1 sZ+@$d\.~^UnM T$FQˢJ;rAs+Gwv?N&:H$_~wr(qNmJu{R666zi]u.fS٥ٗ>ֿMCRh% g[<ꆡ:"y11O޺u{:Υu]fp<2ۇNo͖G.m&c aӴu]Qu}G|~O}^ꗧܢE_t*GӁBs|8<:VJ=čp4)"&R,׆#\+D%DO?"HPYO\9=Oo:?&?iZgTUO?3uU2ι4Yyv/mG.A UuUBl ]Z:x;f$. AV5%O^4xo:xmgZLJ{o|Y3-66׍Xol!)Ps xU?WaRd .0KnmI'W_dDŽ{d,4_t@%FBwL,kK>1IQ+ ,eѶm$ĦiBιw{֊Yu DH"WJ@{PnGcT]M[O74u„X!C/>oY&jܓqXi*F]V" su]$/>HLfP]W>s_Wr_j"HBއt:bd"hڶZLjMxE`2y6κG J\cIӮC,\4m9BΙ|,Ӕ-"1y{߶mgw.\&M˥e/.)®Zjw'-UuUVU[7E@`cJ@$"mf+P AZW+7}(D?G af iZ@,~ FmыpTk=%-ߝ-Hby}n ,s8z+$1(_5E0m۲bEQU!Ķiʪ2Z+ }KG~/ 21+Nf6Z1DA̿y`8}m`b *7+ass?i^ D -"U\BJ)(I(H(8 EJRhSnmǧ%"t E}@L2Fʫe@}@i˲BDBh֥(b1v(23+^%WJ13a䰖ߐHDA9_ou)S;~v].Q;&*7'eaGv:D/1]$k4hg]G.CTD+a_(˳,5F,ئyk9Iy+օFn} o}/?h@@be F m J )*8(A=WV)ҥUJiCUUcB#c6$lz#i}] YHd;6;g"XMU"}nKcB/~EG<3&" QΪz&5#jGv9xoNNj1:W(+8u9qHkdFIzɸf]_?/r@#-R_yWZS⛌?$/wuA)^NOOYkT"jC.q.I$47L!͜Ӿ+.jo Ib>e]~occݹ$MctGr$h4:8GT1v՝c+p Hx/kUL'\쾼w榭'c16o)q1e&ť/B.{DH AYxtnu ՟;R#*K&>o"J3HfӢ(V<v)I{JQ1$MrY1%Zk}dBʹo*PiFQVsWk..]ct=\[ u ַM3&"@DMSWU5U{M(Kտy`FfPst:m뺩 0LgeG"'fw]*J'7  v6?+I DP )$IBউ"LJm3Q,}MmCsl,+ڐ$Mطm۲2h>9O&_7n[ka+E cZNB[[yvWa]E ?y\qY_D^(>ؽkMom Zc@!IQ۪<3ZaU>l }(@3Gw=;t6A=mgѬ*,KOO潼1szO>UU]@IRDblxY@82XJn.NP`_{wyǭͭg޼l֕5!6>,+K9 * i+ngdQ֜?_ի&F^,\ ÷-D("֜7QJM("PZ+@$g#Vr *\x޾5˲g9sV)u)"0֘eiUֺ# E@?8> 9("7v7ވ.l)"X*`惬{o{U#,oPLqkIm]o^UϿ ?!2߹HH@7)"i&h:#1y[ݎ0M@3:۽c.^t%Fmz`>_k:*,ˈn"!p84zoj\QD)Q|,FiuU3UEzݯbpDnp%lnG?4m=Ȫ- GlG~+|O֒o_l} {J"")jNF IDAT\.$`<> !!t< 3)ȃ-6zw)v6{y!֦, a}Z!DHDA?sز\y_hbȲ.)XIhٻ3Z޺zFxe*,@AմB[tu_~.(x1y/W'hWƝ5v-Z(|:7iͯTS?}voxLrжeѪrxXLxⷷ&0rm5k>992Il/ǣegtpej~!7ry/tI#i|Rn@9Y׋a\84hmmPUU12D(%bU-7^t$"<ڋ㣭 8@Xv!@-UDC: @QNd9LM~=#*UkT Qs۰ AǚDiжP,pYbSҪמ)'i9 Te5qcc.()"쬵3?XUuUxHJ骪Z; 4wV%IB @!rYkMJ1fss@4Ӆ/Q6 @l-p |te(7=`O'p@jbB}OE`8c KDd<c NQ;+eG6W*fV* g?ɿL&̗XVz 2}/~s赭!xmy=YMXc*fVi$2BWx1_h4E"fjWmb :I2k-3w@Yβl:#gcK/> "u>GA>ݓ}[{Yf:dD4^ 8%2`` 3Fxdw3kڶn:꽽Ưie&D/g|ԟ#,QkpzrRKkpsB>RAGl3.u{*kbUUZ+cF۶u]O{_R:M,Mq}46uMT1FRDF{GCԽ^Yhh Pvnpzp>NpsǾs s=XiY5_ 3/gin+R6Ml達 IbyG;0ŶyI_|&Il =XZZr2#0׊X"Bg 4KyL/~/}S[zݽ@;k^ZWuYGDeY}fY."DZ)e&M-B87AEqT9ʾ On7[o=kjZ1ܸ";Pgp>!ԕ euOoݍ_e;p^,UQB /"޷[Ϧݻ3O=و#$i?==1{i.BVZ$4ϓJ?m۶Jއ;h>F4qyyI8:{:Gxz^67ىoVq <8"pvE,~ W@IHA" {_ n6t37v˶t/9x[Ik e.xV JMh9E],)lg>'.ɕpf9~w~{?NZDurcE\-"bq+:Iiu]N[[˃]k40DB4M1M*AeQMԵ1ڤI%=hWND"<gUUjQ@m"/i\1u2ZoOrqOn) $DJA)yH??-[%@1B롨Y 8"H󓛿w:\Vy18ݲD&J& IYVa/˜p]UR] !O$],UX8 >HadVki *f`ȸ,`>~TD|Ϡn< ِvo{",ieXsë V0]K/Ŀ_ OIՀTVrmŷfwrq-eYDPzO,Cq1r bu6VQW,'(k G?3mD*I칒"uvSchۆ> >R!Ȍ  Ў'u%z5֡1Q!R^'pi{;I.)¦brzzp8M_Z20V @?(J R~ WL*ŀ`Q]e\ &aƑ&ĠNX]ԶGX$ g'$zgU1'"1kyìء.}Dΰ)93mۺn:Ⱥn&F֧m@aA3fQftk;gںqs2CHWw.lc>,$J#/a+G.e:\&-ՐT]~&q-0aD4pV֑#SqHU:zQp/B% KS# 1v(1 )M,}~`_æQOtg!3JX󼿘U*i]贷6JAm:kKQ0^TbQWǓIqI$Kl+V[}BRi*H4tZ/w'>XhDhQBĽISټSOlHۖJ@$@HAy_y*fI݄$KkxxvBZ ˻uZD\YYqoӕB캓VpBQ D9e0s>MYrhd[O>l0oF:[dOfM$Iֺ$ID=nb]'mHv6 e]^= (Q$" Xyot4:1<_~>@e훽^viGҾGc+/Z7dx 079X02ߏ<Ъ4\!2)]"wcXuMɲʍN bT zPChz={r4(9QDw:5SC=A{tb.NZ^ZZ4Z2Hl)&`=HNOoޱr @grA:@ei!x}FILkӕ8wR /`>0Da|.F@+.CC%Lfa:kjHim\%KX@|6$,-lDG:pxT }{yG)!z<`D(Ĵmr[^o?hq`&bF*nbp}:+," gs6!ZF wE DH.:88[ug4;^Nteù8cLB2x*'8B@LWQWؤ{ cS$G؁ZYV јoVʨyn/mhӃb[]B*6,tc:m=ňMaQxy%`6Y0 Uu1De|^-45CJ2(m>@.L)@@): ~\SIjd {mDԅAޥ7@a>ӅԵP@:D|*rvHAkm~e%>~??/Y5qXѻK3iH9g:+-FMY|ᲂ ou-;d**v̡,ZeMP @'h@Q .MI$i4IkR ^r۶nZu!0Ė!͝`o6[hR#ϐ6 YYcc"Қ$JsVk^:^<3 rvnFy[7n$1"P32 C!pҔ&{޴)S#e\KDJ4e5F4mOE)G`<ͰI%Vt~eҥ/ńuCMzQDIJ+X6õ6""k?ޒgYW2ڄo|vrxA;EMwGGCಒ5t7 Un⹾FHY@5e4Mxz7˜gDXk|?P!"0 bV,mf)Vl]=1>VՍeiLd^! xtYbȫV m?8k"YV2,ڪIo>\[s3[Tc3.v\aLQ]Y^"gb-Ƥ]W1\b>FlCw0p ӄC$4;R\w&]ŝIZ^I !MG~#H&讛֙yn\.w!\?ۯZU7K%AB^e3Zc e&4 ~J'^k2<WbkIs'Uyau5\Ff!}{olgŲ:8L$sNk {r' ɲ#Sشz/?\TX)ɲ9wca~>nݹ~ *+Ĺ(\p}Q7 s*QP"&Fi̋?gU5޾uUZ pd}ZZ#bg oӶдM&2,]$ApH]zᎀaՃd em2CW%{odu~goW-RriXL9J2˲d)3Lj*gj\Qf"J&$Z2#bLҔD%D$mw=7^?4@@Tž};;Ʊ&8k~Dc\B){n|ynե$nI+`¹e[=NR۱4ly1Z:'2Q@8W "ZZU^8^E2+OM @25:>P+ %@QySe5d4"'DP52!Du۶FFj @8جofc0pJME pny |tiBq҂M@fQL)8R'pyֺn!(@,;pfn5Zuc ?2:J,F\*Y){N^ hJ27ZZOȝH CF( $@+%cFF5ƶmN3^EPPRTJgz;˛yo_;wnf2( e2KDۖugʮ @Y!#R ڶ}W>?ZFwbnmli% /ϳ<Jq4 , T-~UO ǴFKi0߳21n7Le]l߲|I$VIk-QjӨ}6;;VFͳL?kv꽿z'LӼ666W(#HoSK.T(ӈ+ m3Y? =Te:)!@QJ@\M@ !DžYY&ãkS1hu_=(K6)ڱlwOؔb#Ab[~XYKJh'N\JR!4ˊ-j VBV+kvunGM[v;:e,( '߬O| @k\Hi)(땡nRJ[dԊpf7s{!2F= a~eH!@8m(S a"l#E%{!kÅ'*5Z?C"fo`?bJj O'B_.> |%d$r*c @B6"[h&acccfflrjO<~i7N64u]V+z!|Ho( ^VulۊWB[!648l@s[mËC+ $8DBemӱq!`! ~e"yiOt`H \d䷜<9\z{TJ+eY6eRqh1]بH™85%J_rv{K6eRcNWũS/ؒFT5*Q^>?2RIӴ^o֞꫙>8̀RB)#CC7ޗbZb.뺜3*Lke_s<е-DFIHplHEJU m jܧ*@Fp̏gU8"5;XY|1IW9wzACԄRY6Uz*RTH@džv%^)(EDk\[8xhRyC e`˕62PIxcI] C/˲^/a0tWV71!6|OO7kT0wiSd8dwՉ+>ZJI )DJ)}'˄JDd{ËϋE)њHŴPJY.CۙdsןOZ \JH0߇rH=*eyp"%HD|R35(A`e޴89~|ϛa0D999XYZ*Z"N'ol"Pϳȏ8!CXLƌ5@Z5qZ >ܪk j^?4uQliLW "Du]<|jtD;qѶ0jLwJՙ'K>H0"(ڄR5R $5ZoG.olvA4XkBm6Z4n7:kkB뉗'(\B5nDF~M>^q_X4=W  %Jg,Vx. Bh @駊 t(e5!N|lvߝ!TݰmmN}rOe&Hra3Gm=לRQgb5Yf`C Zu;o:25s~ ߇rEaviжbla:UBHSn"j{ChdFD-I0>tqu Ridy !Q)"*>nZ+)$y.pRʆ,J2 I4Z89s-*˾,[֩ck? n"Z;#E9gRJJR@)5Ԕ. !rL+@hzwKYp-b%q,nhF{BYXI}5pk !&rΕE!VY9"ӇUK)\jY!fH/W BȔ@CpĎT&my^ v*"FXPC%B߲!EG{OoUn!4DaI^B(؎ckmsLQҲI@58/ accz]fB`;qdρ+IXnTtdt/n^ ^ L^hҸ[NRk@Mnq%AYQtkB>ԏ9ω9QH^9j$#5׵߳Rh\ѷ*b{?tS1%XԨKy:sA"0Ds1Xu;1jyCp*y#"!lBh׵;t B4y!w8 $vP_A$.1cJ'vVu9!Ҵ{߯?r)"GEAPٵY :!ġ{9:&A,B\pBQ *Bڰ4q螨TFa7 }7D9"7˺KgLw:V)Rj!}vxw !q896&ės>FkY4_s sy'r<9|}"1"}sƆ3=["US €zV$A@Y:Iq{yeǏم /ps_7y8S!8Y.GΘ0vAI'6} nQ*Wv&Ibq˲va3Zcu1#1R*YvGN"&@MB VOW˜ђu(h@aWXr;vx_O !$˗79,@ >q?.ZBn^XJ)$pPil#+:~hleM=Lv\vI"l[p(@H!cO\lVڍsT>BTy`{ru.Evvy"S񅹜hrqc&d\8Goڮf-6^)Ӂw`.@a^%4Pg!Y.&'kSS7dsuO_059QTRT*UFj-;ԶTkȳ(d^H%qʉxQr9j6;&nra!I0`ǁdLێdT/nW!ٻaiҜsv SJA_)kuc4Mn7BRmajNCvu7V˶m3ZfiY~5hfeZ+Y+hQш)%(v˄_ҭV6z3ůnDmX!S/;SNerb{fݯi%'Ab}[-PJ^83+OogQ7||?dON,//?U\/2 oB_+ +%;Rq]u~dMIUCa+%;!RPJw:y8e)ɵ, F=Uh;y>ms/$q{(v?2yT0b`sk¹. 3Hx?hD N$rq;gf,%ǏPݺ !bN;AV+- i2{̴/٪,>;;5;;-e9?l9!eqtשaa"ˍKg%uM+UQ}Ϣ%\"#e%i,Nut? {PSt(:i(JWKL1-T52R8v{ .bqus:5cjzB|mmsa~uqqՎҌ1 ei$0 %:݄޳gOlZZL3ʶ)lŞRB)@w4!T\)E8=_bG)Q}Nɿ 4sI)1?)e;gfGGjZ+)z}bg No]_S;&nFkqquqal $IneJ1266jvQ/R(E,R aDVGT}M>q8߅zVvP`AfLs8~T욝u][Ji ,y0Fg11~mbc9? RZ)%iaX.4k5YQJ̴s9mfY+kT0RLm>рz(* )($6140ΡTNbJzzm}mas~#UOC* h4maJe4/( ee1J66vBcFc!d)AEV;v3J #3qxKxƢ7tx_pv)/VO\BIn2NxD2ˊJ-oi G= x9p`w'KV7:SJ"K֓znϾ "9wownObluCͅP}vFFn6o%4˒4ssӌKs=pp,]^n/--7p(yi ẮeYJ% |x62̶ȅYܕ76m"'ODrj%U}nuR)ػZk޳sy,oͯ,/ջqu?"vn7]<7"-]v(T&*BK g`yK{wq>Mu!&qNmmێW.74;X6Q7M%?$"SsY7-忶6x_Z|҃)+ѰI~|,vm)8[(0l&7nz8"u cI);-˲m;s)eϝ#PMnJ~ǵc&܃QFm(=l/ vA-n? H7~zP cѼ9w]D…X)MpNS?D{-m|㬯eiFP0z٧ϝ{Z|iOVSyAFk mQ0Z+Ƙ石8+Y=x 7OIgnȬ{eMh>Wiԣc_WVon+Qfo=VEyJ˭{`Nq|G_ygm΋<0 RIht\ ʨEQhzJ2JֆRZ)exjh6!=FQ\~RF? !~7kffv}> r4K`KބFc[/>|J@v_o{r靟gGFF9v{sZFϜyGY__眗JaШ*έ=tQ{y䑇?`YjdR}}_G+^xСÅFZ ^{'_{|(J[Jm=ǰ^g//xzzʴ"JA3#XE)e}kZ~c-;Iˋi.--V*UΙf@w[/<_SOhǎ&&Lc@yONM=?ty~naPBrWVo|S5O|B(*} !}_&IlпllտЇ>ώ޽;MSO)UJٶ}O?C={<jR;P'ӴҖekZy'?WV H1%{ˣ#O=T\-k?k׮_qǝwi-<'/|37!W} & ^>kWJRJkz}c}JP&TKJѝwu{[o;}6qALHRZ]Y~ϿjEkfueck /^93QZ<+v]fTãBfя_sss~gϾd  %l]p~ttg|{ED9$I9sNLRJ:Ι3gz( }9uեQ=̳##ϟoZ81CtZO=|=,tbT.-/ QJiyK++?>1:(7y~gF;lZccfs4M2c;7 fr9_XXX\?_\.qؿ?ҁIlJ4zIDAT/ξrDnZO.~3…_&X:mOԩӛ{Ea*ƥ1DLd޽rvݵZs;lFevLzm@6B4Mw7(^~VT*Y ^OÇ{AۻwOJgY._?,뎁s??j=J)ug׿{}K_z̳EFl۶'X]]!w{ezy晟K/>|$J2573^?~#eR >˲ZvҥV/8phbbrFWW8޽FGdž? /<{ҥ{vi3̞FJelǎ6o~d߾}_0O;wή,:|5>Rw/t}9r,Smۃmضm>sg  Ъ_tazzFJE[xmy^ضEQl{mۮʹfscn%󠔼r8:y`C-85?|'> o߾~޷_Z[]TPJA裏<}C;`Aydv]Rgc6{a*,0˲(#7lEyCJ4t8y!c뺌q$58 mg[?O}}_EO!bIA  e ?:sl_h!tkd f+z0'=EQ\sЕ/v@\bCQ Ck 4oC! q@klYZZ?#eKaP($IBv}dúqQ Dxl-7qկ{FR$pdΊs)DwjL17+3foJ."0αGZ fN8!ddddt3%xs]fU,ΔFfMw;IZ!Q Ètږ:O"/,β2nĶdYjqtnoHmY?ڝR֪ (@$ %܋/8~k{^O_gϹNwya/M]Y]?v~ڇ>iщEeYv{qߐtN񵋋{Cjyl6;:6i]xbzة{~^utcc D)c_I-{}u}rGeei!ƈ:I^{_fu3g>tˋGK؏@(v[>ot҅?yO^mtt\r.]T//&q\7k2 ʈ8=SK6]2JD"8VZ) Vm# ,BH۶@(D)5 !8=G?/T*m7J憿@䰛 Ո{ Q$QR;9QIENDB`OpenCSG-1.8.2/doc/img/grid.gif0000664000175000017500000001543615141675417015611 0ustar florianflorianGIF89a_nLED<D%&\ctedJtBe"lt*3l6TBlxstt\=3|%Ts%K3SiCezh d/Tt,`TT t< tcdl,pW Z;Tz b܌ ZL K&]Lw|,Ll%l|}\d \}\\ |><:2d$"$#iNMZmlq)ml_- -d||-<lv^\z3 j\B~|#|<<|\Ed4|D|l+|TJ~4,&,*Zl.fl44|9z| LqCSBd\; <, l"TFL"$dd|bdTc$tt4tDtsu|d!,_nq h*\ȰÇ#"a$ۘZ\E#Ǐ >bY6#F!3`FDOʅI3$L'IيQ[5*XџrD` J#ByozXJ֣CDD2$rVȮ ("EKk A2Ƀ F(pEҗh2 +Hcd~ĥǠ)Spg8i$@I.RgוNX;ZG1DҒ .E9p~;]A)h%^PIk/*]p9r#vܹvAP8!vٝ VIPghIٗPeu9ǘBeVD@#̑ ZLFPZga 6"n~ 1ٌC'ed6׈:%g 1$ \~Fi +Flj[`jq+DRJ:d̰BF4!EtL 3:^$VЦ*)TFF0Y xh) tT|D'2ztZ-2k 8 'zk%w, >Lb0r!:-)Mq (QmJncvqM6Ȫb:<5NȐ"6Za0q@ckv'M(O(wy BDfN9]4X4"FH@<Mt T!q~Oɀ*^Dg.(vNyHB!tUn{Ni`nN *1T0siڮ#1ЬRR9"Dq*nPebD,Fz&}"]eIj"v3.bۀV#1 o @  26 BO?NQ"mЇ>AfӃxvAR? %xɃ2uJMP@ aG-ϭ AC1 :DJ6&TDn #r`* ~PZpl&6,ca  |)ӐGe`'6%,`AEIZ!e,`h);LI@/$xpCt4X,B\nÄ#D 3B2t05' /C'U [&9@sG@a1 gq "K:1k d>lH P * R!xa<<f `unhK~!I2D.XS yᩨP/OE>ЀA?2 Po8I"%=# c@( ft8AS+@O&|"O2 MP"Ǣ&HDZVYfdWm渎%Bis3/"F;<"ܐ) Ԯ$2TQFDс2a. عD?V!A E P@A%i7.ZbDs'*1\W ]2/uEZdd!"X& oe?c>!g,yx1KjdLdD@pL9,0V4/hrPr}CƆr@DєtgxXKTDQ**9[[ H Bt+M\rK2qn=\u: s=u@U] ~3ff# !#B26m Ї%,1F@A- "@8FHYG/9 #D F@WP.H Ё8j9Dj[4σ!D~|2 nt| JUA02%8ЃlLgt@)lz`?\Yu4 ̶t HJuȘCN%/j)gXEo ǹv)x8R8WO@&J<+Ac@fS"cR2"Xx pqTB@OtALfOQ4)aM]a1*uW0S}g$a`tq}@ б$Ioj@ 1)'!)0X@)@);1 M@ &/y( ,XA}r F ;$( rE} l k-kPq@\Aj r>#%v@ LShK6br=cq)oL)`$s0pER4;*ڐYB61j0`>6sj( oS@p/`m3)L FP{њ'9ɛ)Amrp0 [P:g&FR) 7 F$[v p HP `uUCqUМH0 O3 ,)=y x y[GzkJcs6u6Ad,: K" <9pkw hz"UC-IFpQ<S:* :c |ii]@v"] (J@RP|7C 앥OA ;Bm@@kCuqytJ}TP kp F0%2B$xΰu~T@-PȀ/@@}6 E |"&%J&P _@X3) !(<} ]$ ~oxI @ FU!BP^ vpϰ ɀ q uSU GJEGU0.d .Tgh /' _"0IOנD ,R@w |`!#C ِ#`r`q)!,5r` [`9#e $SE X Zxp^WsP/ɘ/@,%t%bc0I,G Jr /&N@ * 5A@@2K]$ ;ނ1 5U:D v(`S^"\hmc}dQ ـ KE ;`:USk~` &c`r#+It.KwоDf(n}DHE;#9UZq@ /5?rag%A%4bZ4MgC\kHc%_vPhΐn98!V}><'᠞T{E1Q* +kMk4DlcrlWФ"P |tDA %f&tho4 M`>CW%DT@O W`U W0aK X q' iҝ 6,D4VN\ 6ahOZ@jPh&d-(5EO-6)y`oY,]0$3n4Gu )TZ-oP8iC7!&xk!]Cs$jPUdGkyM 0;a[x2+ml>Ȱp#l'GpsDUU6n 0ӑ{+l@y`WAlT:<Wfa6[ KL0kB}"~J @ z`TI8 V:3s"V`c=o Vw@Bѧ8^` kR}P`eٱyaLDP9i@jW@ CfTCА R %9S}gA|.Q^OǴj`>9C|?!ǑAɷ6@ȧl lP#ـ)0ƔSh(.uGF|4D@-Ȃ 0P@e47=@|&U  O"2"}@jFgL0 q 4 EyA X!r&`@*4W E9;"~(j0kWo/:N/RNF`Kf+h1):d@b(@n)q y6E sVb0 }7*L76H1x)Q= u@ t ; +V ڥ*W4%9*Gr xg= r)1 vPP@@"\p%2yAB*n`Atom?" aFپG\ b4 2w֖|1,k-oͰp&$8aXtaQ`1(IF^0IY +Q6ʰ` Aj<%)Ûu(v`c);6my\6 ]C0 Mt`I=qhV`落_*F+y1\= J a@y@&M  DZDgW p `%.CՑɛ p}-TCÐ&֎6ߘ>ZP'ceP_\)+Sd= 6!卜,707J` QP)  4YJ}-p6^Yjp  dW #X9\ >q!"dˆAȑ 9»2@ĩR0CLlL? IZ `/>">p0ű:,OAN)}Ч3W1N>E@*O0QN&!sx0m]MRR%Z N @498 S6W|ahXST0b4)$םw랂g~R9;"L =9zȉvw6:N^9 >;ݮ+p\gJ=2lg CarC/BYdF e*驲u>Ȧ:lШpl0#`CMyڮcD2Ј dX`*':9 MdĠq4Ԉ(T)9~Ѷ<0"$)BQwuT"B04?thZC &AHڇ( 7C ';E<+(xhk׍("F6 IPCMԈ!BX]2*"7*o/H"f9LPcq!?Am!V9E(I-s&:".` .;OpenCSG-1.8.2/doc/img/ibvfi.png0000664000175000017500000002172515141675417016000 0ustar florianflorianPNG  IHDRr>! pHYs   IDATx}yy^ٙ/\A$HP4)C@Q㘊cU-r%NJTY&Y%[bY,B:H"`H$]\fgc_w7:yD B5hs;B?[,[{h.4k_c75>oon}mo׎=}Q iDCs[*#F#P40TCV' +xup͚]*  [d5H9 ܎؃`kBuuenx]윘& (WƳuB>zw'{wЎ{K]sW:;S3隡֎6\qi2q"C{í--9>Rw6lu)tjhɴ1Vџp7g/L$3p$" l;4eƮl;_:7ix7|!1[۞9s08钂ާ}߱]@Ϗ$Uܵ Ӯz,g[ޔvtbۓQz`O{(m\*ȗ]ٗ|swfEI3eNUh"](gE2L"XDc9ӵ 'Jm nSl6&&sO|@$k6z{_!5lCű"B! p5ƃP \ݟ=<{ _jn+A1:5{mmWYsMQ~k%29l4wߕkW1EYPdY&ȲQ16Th,}fR5]7rd,t@tױ03e$d[&Su$ #KKBQ$n8z4q:V"V J)\U圌%IlԿύG:[*SEUFz*%a{8b_b,NF?\>_F\Vb}B|c3 ض-͎FѕeKDƌutflꧻzcg[աYLmKNud L,I.eVһLIY@@uK)1j\Du-ĜҚjOi1O74$Ecʡ#6$^vGFXh c@3_/$ `^w:tǜP,MM1۷.&^6Ѝ#*.o> 7I!Mew&VKHWo?YcIcM|IP/>|YT ̰8K1-SZ)܄@ˈM!-]XwqpW3TUm;7\uq4FeaPp.  *YCY0ƫB#-Z ش|/ byp`0TNWڇGr9gtPhM]I-x0Yx01A(jXqf\[Sc:2EHkvj4ڙ]`i7{]Y@p~DKkLXڬ%D QMѶLwQgCєP",*%rηo~vr:/0ٚT 0hE%пHJlò|:3k6P [1uEYҲ`mdeaK9 Ds\ԔuvvgVl^A4n.J15FBW}]uwl)-=+:Ӯ`E!!9@$gȲ>vkP##W6{9R (lMdiaic1 ;s%Fi Zr=zJ{gO/9I3:<>Qϲw͘+JܒPW So{4M4~RDZ… mmmJrƢ$aւEsUUc,SJA۶/^&28e B^rehh(Hl&.- \5sv8ȒV(U0eFm0Oǿxb,UU1x<>::Z{ΛoYcMV ؆iiϴrA"c r]ϤZ3d3%A!OvUM ɘc]>Փp5`ٶM4qb(U04MC)"8m$eyff꙱m;A DQ)sH:TsrƑ7L&ofh[vt\fveP]ã wwoX[`?wPx-WP.Q%GܹSB*,kzzzbwSX搰gKolFn|at[(ˊ,ul:rhk7˲'hžMOO ѩ*bu]BlvΝpU۶$ܵx r e8•K L/Wow hj`8mf ]ׅc /p!|>N9炄mU{?"Pf8g9V+F 5NzH$bXӴJ"IRUO\.bB5KN,7h4-ύH@9"#>d!{-=鶐^((g~+3u^$IJH$*iEu z$Iۂm߾]4M( k5i:JʱD+,ц pKN%Q,M0YKX%dM 0 933366ffK5C'!VWAf ,}}}ccc\ζm,ˋ@ob޲c[(HVeCWcl- I]4 3331˲FGGE㪪 (IRTD)={333ROӴx<.dNBHñѰ b]|dqi3ࠪBJ!円ɓ[n<\.BB("ۛ{; މ0x<.뺚q|Pm{zz|O&d618FM}!_ZZv Ǣ>Z6ɱUW,ŅT0>>.N4-Nי !٩2`qѡQ^M4kXKC$ B0JR t]/~Jebb=ϧA+$)Ғ[_,ԩ*~mۖeY^(rw8q!t̙Rv3` /KB}zH%PHeYv1UqBXŢ(4wuEBGGG$Ijoo?v,ӶmsΩ))CBYVm{޽3vebՑɉz#H.L&Ϝ9Jc*v.dY>pǓ$Bu]`?߿X[KhTdֻei ˲yiXLQM岈$IPT4YUU,+N{AWWWGGG6M&oi>,˷vƌ|1ԿݝB9dFKKaOb^_7˲Ԕ`LՏeƫ ~ZXY[ot-JRRJ=b`yqXUeBRx | RqeQ7r]p"w2iOBu"!!鏨a/Bba=ۧoIxFC-)˲eY_C… APJSжmambuڅUcv]u]ιaUr‰Dkr èUD]J[10_/rÅBSB83KmWt]#҆ScmۮUTgYẓbRw+0(Z߽!`ijj**zFgϞrN;wnӵ  (b>zY+( mmϿcccoƐH$) 6:]*D0\e2uE0Ʈ REx?#GG?#Η+$eV 8nYc 9b,˾W 1>+d2 OK4M1kkn\. VUMZ8Ě*,DTV˷1-wu5Fs]^܆Uhkkf3Q_M6B(}}X,. twwC~pׇT5yotZD !S1&o<[ez> /ZB$*]}sJ(*.zzzX4oL"!׵ff|bqMS7l۶J zN *[xX w}_dċ]˲8"wi˓`9w8g׽].(Bє$T*7Dc:uvzB\U0llPGW)!YMӈ@[[HXĊe=׵>Ytl˶mu[Lt:pz:V]nb Ȳ<[T]LM{IP4MXuJ(>. 7 D l200 nIA|t|kSh7LGvx8iaIR8Zc&kЇySN%D"!6ϚeYc>Zɤg_z{W\JQ>, Z)M&a+JUUbxW5-J\6v}?Ǜ\>zh.ms9$|6Mf_:>wb<RJpНGaM7HkY?RT*a5#kO7MBG0?~}G9BHvTxV_f{IDAT_}ܹ1]"cL Wn.6 [C?UJ%U  ٚR[/|s޺كm&6/ s?%D l}4m[٘Q rcZ6/ K%/:uYcD$If MpO¹Qo$6) Oz䑿maY (u7͙~]0E!$hp][,G|NU`BTPxf3K\ǩ-cOCޮ̥ +nR5-X\ߧ-GQAT>)VC i!8{vᇿZ0M K,I iF$"_U%~GlkQQt,7YY8JmƂJuk#D:uR:SDu>!F$,Ϳ?z„( = \ﾽ'u0Su4$iͿF)]7HIxo*Q90[gӟĿوQ;Ako$|, Q٬Qjns~=Majs[DU^s5_KEsHX._v&!ٌs166Nobwk$ɏ_݀8hO=_ȗ d"ι繜G\O}4J7 Jٚc ;JD9ڪQ4"YUqW3f률s'\g]2obp_(;/'n$|q$|qt}r jf7Rs$IENDB`OpenCSG-1.8.2/doc/img/drivetrain.gif0000664000175000017500000001307215141675417017025 0ustar florianflorianGIF89aj<><|TrtdPUi /䀎Ta0E)(V>)H?m)*r 'L P@.3Xa<Df0.\ 5y*ASi@-l tPԢ>/!VdVV`B *SAGa!TC&@A[p:⤀{ --`rsF) \ 0Kf&NOPD/3QBjXY 갉9L K pLb@kM,>HF\A 7A|Ĝ ,pXfy pxA j]\z(o u @QDqt%I*ZW9/ͪn>2^v ȅ,($ ]_< iGߛ`:(yŕ|v-AcCL qz[i4! .:Q=zb0&G2 @|cDX!WW%фv~ep*"@*S[ a!՗QN<-x r~Fx>1こAZR*NWѡ@patnQZPȄ g`B vFpja3!bh"ΆDLYJV)tfV BP:0SpP(,0ks/8f 5 !a\޵Z?V[$HY0Zu=asǛXD`"*y LX@":(%7Ua3GTGpBheI\m Paw}z_ ~p3!SZgW%qeu] `2̟ n9 4!ztۥ D<BaX8X>!XOlS({ѓ?/T>P̢ L@!<vnXaC%@_|#0G`B#M左9P(V*D-*nrPnU1ʠo)z: !PN+/hEP86`r1B-`-VA%9 ZhN(L)ON4SN’R'vlaSSBӬKs  0ڈ]Mο߄W!m`I B%[D@K/-pM/ 9@@ bC&d(x' ]΂!G_WC0A#Em"d?iS P S/6 5j{.C"yjr &  ~}" 2YQK?x=udBTmlpqH p` h pjxqLr06nP`\mT N(B|} }ׂar8P5Uq!@I//PDP CTI/)bWZS`=tOAFZ` \`[H|.'n:s1W4.Z^ , u[(" "9/pPृ CY}]b w43O np.t|@rR%@H<: ]Q7u7/B' 61`b8gS ?Q#@ DI5QfaTvKcMI$vL  &g{.H_UyA5C#c#I %X@Rh`C)S|3wf 8sM0p.f9#bfYz0q  !z! {ReBp |Q*&[pS }84 y1BT1tF4sk'tzrr % >0Krz j{ $K$k0 0GA)g0"T0 6_te9 )\Zk@Q7Dj06 W  JwY09Q:P 6P*@gYPLY3v`7uO$[ %Jr`.C0 u( ES,Xq4! 2Y|(wz2.` '6zWDP6Cj (Y7N2WVfr@081yp0 MG -a50[4"-p]) 3@Win4Y5Bk(k#0"RoFhF4'oCU$ @p3R%xg2 wZ PUZ q$2X@*B>`N ' Co3*g. 7Z)pԻΨPju*)"0u @ xrp p0fS{`r T&)k@mc+5<&1٦]_l&q@3 c`E1F &[g1`FSOFu ~pcNP0`35\ ="<d c.3Q~h@;OpenCSG-1.8.2/doc/img/diss.jpg0000664000175000017500000007124615141675417015642 0ustar florianflorianJFIFHHC     C   Za"  O !1AQa"q#2 BRb3r$S%&4C'8Vds-!1AQ"2a#Bq3C ?N(((((((((TnHm)a)I84+]mG$.cYBUggQH\twwmIi$KS=ș\woEDvmOVvv3& (:<pTyƾoUVv%4B6j:zUiokS-%#ڌ S|LOԏ:{@7+wd8)H0/ ~z)~kʱ^'cD]]vg>%Op8k9Z|u?*N{vp(ljhyHs-BAhOēE^#]/i{pnceZB'hg%cX= eI+ۯl.5 M y_[IHJСj9PILcmY(f]iKv*tX@SzJJŠ(((((((((((@u82&\KhRlW(ǶoVHS ޼j)(ʖ)BcHcL_$i4ۋ ZA'¢n](}XPxΥdyg7'Y~ȏr5 m[N`d1Ɛ=,-%)BB: JM Adm Zcs>e{D%8e-n|xP]T0T ҷBQm+)ң HkZRBF#6Ϸb)oGV1݅gNzW6_'$rJAR>*9{*JaU-?sÊp)A'n|i, mvI'-o 4;JI$"J0A-qdTx)XI_ PA`\:a qX֧r:VݟJrYY$*mdБHصӒ_}n氲Y.7mÂO+rpAP:"W/GlI&挆F`HWQOemCy!T8>g]Fv1;2yӳҷwc8 ?U.'੽{@v%[Eb\UThN2889Ⱦ6|kU<(!ZK-6$a zsU՚!2Hjr=CuYFD= f\N̸p) EPEPEPEPEPEPE`BxkR*8+*D6=j7AC3g!2c5~W9nn44Mtgש%EIY'$WX.}O9m4CI8EʕruK3) oZۀqk7%Āmx5:wWUnVg8(r9ax\my@)HʉS? vэhE;'>3Lk(nr3|2X;3oJJvjY=PE㎰a$(c\,rz㯗r៣H<"zqI)W$xJr:d^&,8e(cÃJx:'Sc۩ T{\ mj~S~M 2Yy Iǥ.J$mBNRqQNί]!ۻiaŞ\Q4y_lx1}5Jy7E7e!< BF9,*H>R~#?N)=R1]b:_O/_!u=< (jٶ@̹C`LJu8}K^5 6d@6?<~u8{:_딨ֶܐ{<|_Y׶Iml۔>CΣ0 p w|y9jL]!?c:EAm $Ԇ6 ،;:⹶ܞK*mn|>wlbK@acPUI]O55ѰŰTAK;Е CT(=]8IVAϗ[_ܴr1sRqyN]sS=dY3#oҙ:e\rƇ#+I4GPݫCq"U{ܶ+FjJ!eQ'y'"<Ɣ-y= =LvnoBVb%DQ%pYQ>1v&)0ގN$T~|!"O}򑹵8?CJkd\m: <[jm+ڡ/,Qݙj.pB]aRJZP#ӌZCW[u8RW<JOC,ʟcQUŠ((((j=A34Uʘ%, *ڢsH9;c^ݾR樻nb܂')=TGk=n&)xŷCn>'>yF~%+v\uw)rh"Ƙ"6 [#iƟ17d LNAƣ%4(G9'Wmؽ! [_ʀ籞erԭr? h0GRxڄY [WB*6wý;|3¤KC%rʇğBX:ze6 C k' bَL˷>%E ]NxP13qa6hm`$EG9Tŧ[=AjrdCq>x[\çar4҉R7xГA zY{=hRТ((M-CO/wi(mʟ}J@'HNuH;em;ZO:d6.e(<JRn5SI7 cS-zree@mFLA+X$K4_WΥRmv\jD.F@Ry<f J-LWtTͨ/4!65hÁL\ԕxazkّ uHWb0ʂ@+fg"3kBU=ޞ6Zlr%i&Iq+DIy(Ri@2yZY$x8\XlU ;w *@N:V}!9>\G0\m򤞕$X4'P*jY\(Ԯ]iDva(SN:/^C Be|qaӞqY̷[ڲiql8b[AR*M,ASR>8KD8KRixR8[Q)G΀hrɶ[s֏2 ekM!8 |=|t8x>ҐLnm-m c(4cl|\;K_}pǝirO}8Rkt6D*2 dmu=d38Sk3:C.I u)xm2x'Yˡ2^q"||jmVlaھIvT|TMphl}}ezqW wKF7$I3UG~%HzGgVT:[fS2y:$-\xURV_sӦe(m6!#v_ΗKǿK.BP CPPHQhf(QEQEEM~jkx-nKA@'jQ9*7 ZP\uBv+r -Dg&g/Sx4d0PK!N4( *XQ?/ƷǶMq$ }VN~%}i_zqGE+4(P{8q_z*Zc0Dx*d%Em#ge;N=)lqadyvر rCS ',딅ؖ皔V٪<{|fYOľ>FzP.0<*1S*VO(H ZT|yJfpM2h|i8!RHo9!d6tZ*inc % ! 4Ӗs-e*S|jQ[c:QoD%.< -JuiR[uT%%niD _nJҠU*Er#-9:Yk2̧?HVl M>H[x-ڔZ-8p$6pI*FA9V4};IZ+*5 XCTzXK =ۋE%4TG8B4!ʖHRT| r̡[PmԐdSRܗFRۍq֞d 8xD(#p((x[,{Gv)bRG%}sE i#2P'#|<[RkL[@MjMߐPGn@Hl րF-/Q'sA< *K^*Na!e[NIqrPJ~˭N'\]xǁKD(BVi)FF)I7bMAI%0V؎Η%Ϻ-@_jhǴlgr֫qVS ꣒)]?\ki婵EEqt*len+`WJstC̲p80ډPy?}kWkT5# [wz(GiQ!jKMmlgBRRN2Rkںׯ4evZu=|HP <"c%*kP?vR9nDq  =j漜s wYV ǍgTHAET תu=#r]9!)'>'̊tݯWe6/͏^.HyvHe򚔭Гȹt5]=ʘ j$'>[k+.DtRx*O? X !=̣+R82wغ~wj>B;PZlӝ™g9C?B[pen+$qK2n9܀a 4mOz1S<p+&ٽ 6v!9Zs>m1lT(B3Y~qS)H2q[BIZUV~@Oza@ݧ6 xԡ$n1Fie8ItIHVQ!'*^fjh1V< V``I Ѓρ Ww:՘8܅Z2ܓjBY[#w(Q̴͎ 2v9S5 B Uf]x!+ޏ y m;*9)ԥR$-vZ&;FZQp=mR'wKvBu%MmIHHqAPGAH D;N@-T⊈9XдLhS!$AJj&EH OT3a}*U㥋[N$rTb%7WI{r#zT閒A)% <FWN~]g1M_uVݽ3،x8<0|^3FZskMk!=H^K3V#R ;_2.)Tf޿wr~M-thVŪr@V3 \Ai=kIRHٽ,7oJCvhu0ZU[)2d8ru }`Sᵽ?"ԩzdÉq)q* J Q\]@&NDXW2ĖP >e)IE"IQ->E6}YL-pRTGkde;@ tԩ MK$mM% gu)bJ_Q`b_Lᴓ3Rf-j\kgƞlDnO>1#%7AVGJY b"GzB[sn*;`WGZ|w*urK6ȩf. tH(\p&8-EKRM48Nh7mOM(Gf^Auo=)n,`$؉+Zq);Z凾umhɦ["e:VԆI 4 eChqx4BAIq`NQ'򭩀 g A>5TvA#&݌`Z=gU)|0qCK-7PHӅ>ۋAܐ?NOIX ib_*Sd&Cy\qŜ(}I5O]=TkK,VVm NԆ$ee)Hslu]9 i9whZfDgTȸÉ8#.yQxgնIfrB\;ITe=f rq4DÊT fR՟(nQYJJ6 SEH({|+i嬲>7敼[Fbq]U`U:0+%JV:,(՟oiNQU_5{XQJ!K 5獞>! gZ~ ̻N=RN֗;TqPW\\t(mȼFS5~u2TȒvF Q|~im:_9۹$>031үH^tN8-:m[HY(^<|ЂA>5 UygLRa1hžI q_c*t#ٞ2yW"?ګǧz.sg*U؏xyg!(QRW-eI4CH$xTO\x^OZG8&iW^) $t+IHwk"-\I.3nlۇ9hvmR mL&cBTlEY>X/tE< oeH?f#*qLL{K;<(B)fQPnL}~)'xԬbKE>,?+T2|x*R<r695'j >~\%DB\@#D\ GR:V&FIBPu%BWMK[(M`(?JҲ;g<P]jKm);AʾŞ wpGOt:_ش7S)\W<\_t%*7cT6|EM8oS‡?KGD(gm5GÜbbD3`#P"ϫSE`Rxf.մxf}"_ fU0!N1v0`NBJH> Y<_b7ҖH!'ʞ-̦4r DiV|iLWs4jYp|#* 6*|+qMmEN9N<cCjKIM&YwB|+l'Cs|iCiJ[Pzc$6IHܝ܊Rڶ6 c#}(je( 'YZ)'jȬICT29|f"(~ڜ;4 (TrImϛgF><75VL[htxוU韰~fӗ$4ڜjv WKnGWw#ʼ\[H\I>q+J2AyVͧˈqjBG(r)Ŵ#X#-;N=8 ӲTi5ȍ) VqyΝa*!i5G}glӔSnB~UlQ;$kA/8պkƅ-( bm )¬?g?>hgh$c$ݽRLiZerJ (zO+_!a]BIµc\-Tl@T5ݷFԹ>T$rx)<:RʲR_QX]vus$XlZАIQOҮ9ڷWٴE]-}Ed:~g$Z/n]Zm1|svֽ\$AYQ>^Rtl^ɞ/i,z.xޮ?Xh#_BSJM~t]/jӶMָ۬ĉy'TE;7mY(+%--}y򠐢(Njĸg[Kf|~E)в++ޮ"}+g J@yt诧>iH\\ABrFWNUlŲCr,Lˊ2XVج\S'$9|HЧ/E;[PYJ5ύ Zz^HH n8 ('7kk= d P)BrrRsT0#'ZERPJR IX[Mkpx5))8("ZqU"nJI(Q >5إiDd}Qx-·JIN@@挎ƧsRrk`{a/%͎))lciPe)BڕqO.$µ7r$.%*mƱx'JGwr#vTZihq]/"i:Mi mtԶ1, RZ#A$Sc`\bDmlZ_g8j+5˔l[JJd>IAJܟGK۴FiK kDjV mq;QE)pQEQEWIf_ja`KkVΗIL=`=Ķ v6t8J~o6sui*kTÉxOVBM3&rcmQuTFV$򡔤p E{ǣsa+ xնZ!A*#iDyu}D1X 9e`鮤VQG UfBߒ$rxy];-hŤn;?tϒQ;fd2Ѕ6G%c;퟼9Pʒҕ-)愫/a# 3Rv)KB(a{"GbR%<\*ݕwcp< rGN' .gOͻ춀lp6wiدN &K-,GW(OR[G!ϋ7jYJ;ZT>ƻ7-9=9 dh}QhftQEg;_ӷ 7>y7:8J_Eƙ%L_on8!m%u6mc*׋i WvSyQE$! (=1zk_mG#k]Y M~;% sbcy)+Ψzݨ"Lk4rp*T5iǓybͬJ 3N+ݤN2`- qX(rBGHV\J]r2G*'9o@uϪ5ߖ㭝ҫFkt%hVݫnk?!M5Fj$ddc!!hRK7nP+d] %n0҉/I@@*#߳Z7Gڴ,-Rؓ,ߩ$nXFIN+im6gyv=(NQEQE^weZX>Sjp`6ڔֿ2N-NKQ*R$^~[lM꫌{j,]=0O?< h?eׁH%>ȍsWD 8c5qL%I8 BQ 2[`m%ԋM^ؐߥ<(yGkhRMZ/sux% )z9YXD ,HB#mL>e :*Tz_a‡}z*iD+@ÙϩIK +R$4 QtsSF\.-7tG| Ѽ:v gYjKKޕ%_=VHmN+ 5b]|6~nw+2T[jc*{;LWTeQ(?ڹa~GE6xIJ@l <5Т([Rv+%=['gvҜ8Q m BMT&Wim%4R֭{C2ut+ftQEPuNO=l\ɦ3ׁɪu:4izTߠEۓ5B8%M60_JLcv>q8'µF)Žl/Ttj+\ZJk:zԕ($(]N/zv#-X*ᦇz _w"F3-. ՟D(ǁm^uF*  Sj~yJrl=qEKI,Y!R (>x'~X&6$%mLqy z )jD6q4̍i*;z3PڥY*BxU=wRZJCB)V_~5Ƚ4-di=LK킬2F*QԭPdG8YRSV+GQ5 zqew #R0O`x5m:7k!;ўRFswwV- ѳ݃4=իLaGq򜟿eâE3- Q(qRu;L#VD+_/D\)O¤sk{{T|L35j5eO7= Hz m?_ZVk'?1SJd|[OҖ!G5̶/EOĥe@x<h+<+kDmkP!{KJ8V$pd2 m@X"bݧu:, A)&`8>T΁jJOڒk5i{+7i¤o'hc'Ƽ7v KC(8PQ!n}uI ƌP&SD(|5Pryv`gKG)dzVCeYiM)R*I)+m@b@mEi$,`𩄨rRS:Rnʎc2o0qҊK  ֥_SO+JmVtćT7^ymϏ;~me xᩭ42S@c#H7x=MY௹e,:rJ2G'ԚBTE6(r_Z;YƏSQg۵^ 9s/IUyBz8EPX6VcRʸ ]*)S^8exO:lK͙rViԑ,1f4s~y(yPHAB>'?O mɍ(F2@PRTg'9#9\W;%ͱVښ;bÖ}ۖip^R6EiKR[WnŹ̾8[I ?CV]$)Ji_y/Qoѥpt @\/<0= x0Re+^;@~U:sOÏ?*]L&:ۍqyӴYhx 5FHutyQEPuBuZ7i8ɐ3eKJqP7!*ܲ25c=bh+IHc'ܚ#P烊LyPYs϶$*1c͗+g߮A݁>5R$%Sר J̌np3|4rbbҐHFw9qOFE"."A(}I%mAVz$q[M*c尒)ԟ3RXZ}a1B:TMH7f{mN坕&KiRNFv>HVƴb]BUk[]CL⃎pGQY-s\t!Aڣ7wx(5`Y댞 Q81[jhHm)$|<ROmNsDBw3?f6Ղ[O•{ ?_dJOg׶wĶRzvCsn{¬'ʫ[ҜH[M%|(cg?:zV25^}FGZx'Vы,|(7hJ+jo!AgTB>ܽR ^ m qX! gbG3M$pTڏ4I'RƑ;ߣOHXqa+@*GSJ¼:azIHy1n)' S!f¢g eܱo"~֖7Of^#k}V j+ KJQ9>\k;uyJ}I ^'ֽ6f^sr5- k幋`y A`AXQ ,A%Q4* L66iE6jCHRSZ 'S)NNHhၚL͈̺4{[FpGAMA65[a9 SIyjry#,2C֝En~۪T[Vs(T%v>.>7p']ww!4Bvd:EYREKtӒy篦qRkrܧ m_֙3,M9޸[ HB;[-ݝNݹZG]Y;P'%l+%}RkvϥQ4ЄX“3?T}kcxT6R%Y¿~db݊SZ> bmPe9RҒ5ީqԯ,iǯUkY]vofbm+?f%Q>2 *pRj\]mrJDAIaĜ| kծDs>̬z# 4rR FE:mtQ8FN sP8gC 7G5 Zskn4]PP[/6T꒐pMNYtL jX\Wi7ǻUdҝ4;҉WCC_.+8VvC -GKnH ➅>$H}R9K( sS+˗R44CcR>` K{8kDǗ:-a#Ts] %<M(!z>~tmA $4~,08?:Tf܈iݤ[{.ї]Ir%Lm(ežu[ |>C'¼]_n.S]/LyKQ$Օclh|ܵYt z(Ֆn&-aEUf^}H4Nb#SyܯxgOJK!}tX\tX q6Ĩ)۫q:t`ߋw8,Ƨ}uƞ(la>ew8pT|)CUSŕ6?+b<ţȘa +$rM}C$"(DjxNwN{¬0ׁr 3kyJJҬ?:d`қVۮyǼVy)a=a#O!Y+DkHylWBiѴ io)HormOB !bX% <#A>4Oǟ?xfD~}vmR s8PKؔ{fһ_4}tzm&Gk{ k6X&U$46BŃ+˓m?ڕD?pm_-FÝh-˫]m͹RHlj54Wt_Ug2v4 ӥof+31 oەFQ :fK 8 l-ũ–1&&fR`BnkfrPcM]woG Ctf :G`0]8 z]Li ݷAG+W>ķdKݚMl[βgQE@EP(D 2Fˬn_$UymF~!pjmM!hP)RT2=EU}кd]w Rxz֜R]ȿ]$hI!$:V[#(v8;OE^g[&)!hIAFOVUYFfo9-[X<4;JMڞW<`LIbTt<ڐKC()*`<)\V%IIu$O@ZI-dX?d%,̖Wr<{Hv7vABmniXV~,g ^xYxnBOPzW^}#>ҽ'Xb%W0@=@H2>W9mF./tG>EtTR\S:-j$GԒM'z@ \Y!ij-X|I_g 3XghVLcAJ*aŬ*FCݥQNQGrBzvuvt}5EuRܦ$K}[A آۀ<+m5,2ͮhd[oH HoM> $Zؓ8)%'v #±i퐢p<1ɹ fGt =Hd 6oVy m g߳SXP³]444J۟wSѧbHK(!/Oۯ *)$`Λ$[&[yClL"ظ>GΜl7zr0{wF!Hlt8$xF')lik<\vYYvPA#9jg' _J?WBJh-~eS u;cwKjBWR~ԛ]{ӲЅlu!Ήprھ ?J%RgL yp.;*K)Y.+OʐI[Ͳ0Ҷ0 \ɶ\D_qLi$sEkj)L[ 631JtGn·iaTvMx8#۷ȐJ;RmO\.JobGzr@8;.vƉl4!<3ϯO*GtQĂ (5r5GJhe| ;@˪]T @HIYqsEq9GtogSβ(ڐ3'ݝF6wV"Xy `d\3ܥ-1^WۮNd5;% >4?o:LS,]ۗy$g$y9?tʙN-u2:LVsT#$5Wt-[yҮ݇# Y!CNgFeǮQKI;IVcpk8ΰr-7 q<CMUr3->km]RH դo6~3 {'rt ט{~h@h1”S5O@+{mIIqgPL;٫.).~rӀZy8.R0G*3z6>}B=mG]$(I= OFTpp=Wݙ{<‡sc\ta.l3}9J1ೕge{:MvQmcIYY,PXTk8R$I%Vj ( ()f %EC>HBw)w!JxҹH2Y*K;R7㥲?P3#y:ؤ"IOqI+Kr3ޥ PcHr!] UںTbD6'F91!٭Ċtk787\P(`%"<*t-aiRn>$PGUk+a$]?{t#/I'”8-\X;TA||[nOMjUiRkgCmRS|kFVL|ςa&[[%V V s-%ϱ@7 Iӊ IKP-zmzn{MIC6j}+rJRY1  ҀXAXDR·.*A/F`-脔+y%U`Gy2 P;E9ɔw%\i 9HP`e돢⴨s݄g\d-{w_gB̔-@ $>^F4#iq[b2R r0:漦zCsO@W:xʦ]ۭ7/(oHG9A\FZgTUJCL$rdR1V$4Qw3NK>kP%Kv6Hܢ|PH-˦R DasO^FvB3\7krWj [py)oS+p'|)e3A< I#Ӣ$$@ )5M)x>?Ғ8As< m<{7AǗS:؜t֧r,g$JBa1t7d2y u}ik"PB|ӧFw Ͳgp*Kmo{M5m]U7n`JNLZ_[*]KUS'_i8h|/$kA&K>7V:C<y,L]eb Su_]_Hڻ>A#8^p'oRiGte"jHuӴKVxs U@Uv.j+s˒p, ~&,猤f`?qc? *-$kET+qN<e})Zܩb%(<`¾$r9ajܾʂ#HyX|G񮡜sXkqȷ#P}+19!)$IQ8R d^LmKnVZR_?y~^YjVula<5UfPQEQEQEQEQEE{@ͱ- \i%9)?|vNBCTi,)9#Ų޶vo-K ,HGT1ϚzdzUSY~RgհT㐥#1~޲ODä|e5NhI ̈́d;InT)X~XpaMPG֓]-6qƔ*)oqpi"0ܑnw%_j_KJ‘r7&Br1NS$)Q=|k%\gւ 'iĶl26-)*\c<ԅ=/;|ɑ\S_*"jWc)î$Fs_%OxgS"<䒕 @4fyntJWմ=sLR!B_C8-;>Xo1g亅dH 8ql)hJ)M,+(\aNaJqju4ZJAVO\,4s~\_pd'QkKˍIWOҗEr&a{KV6~>_ήOg+]GJhø]&SyN5})Cv=Kcj N|Hǎ m0<>5˩Kb7B֠>in [ԤmzZX0z8Y\Œ4w)9ή9҆#+ |]żO8qZ^Z2 %͊ǁNH!JRyR<1G,wc! |U1!. su~m+mP3Ib) v%LnS|L6.ɞFP_vN|-:x S^ҰHn}Űc'Rn=$ J~]VDY2IbTҶ{@G:dp.;LCY9A'j$\hARx=Q'( R!Br%)G=qE*=?l7v3l* >t؍!)r{)oD7=AtmRs֔)rP j] 9^>^_£՛W2HW>2{sO׊\j{ZV 5mTŇ82xS;֟Ozs46iNnJ_N֓ B-$~X{%! H Ht7l8qQE)hQEQEQEQEQEQEOmr+r >hLѪrT`u yCYhKR`)76m<3.{Ru2NOT?Tvmy0yH'|NS|V„sӈ(sp[hW$<>=<˂tcLK>vnz)#Ӓ#["8?ZCp~KraG!žGԥ$2,  E9˫N, -)s@?mxlXmX+AR@~5%]}Ynu6UCiøȺe>DMGcڊqy\@plg8>gJvY6]Mhq>su-2Vqȫ1ދ?T{~1ϸ0bTܣj,vFJa Jc PS=JJ%RѢ-؀Uy*Q$M9x)!ͩ;N1ύcl8\׳8WO># #;sW7aE߽cG֗i6WƆYkט3 y`aJ;d_XR[d?"38""eko8LGiJK|>$+r|}k].hۮSN XqHP~":}Ex>MΦ).6ۭT?PkIrGi>Suns5C$}K!{ 2T֎IEj)VIIWxH=k)95IR)R$0 M% WJctFa)pgZmϟ@;κܭ* ZYe6a%nʚW{ *G'ңWvJ7KB{\ڌ9hgXCqPEZ(az ˏ3Qcq sVG-;[IޱdZڬu0myQSqTc<򥐞y/e>% -]:׹y[+=y$'\~1ii;K+qȝ%[HWՁ<U)t0i%>_vCoIrch`n_|1h6gj5((Š((((((((uV(XIJHW_\t(膔2¯$Z^!#=I3'bIqh[$ĔqjS]i L]aUjmEUG<㧥_vs2c.q*+8YJ! -ݧO7~8jWDp3 =:><'^'JgTYiڅK{g:tW)̞&>&2n><4ͺΠة%?.8AEۈPKncϧO_[)ZwFGx~P$i N! KW8ȋ1lD8[ΟJ.$[}:*h3MmA$6/B j,cg\zk4$5%-G̊1#B@àr7 \ɋ഻6ia;C_?4 ~t3KumbqE' mԡＰZ.7o.0|OP973Bۿ\X%¤5&c^+O$[ZVf’Ez$rÉ~ }SViܧ\q 0{zQ)ڤOyO2ZYSq#^$%bcug U2[*u]mqn8ًS '%wp`Ԇc.-#T1heN5Wh<ʹIqr i9%wϽtKO\'w(hy}G#^=$+n#oG!Ws PH&fgJJbsX+gG1"13Q2x$!Z@JUslbC/|JB0W(aEPEPEPEPEPEPEPEPEPEPEPEPX]Gć$GMz{:'M}hHXc?5;^/C=ӒWziCGФSœJ ۉrϣ,F# TAzo-! $ wivp8#-{< ڽ֔ƅ}IbPVcκ5w6eK~EjLKE.[.5'ӞYO%s$wc9 ~J'6QfjohBVR,_RiKlF= * ( ( ( ( ( ( (?OpenCSG-1.8.2/doc/img/ogl.gif0000664000175000017500000001461115141675417015437 0ustar florianflorianGIF89aa!!!BBBRRRƽBJRk!9BB!)9J9BZZ{RsRckR1c{1{!kc)99RBRZ{!19Bs1s)kJZc{cJ1JZZc{cks)9JΥss{,a@@pH,Ȥrl:ШtJZ,br^TJE&w>8>U'~ O<(qanbe}/.-5WZ&_/)}jtdk i """16=>>>> :: Ѿ : 1" z/20ǔL 7_}ue* )  [`c !!F.f#>Nat## 4@Yx*p+@Hȍ)2*U4)0#!ajI{:ܻc8z(`."`A4P!A o (E! t| > pc" t0G.A7 ]+@:$}l+*M=k uL0.`Gs|"F>F9og7 (FBl0`$WոO aIz @FfSW0!d'`7+lt`BVbGEi~t%I(xÂ^@.͌ST$KFU8s@a=-t.cxr(:G 1FB   @E@ `B df&VMR%RcjI&-I,\X`\#ޕnp.qF'qKڼjUf8 b}!P6%Ʊq #j== sB],NbǙ| hGKpR{`m.\l.Xd-]t 3xrtAܺBƷfsFR0J:1BҒ( r庌0-.'.A Mq8PEʜƃ\6al6Aa3,@rս5F)~@G5N`4ނ$C ƿPE(o b*xp)#IERYaȱ-h|q>rӣ S%(A xE^tٴn86ORUR(sF(J.1cBy/>/.CzЊ؆չE@t@ FFBR##& Sm iP b)]Y,  AJ>.^$'Et [D%XѕP FNB|.۳Y%7C] G2P0%e!Ext[sy7X'4N\_D|H/p: _`(YXT>vjDWQ"9Q0R aB !804d:*R- = >dYئMK!uJb:5`qXN?k mQ bT &(G0w\ Qe|g goh# R`*k85Ʉ'X&V Q@ŗ iT 4c װƐC3c ~9UUlG( akp 3G 9(3p5a*QyX:U_$C&T9X@mevP;nGiB @h'dbz.0M e*Sq/Fs[E!)tIբ>@'&M q5HP!cX`Nu&Z&70[G|a2p1bah!o;)'pbk,@'xX2CQhcڔIsF R"\, `v pk2 :f ; hv^hta@T2+ ( uc7 `<`; 5 暲"( ɐٜ҉CmoG"7)7qT7Pgw395Vrc\ AQ|6hcuО67#de[10XEyM@$]R;Y7YC[]PEW s0XkX^0z>sth1l`!tTҙE0Y8e^Ӥ'#7YR\]Ui0aP0:Blr) 4,`aBk=:iP$3N+fvx}QJ -b֌ 9oFkgy,v8B:U꧃QFTVpY+' Ԑp e5 r!3 6c` BR}~CԠu?020F4kj-s Ht&"DE\(D!0@IFRF# +o@yF%͊!HR]!Ձ`JWZ=0Lb)kQBA(dt9;*!,TPѹE$ u:0&Jtӑؿч5uH}wH ~`a(ҦN@(eC_ |1~ ӻ&2Xa2 .T7ylŴ*M NY.N$= p`P?B3m{^JrMZ r4rQ;nN$@#` ``!qNS$s;/ ܴ n`1]Y@I!3PP]0  Pu_ U?1Oƕdq D,bWǐQ>ded1k4ƀ,"u 7}%%;:D*&} Q]XЙP9!;2iCvg}: nAjUEw&zēF.<<!Wb4*ЭW-4$44-3u$JR *S `PsHŏ4a 'x>`*FPU Ya:6oG@>8X8+p )Y VU/beZnpk-i:jѠFHTs( 텽L7 ` t. ^5Uˤ~aqQa2Go G6Zjd> *b tjj^*(h0!9;=?z4&RR-XT&Lfj4**c| >kn`Z@*% xttX @@RT:R`d\"n 5nf"L.>2D( @P:tl0#bۇ7ʩ& TLD@Ha„<`}@eQ`B1 4p9S*5 .L0ƍMlMxƳB^}!Ah_O@ d BTXG6vFr78_k,uV4`Ot(# Dfcǎ7ntr8С3yM9!9 Y )ׇ޽ZzǗRx l  PK:ȉr+$n z h$ Q*0 a΀ ui$#r`< D(n68k)E"k09bJ^43Dӌ $m|܎P= Ê!XI1 *D9;XZ¥>9!(H%"Sɭԕ ==UYi[q/;OpenCSG-1.8.2/doc/img/diss.gif0000664000175000017500000002121615141675417015617 0ustar florianflorianGIF89aqlĴ䄦4FDTfdt&$\vtDVT,64씾̴tvtTnlt<Ĭ줾lnl  lLNL|DZ\t\rt\^\$24LJLTjldz|,:<쬾tԤ섚LZ\|drt,24Ĵ\jllz|4:<|l$"$ Tbd쬺TRTm#D|0ӈw|!,q H*\ȰÇ#JH"C.3j!\A"޼\˗0~$E15DO_]F ΄3~ɴ)D. dQ# Sx!Ad=H`ER<<K\^qJ.*40ē r$B.E2񡦚}&0}V9*DL( h i$Lnp✳K+?h)jҹa]DޡF+Z3Ep P$jFKn5lc#ϯE Vbt2x@DB z, ߻r1*bq|j'&@LO5K|$9'C2+TDKH0K,1 F\<ASlJh@0F9QO[}gX_)FGT:䝷p`,R"to2&l`xg&X?LSD,yÕaㄧW}҅q|s;T. -(r>@q Ku2$"@a{"'ș Vt]x!Ӻ6ŜC/ 07)%H AX `i j m X5ؔg;m7xс"l1Cz'Бfzڗ& lIHd$hظAjD` ‚ZP8nB<@9Po̢ F#Ј4C1+jFQ pl y> O* X`A #$ØWQxc`#¡C 9:ZVd!Y=4/AzIB( Q\i\u! / :A| [ag* j29O4n殑22QH4P(dA f%p%P'mx0"  p)n"@aB2Հ sP" -iV ]DO`q >-AJ:Zo~|Y*a `x6 7]`U/wA%и!ccN3}'~UoRE\`hiDaTބu"PԾzoPDBRM+ Q\@;zoB d)P!, 9Ntav$GY p JV`ZLDu alh_"0b#]81c%~:lЍmI*S@ ΂6a))d)7C6jerbr+0<Q$;& V8` wȆ (#HAfuvXZ͐C? S`b1PJ,hC@ ;P#錉qtmIrz&0%tuQI`r,8 "x8X̣3Ղ1\ ixsKP5O4ă(F0t8})OL ,yn$Ƞ4ևKs cZEQs >AfpAw:\Fn^`W`)H+S`l40Xyف)pA0Aavd3tl>O#Z!:6 V,Pк1:)XS̰a PHPQNKu+#c|\~iDFqF 7a1WQu(Bq))\0cǐ=ɕMPБ ʠ$v 5KMih-y:6.A1 E 8;]q.XedAeAn j>W+H&/'YBPC/ 9y\fXhqoFMJkͥrP K"[1~a3"Cv p 3Av a"0qvvd2kf"w\`f{5`t!hKe$q, |$$$bSWA[%w v! V#R"f}̒, { Aq U9 `e#0i=a|n74+i02rC*֣D[v yH%"G)Q7`+st2l]t=)2* `S5=@RU> ') lvׁ"Sh)B&;Fk P +7ām eh5|.   :aSW9fȄ@ez1fv~! 2 \T `RgaOB23a5G%8c0)v_2Fs%&Gvv)R`+xZ9JVtaa^.{"a^}MɀDc2&,as<0O} eA: Tn`;PޑGBz;8dTg F) vơSz)!:+k${m s`c*)Bd=zyhezng (Yikw+X 3N A 0n{ ZPpq zLj)Rs-1HpAcqa:+hޑ0LxjXXFg¡)is*`sR *2cp 03I0ݰ>~p 0 NQTvrYk2j _H {wRJ] 1bg<$75S@r[Q( ebk钿ds鰛 <ubp707bݶ$Ch0§ZikZء~; jOY:ppxSwEk 78 b\o2Sו` e A7u7;`FPN' VP0&1++☃b {l !; p :'SP%Y,12 7`S~Zu{b: [m p`sf ΗG `/`")ۭ%eS Dmy4;;-n #7) ^A ,ۛו]Y3 !100S`s0f`6` 7j`0@R'`ʘhסXkZQ.A`q;;@C[ M`f нz tC*C{;5, o0b 003_[ - 06 !q rPIkXT:z!agf6P0-` ,l0;O$ }"cRR21Ӱݻwp=0! t:-P  0ՀM 0CB#+T\¦u'b& ^fBf0ǠdtlS[E{ [x~Dz Uzg!$ ۡ P -`P X`-0@0ZNPyhQ7p`op7;P l^A`N2- b HC j hY<  U;v,x)u 06K`Ilj LP^PXSw`o,q S @&V{A` @[  ڨ = w 0 0P ` lПݑѿۡ;0n-`n` s0;P⊍9FQb wXuЅf lP=l %~wi $@D&}퉘T2` -^ D⥀X=S ns5.6wpH}0.RND@&*eZܒ~P\ fs - j!/:T p%P R `Pu@  pl@h5꫞y fNK4 0I` u\ @y'S}eS@  bwp "`s"0 `t%} !ЃD 񟤀YHsvɲכIpU-QmMP`KѸ_%  y0RQ!p0R0`DH w D@zs0;DIׅ(K5*lX WN @%`l  n^qypP! Ԯs r@!c6$ - p l(bPJ?p ^PJ 3y)۰gg (#xw@Y+\b'0P~ !&*|:#xv[)Vp.l >!&dSq PB >|8cS&8;)p!HXKX{"1j@NJMI 8xEԁ8CB*8΄ JAK lyEBmݾMx# @rAwZD)>r\~(PAQAETS3. * (QS>Ӭai@"6l` )?o],#HS*!1j 4ӁcG'25LmmL2v&Ѹ ,`8Ҍ|4<"d*"!Hoz0" z8YM;MI-B`B%=_!(Q| Q<[V- Ռ(0f>RiR!1Y E*Є%GE4! A ʴ--P!TG$1 m É+"B&=W-n1%!U-N 0&Em'v(Ft(Q XHr#]$0F F0hH@ liW$CPld`152Yz䍶IrQs& ,.m[[u L-I[ ` ]?$sK!wT9v+%J4/ Ch3aZڄ|@\j#>h,hF<:p8Gr= 8>  H`7g~*oi2gzPx $dЅfŶ'_xm8 a|]u7zNSD`ERA_/3P6 Z= ?]0n+*F܊ | " 8q~ov^.x}\L`.z3gE"QJ/PQ@PEOEL͙ߌM׬ND|Az"]hOA߸X%=q: !R ̢#R>:?r3 d oyo@ꁚPqPjB5*h@ ?!`Y=) #u1.x>`4[+ehP?#R!$.k|iZ8$XB !Ej$(l+x99DĄ'%؜vq)Pm86pJNy x Xex57xY8 jh52ɧPJ D%`B-Ǖk`c5M;y(РBʝ+]b5߿ #Ladt׀qXekԙ3ڶALsbF<bŋ;~,iת۳Bɬ b=NFÉc7m;m;ZS["O0WaiזV7_5681bu5uM]nW ef>XP`k&l6mA~}Wax!qHzιƕ{ hu(fgn,C ᇇvV| wEdJ2)fAs;ΛbH_Z[6h\Y,~1 e^ c d(ģg)SVuR-°z )g] %tRvjlc&+S] l'K|t ݒ/8H}@]3Ռ=5%VtZ0ىpyrɛC.# vlϺw< _~{zk\H |_I Gm6Ygp;_r6 d]7H!cݦāEW8X6*6gk߬R+ЁYX8Ab T*Z*h[򪆠~%IJPs V%;"$ɠf7!dpOtB\75*^W4_7eJ)cͱ1񌐴"0 xy?ytMY 9/KDBf)K2dfԗ|$.F &SmKS*X9"Қؔ6sɓ|-22OI+!8) F-rەfHZ@9IK32hu [a6XP#͊V(>_O}o9"O84l5`5l#/zk h55Jv4-m%щLi| h9ѯl; °UGXIʍP 8JTui=e*_79MM3|.`_Q}泖SaWS/$XSf,h漏akF}ִ a_PÊ4pxD*IcH@[SV  \W >tZw< 9xrIc*k NIhqއV1u7f[_h,[Yh$R5`06BRXW_`AYS&3UC #NűoIem/mpwcR #?86L1rdF$1%x/bAL%>Q2*S>ߨa1Yq.!h:D>$=/ޯci$[Ls_j?Y 59#F5@egMk09pS1tScbD|X \Zf&J2jS!vd#Dc"Èp dv:Уa) Y\֖v!, .A#D>W>f" .L Bp ڠAhtg耮L {m 6W_//)Ɔ x 3HQ6T 5_3c @6toY-Ç G[ vah}y~1jwmpWC'joy46י]יxh6TY٠ X 2Gpr[А4@ppyrB hx wItqfB aȎI ꁝA/^]pbYg`Np[`xp@yFR p(4 /}՘H{;<ч ) dIǙ$ji t#,_D;)xa(* G I?kV` ˀtȔ ?Ј 7pv('"/G ֹ @ɰaQ @d*Hj Dx(Ĉ}u,p;$3Wڤf*@`P- PKP6G U M @JOZ%%}M9zk0-P)؝ڠ 0p\~ٞ1 ;g h %g[d&ૻ\ ڎpڟщ t" r pdx 'r' A;x{ *ۺAJ. _ Ger ψr3H8 yN _p)z4 CR<˙{':7 1yZNpM9[ &y^PJ'ڎ٠$iMuZH{ xap pp><= @K) e9iЦR@[ r4AI \/ [ Уra Iě|[3a1 ޫ` g@[" zA(@M9:Np$ x50vZx0}r) +2|U3!#B3;Y hL08 ڠJچ.  +̘z\ yZ<r ˜qYc3Rq pE[RyoP.f:; x0mL0x dž8'Ѐ !1|{0 '՛ZL66۰v@~ [7oL f: y` +j!7h5ܛ(`H/{v€ 0|ki-rlե'L]b^v4ZB. Г:Ek^`ܫP ܩǎ,`R늁'Hpu",.,%7)̼pc>=``Fa03w}T - ,ɒ8V#`~Q aQeT^mp׉PgdkppʇbJ _S!V^ j7nf $ Nr2. ri<ol _(8#_A ༨Pu_ <_A FO(gja_}{/>,]ԀZZE{` Sf/9hТV?#%xWxa\Mn9^?/P<#e/9=_"%9Q-5Fif W }p ] +8>q,d55@C`@/n?`f*1@@ D$-^ Q<$<~*GDD'YseL1}XNy~rOOZ('XI ʚu`R`F2{lȑnWpn*qcȐSƼTsfǥdZ! ҫU5=t6Nt.X6 Gݿ;|g|yQw)&*@D0t( JC PBj8͠0/D#ѾRn?0@e1F ĬFb"i +z0!Pkp-,+tKN0ƈfF|F1@z\("芄z0 J={3gJ*g9{&Q0p@ OTO(@:`R سTmcKY=0}T 4-mKM^SqLe'RUiP 0CgKmm3qdحXXidv=5R1{k[0ZV.s1"r7^`NnF]jxu, !=U 8`ZDQ2'܌]녝w$06,@Wd/jET0YV.&W}9k0 Q|;cEN,nUh>]9[XNihXT l|Vmdl}è/rbb cGb/1*ю%x4 #Ze;Ґ)E+䋌}2 H5F+پuYAd*AFNqUl(60˰y*3)5Q{l[2*, e1FRlނH}f1LdwUr(7LdxUFBeY3 7N**[[:y 𝥛[dϏV>< ͇ƴM2ӂb27OtMbNc{u0 {:;V[UZѭ~c=Xau7if90 aډ7_@;Ч^ZFww{pÏӽo t fU/#fp: ;OpenCSG-1.8.2/doc/img/columns.gif0000664000175000017500000002336715141675417016346 0ustar florianflorianGIF89axDDhhefXHԈWI:9</ii4*|PPDhsrtɬTRTԤhDxx,yxxxTmLMG쬬*|dTR$\\AfT܍,\\\dfdD(dfggDDxxD\\X9|zt|z丸|ƬVDDDT՘|zdppd=/TVB |~.|~Xq(~ldb@2dbZL|~J|~!yLJLڔ|~fܔl|464pK''FՉnP2^BcQCi'\\ʴSci!TDyχ'\H'7 6H2ӻx ֫ga\8 )Fǀ`YjḛV]FځB a˒lVn9c=`I6mؾl)65H6&5ٰo<P>$\/6SAi 7De:fI2 eԸ\' %Iڮ+GA ,.?B@ڝ|j2ҋoDi(ҁ vJ /ESyk\ne:S"b W!O[F3sbrfL4Ә zSn`izi10 ?X<7 JkD 4C q:OMf! j෿5L8՗#S=%8 pROKxdL X7KP~%c Z9Q:8 d 55H(k=0L-R"w~a>6xF@N*>JTxؑV1}hr$8*yHup<$%02W a"!<0OD jrp Oz%ИB 0@ [@ulJ=@N e1@Ȥ4 CFj|"_F& ȎNf!OrAuDg%-?Ȩ(âMi,7O~L!F% 5@߸ @(Rγ>qǙy^*ؚ1Hs +a¬:j B8tgBZPJaW1a3 D@e<3 eԴ\`qhDpԔ`A'!L HDGn1G :ib 9ۡd&) h@cO2@c&MK *xȫ$* A,xy[J+^Q~).Ѐ #zGp^ԘAT?0D<@_&I[&Fvco12rv UV@6(ZUEV{I~@1@Pa69Nx' +clHЀ9Dai !Z ,XCt6,[+0hɎo~G69#|U }Anr$ CX+E!3U0t 0g0ph& VIuLb=stK K2@4F IIsN\H(B 7S!S)!o B 6FBA(BB60P v5= |054y`1 PK)9P)$W1;.aQ~Z`r!0PvC4 %l S6y464p 2 P B!S320!PKr0* H5@n(ISI# oL5Šb)v UI6q?3zG{@R10p RpVИ!Ӹ3%!Փ )2 rt"56Bg'@!0uadW\~A7;=n2%l22`0Y2R\3h(5@cWh + sq'WَՎ<2z3A#)0GbyX\zu@ؗ?攳c_pA`.rMPquvz5 1`;K1M'lKMa3b(/YN_1n51`FL3*pVyNa54N)r50 -ыv27#/J 2*I5%4C v`nW`Oks*y% 2/H6kc9z_[P*#̡f3Sq)ꠋ\V@Idn6'J@m 5YaM)Q WM$O)M6* " S"I8udTg24h&P.2Ǜ>23|k̚sE X#% )IN0F)q88 Y=!4Pb bu`1a>*l_ys&̿KRJH)a :/ KQ4g50+(G r"Rm0+YJ:@Mr4.|u]wĬHs4 2LOTU2jp9.bPsrtB)i& H&RZ'6$@!=PRC1u,[))MkC |aQr'7Q 0in}⥯ӛ>5RP dhb<@${0}Q4  Q5CS)!ɽd %ilwlvrxYA!LlF"9!㶾b;׶ l8xdџt"!"z Qj( Q) |jn}hn}%hW(}* B"/1ZfDJej1ʗDV蝄Up9| Q3M!Bh=#37-50)u !QPrNWi']f=hYWW-zQ#Wi3Ru zYm50CNWl&>A#*B* c1,HQ!W|Cb4ˁǩH\| }IQP(P+)^_._㡲4{J<"5$A1r.0*kRs!1,4 R~2PU6YR@)@ ?ɜ(iڜ'No ,V7)R`Wg^~6>]Bs&ǜ4'|xxx>| 31UM:>|-RM>u*avj`J%UX[㪍%@ac7tȃ@4u pD0 /8bot؆G2'C;Æ>8u  D9.+\T ~A ~b(\AcfАB(d C||0@c @",G j"f 8 6Pj0k1桦yN`yQAWbQYHpV(2yQ (dsj0C;#["! 6<4ÆN٩`l@ȴ/53 g!e +LGyfX(4e~$.ï gp"yȢA5'v07.Nq><vlңH +|)z`4NȾ$x]`6#e1 |BvCJLec ^hPE6Y"| E"DÅtpA#]y]&b`bj.jRYA^ ͠D{zAg=uݴ`]ToE{D~HG$sI!f-Sbwdy^ARz@EU30p**p9G5dQr9H$$x]kF"y#(o( 5χLl "GP^ހF 5D'0 B`IBU!-I7RoX2Y!,AAqA @4 Ёoو[! IhbWd06ҋqo4_:-4_ p0H(v!#(w</Rӑ##UrËQ D|ፆ&>±BrL @' \b̏ƐR!hP@thTj|HWKx-ӟJOb5Hs)0رPxNiYy֓MVGD!+[W(p5)j1-E[1|^kaQLH51 jF& FJN{w4(g:!\j?9ВsB2b%Thoiy)S.VƬ)?V P.f%X+Tq{؜5*F~0DZS)<ʼnzXvj1])BМ[)TF Z _ۭ^Sjf@;^=% It)C: k@b9-RPK̊8>2FCHiNh #R ɽLT/SḧދP>UsQ6COVt=vkcLp2  A{ H@fkP?b 4h`dLCxC'':Q 72a. @P0pz*PX3p @,bq9+UI b+)R28 vtԜxP8њ!ΖBWb ?(cیV ZeCy<Beo4t عXP/aQN!VptEHz*fp-qB8lK{Z6'7-v/ B˄YC a~Wn.ԁԨDsy ^B'ʦ)@B ly(IThE/_ˮ&Ig(SOC+w 'b5k leެ n S,9BZk=\Jخ";+-ɧnς#a +!!G"uqua[ AK1tX?0+`و ڈB*R/]z!À#I XpBZ&> h;0rC ^i?ZC:fhh ! 4N12˃@.SJbcȃ[;3+p$+0Gh|!ڈB0x5k()p )j pt(:- `7 R\cVtFsna@d/͢Ɖѡ.ᫀgJ5D3o†AzA1m40&HϋClؐ85к<1)`Z^IsB`{.dLI":>ry)$AA0s\ CX6PC! PE#2tfhRx1J*+G ! wb :y:7F:k >h#^r8)! ! ෰t)G0pÕ14qOb!A<7| t z+r')[HɲdxA) >ly8t]q@騃P2, a 2ҺRh XB97hJqB zsK UTqI)`8ѐ dAu$B(fH۠\r4@ ̩(%)*Iߣ;ѩ̲@L?~ؤ$"P)ȻA3R<[ܦ( ۀ;OpenCSG-1.8.2/doc/news.html0000664000175000017500000004227015141675417015257 0ustar florianflorian OpenCSG - News
    OpenCSG logo

    OpenCSG - News

    Back to main page        		OpenGL logo

    08-Feb-2026: OpenCSG 1.8.2 release with rendering fixes for Linux with Nouveau driver

    The new release fixes a z-fighting bug in the SCS algorithm, that was known for a long time, under Linux with Nouveau graphics driver. You can get the new release here

    09-Mar-2025: OpenCSG 1.8.1 bugfix release

    The new GLSL vertex shader call did not yet work correctly with OpenGL versions 2.0 and 2.1. This was because an OpenCSG internal fragment shader had an OpenGL 3.0 requirement. This bug has been fixed in the new release OpenCSG 1.8.1.

    02-Mar-2025: Better support for GLSL with new release

    The new release OpenCSG 1.8.0 contains a number of changes to avoid z-artifacts. Most importantly, it is now possible to provide a GLSL vertex shader to OpenCSG. If a compatible shader is also used in the calling application to process the geometry, this can avoid z-artifacts that happened with older versions.

    The new release also provides minor performance improvements in the SCS algorithm, by reducing the number of rendered primitives using shorter permutation embedding sequences. And for building on non-Windows platforms, it has switched from the old qmake-based makefiles to CMake.

    18-Jan-2025: Improved support for the camera inside of the geometry with OpenCSG 1.7.0

    A well-known problem with OpenCSG, and image based CSG rendering in general, is the problem that rendering errors usually happen if the camera is inside of the geometry. The new release OpenCSG 1.7.0 provides improvements for this case. In particular, for the Goldfeather algorithm all such cases are now handled correctly.

    15-Sep-2023: OpenCSG 1.6.0 released

    The release OpenCSG 1.6.0 is now available. The main change is that for initialization of OpenGL function pointers and extensions, Glad is now used instead of the previous GLEW. This should improve portability - on Linux this removes the implicit dependency on GLX, that existed before - and at the same time should also simplify maintenance.

    For the offscreen buffer implementation, the historic pbuffer code has been removed, and only frame buffer objects are supported now.

    20-Apr-2022: OpenCSG 1.5.1 released

    OpenCSG 1.5.1 fixes a compile error in version 1.5.0 that happened with the more recent GCC versions 11 and 12.

    10-Apr-2022: OpenCSG 1.5.0 released

    The release OpenCSG 1.5.0 provides the promised license change to the GPL version 2 or newer.

    The release also contains a small API cleanup. The obsolete render() function taking three arguments has been removed. All rendering options must now be set via the setOption() function.

    28-Mar-2022: License change to GPL version 2 or newer

    I was recently informed by one of the maintainers of OpenSCAD that the current license (GPL version 2 only) of OpenCSG poses a problem for OpenSCAD, which links against some other libraries that are licensed under GPL version 3 only. In order to solve this issue, I plan to release a new version of OpenCSG soon, that can be used under the GPL version 2 or newer.

    18-Sep-2017: OpenCSG on github

    I've uploaded the OpenCSG git repository to github.

    29-Sep-2016: OpenCSG 1.4.2 released

    OpenCSG 1.4.2 fixes an issue when the calling application renders into different frame buffer objects subsequently and uses OpenCSG. In this case, when called for the second time with the second FBO active, OpenCSG did not restore that FBO, but the first FBO that was active for a previous call of OpenCSG. This caused, for example, issues in applications rendering into a QOpenGLWidget with Qt 5, such as OpenSCAD. When resizing the OpenGL window, the problem occured, and the OpenGL window was not rendered at all anymore.

    11-Sep-2016: OpenCSG 1.4.1 released

    On Intel graphics hardware, the new rendering path in the SCS algorithm in OpenCSG 1.4.0 entirely failed to work. This was apparently due to an incompatibility of the fragment program with the fixed function pipeline used at the vertex stage. OpenCSG 1.4.1 implements a workaround: a vertex program is now used instead. I hope that the rendering bugs on Intel graphics hardware are now really a thing of the past.

    15-Sep-2014: OpenCSG 1.4.0 released

    OpenCSG 1.4.0 contains a bug fix for rendering CSG expressions with more than 255 primitives. For the layered Goldfeather algorithm, this number of primitives could cause an endless loop before. In the case of the SCS algorithm, there were rendering errors with older versions.

    For the SCS algorithm, the fix contains a new rendering path: using a fragment program, a kind of alpha test is performed based on all the components (r, g, b, a) of a fragment. This allows, in theory, to distinguish 2^32 - 1 primitives instead of 2^8 - 1 before. This new rendering path should be, in theory, also more stable than the old one, and some rendering problems reported for Intel graphics hardware might be solved with the new version.

    11-May-2014: OpenCSG 1.3.3 released

    OpenCSG 1.3.3 is a maintenance release, providing minor portability improvements and bug fixes. In particular, OpenCSG should now compile out-of-the-box on Linux x64 systems.

    02-Dec-2011: OpenCSG 1.3.2 released

    OpenCSG 1.3.2 is a maintenance release. It contains fixes for a number of errors when setting up frame buffer objects or PBuffers with unusual combinations of available OpenGL extensions. Furthermore, the calling application may now render into a frame buffer object when calling OpenCSG. This failed with former versions because OpenCSG did not switch back to the original frame buffer object. The release also contains a couple of compilation fixes for MacOS X.

    09-Jun-2010: OpenCSG 1.3.1 released

    OpenCSG 1.3.1 was mainly released for a slight change of the license: The GPL license contains a special linking exception for the CGAL library now. This means that you are now allowed to link OpenCSG with CGAL and ship the binaries, as long as you follow the requirements of the GPLv2 in regard to all of the software in the executable aside from CGAL.

    Aside from some dead code removed, there were no source code changes in this release.

    07-Feb-2010: OpenCSG 1.3.0 with support for MDI applications

    OpenCSG 1.3.0 implements better support for applications having an multiple document interface and, therefore, use OpenCSG in different OpenGL windows. If the contexts of these windows are not shared, older versions of OpenCSG render incorrectly, because internally allocated PBuffers resp. frame buffer objects, that are not reallocated for each frame, are not valid in the different OpenGL contexts.

    To solve this, new functions for setting/getting an OpenCSG context have been added. OpenGL resources are created and reused by the render() function per context. By setting a different OpenCSG context for each OpenGL window before using OpenCSG, CSG rendering is performed correctly.

    03-Jan-2010: OpenCSG 1.2.0 released

    OpenCSG 1.2.0 contains fixes for CSG rendering using the frame buffer object extension. In particular, it adds support for the ARB variant of this extension (before, only the EXT variant was supported).

    Since the new version now uses frame buffer objects as default, in contrast to the pbuffer code path in former versions, there is the potential possibility that the pbuffer path might work ok, but the (now default) frame buffer object path would fail. In that case, try to set the OffscreenSetting to PBuffer using setOption().

    OpenCSG 1.2.0 also contains a small API cleanup. Whilst the old render() function taking three arguments is still provided for backward compatibility, there is a new render() function that only takes the list of primitives to render as argument. The other two arguments setting some rendering options are now consistently expected to be set using the setOption() interface.

    19-Jul-2009: OpenCSG 1.1.1 released

    OpenCSG 1.1.1 is a maintenance release. Issues in the makefiles for Linux and portability problems for 64-bit Linux have been resolved. Additionally, a performance problem was fixed in the case of lots of CSG primitives (several 10000s) with standard bounding boxes. Rendering this is slow anyways, but before, the rendering time was dominated by the computation time for generating the batches of primitives. This was, without bounding boxes, wasted time, because the batches are trivial anyways.

    03-Dec-2006: OpenCSG 1.1.0 with Frame Buffer Object Support

    The most significant addition in OpenCSG-1.1.0 is the support of OpenGL frame buffer objects. This change also led to the option setter and getter functions to control this and all other rendering options. Additionally several bugs have been fixed, for example in the heuristics that choses the offscreen buffer size and rendering errors that occured on some low-end graphics hardware.

    03-Jul-2005: FREENIX 2005 Paper on OpenCSG

    Since some time, the paper is available for download at directly from USENIX (which requires a USENIX account for some time), or here, where also my talk can be downloaded.

    18-Dec-2004: To appear: FREENIX 2005 Paper on OpenCSG

    I am going to present the paper OpenCSG: A Library for Image-Based CSG Rendering on the FREENIX Track of the USENIX Annual Technical Conference 2005 in Anaheim, Californien. This paper contains a short description of the Goldfeather and the SCS algorithm. It then explains how (and why so) the API of OpenCSG was designed, outlines the basic implementation and problems encountered during the implementation. Finally it describes some examples of its use.

    04-Dec-2004: OpenCSG version 1.0.2 released

    OpenCSG-1.0.2 provides a workspace for the free, gcc-based Dev-C++ 5 compiler for Windows. Additionally it fixes two bugs, one in the RenderTexture library, and one bug in the heuristic for choosing the CSG rendering algorithm, which caused that, under circumstances, a non-optimal rendering algorithm was used.

    27-Sep-2004: OpenCSG version 1.0.1 released

    OpenCSG-1.0.1 contains the following changes:

    The settings of the OpenGL scissor test are now respected (Former versions just ignored the settings of the scissor test.). For certain cases, this can lead to a substantial performance gain. Note that this change could, potentially, cause compatibility problems in the unlikely case that your application uses the scissor test when invoking CSG rendering, but actually does not want scissoring to be active for CSG rendering. The bug fix for this case is just to disable scissoring.

    Besides, OpenCSG now uses the new RenderTexture version 2 that has superseded the older version. As before, I had to apply some minor patches to RenderTexture for correct functionality under Linux.

    The interface of OpenCSG has remained unchanged.

    I have also updated some sections on the web and added a short FAQ section.

    02-May-2004: OpenCSG version 1.0.0 released

    OpenCSG-1.0.0 contains lots of improvements and additions:

    • The makefile system for Linux now compiles a shared library. The makefiles have been derived by auto-generated makefiles from qmake, but of course, qmake (or Qt) is not required to compile OpenCSG.
    • Version 1.0.0 contains lots of further performance improvements in case the bounding-box for shapes is set. This includes a performance bug fix, i.e., formerly scissoring was set to non-optimal values. Also, calculating the depth complexity now also considers the bounding box values.
    • If available, the GL_TEXTURE_RECTANGLE_NV texture format is now used even in case of power-of-two textures, because this format appears to be generally faster.

    The interface of OpenCSG has remained unchanged.

    02-Mar-2004: OpenCSG version 0.9.2 released

    OpenCSG-0.9.2 brings some improvements compared to former versions. First, for occlusion queries the newer OpenGL-extension GL_ARB_occlusion_query is now supported along with the former GL_NV_occlusion_query extension. Second, OpenCSG comes with GLEW version 1.2.0 now.

    Compared to former versions of OpenCSG, no external interfaces have been changed, so your applications using OpenCSG should just continue to work with OpenCSG 0.9.2.

    04-Feb-2004: Paper on rendering techniques in OpenCSG

    I have presented the paper Rendering Techniques for Hardware-Accelerated Image-Based CSG on the WSCG 2004 conference. This paper describes the method that OpenCSG uses to transfer the depth information in the temporary z-buffer into the main z-buffer using render-to-texture. The paper describes also how occlusion queries can be used to speed up image-based CSG rendering.

    You can download my talk already; The paper will be available online as soon as it is published online by the WSCG.

    22-Nov-2003: OpenCSG version 0.9.1 released

    OpenCSG-0.9.1 contains a number of improvements and bug fixes. New features include the ability to work also with the non-standard clockwise front-face setting and performance improvements in the case of constantly changing viewport sizes due to fewer resizes of the internal pbuffer.

    Upgrading from version 0.9 to 0.9.1 should be no problem, as the external interface (and even the hidden internal interfaces) have not changed.

    30-Sep-2003: OpenCSG version 0.9 initial release

    OpenCSG-0.9.

    © 2002-2026, Florian Kirsch, e-mail: mail at opencsg dot org,
    2002-2005 Hasso-Plattner-Institute Potsdam.
    Last change: 08-Feb-2026