From a2ddf3dfe066bb4e58de1d11b1800efcd05fb3a0 Mon Sep 17 00:00:00 2001 From: Sean Harmer Date: Sun, 27 Jan 2013 15:53:13 +0000 Subject: Add a new static lib and module for OpenGL extensions MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The complete set of OpenGL extensions is large meaning that any attempt to incorporate them into a shared library such as QtGui would bloat the size of that library. The typical usage pattern for OpenGL extensions is to use only a very small number of extensions from the total available set. A static library suits this situation very well as an application will only compile in the executable code for the extensions actually used. Thus makign all of the functionality available to those that need it but with zero cost to those that do not. Change-Id: I49fdac7e9d2e0b190b7ea04b776018dd63c3065f Reviewed-by: Samuel Rødal --- src/openglextensions/qopenglextensions.cpp | 7713 ++++++++++++++++++++++++++++ 1 file changed, 7713 insertions(+) create mode 100644 src/openglextensions/qopenglextensions.cpp (limited to 'src/openglextensions/qopenglextensions.cpp') diff --git a/src/openglextensions/qopenglextensions.cpp b/src/openglextensions/qopenglextensions.cpp new file mode 100644 index 0000000000..2119a86ccf --- /dev/null +++ b/src/openglextensions/qopenglextensions.cpp @@ -0,0 +1,7713 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB) +** Contact: http://www.qt-project.org/legal +** +** This file is part of the QtGui module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +** +** This file was generated by glgen version 0.1 +** Command line was: glgen +** +** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB) +** +** This is an auto-generated file. +** Do not edit! All changes made to it will be lost. +** +****************************************************************************/ + +#include "qopenglextensions.h" +#include + +QT_BEGIN_NAMESPACE + +QAbstractOpenGLExtension::~QAbstractOpenGLExtension() +{ + if (d_ptr) + delete d_ptr; +} + +bool QAbstractOpenGLExtension::initializeOpenGLFunctions() +{ + Q_D(QAbstractOpenGLExtension); + d->initialized = true; + return true; +} + +bool QAbstractOpenGLExtension::isInitialized() const +{ + Q_D(const QAbstractOpenGLExtension); + return d->initialized; +} + +#if !defined(QT_OPENGL_ES_2) + +QOpenGLExtension_3DFX_tbuffer::QOpenGLExtension_3DFX_tbuffer() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_3DFX_tbufferPrivate)) +{ +} + +bool QOpenGLExtension_3DFX_tbuffer::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_3DFX_tbuffer); + + d->TbufferMask3DFX = reinterpret_cast(context->getProcAddress("glTbufferMask3DFX")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_AMD_debug_output::QOpenGLExtension_AMD_debug_output() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_AMD_debug_outputPrivate)) +{ +} + +bool QOpenGLExtension_AMD_debug_output::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_AMD_debug_output); + + d->GetDebugMessageLogAMD = reinterpret_cast(context->getProcAddress("glGetDebugMessageLogAMD")); + d->DebugMessageCallbackAMD = reinterpret_cast(context->getProcAddress("glDebugMessageCallbackAMD")); + d->DebugMessageInsertAMD = reinterpret_cast(context->getProcAddress("glDebugMessageInsertAMD")); + d->DebugMessageEnableAMD = reinterpret_cast(context->getProcAddress("glDebugMessageEnableAMD")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_AMD_draw_buffers_blend::QOpenGLExtension_AMD_draw_buffers_blend() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_AMD_draw_buffers_blendPrivate)) +{ +} + +bool QOpenGLExtension_AMD_draw_buffers_blend::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_AMD_draw_buffers_blend); + + d->BlendEquationSeparateIndexedAMD = reinterpret_cast(context->getProcAddress("glBlendEquationSeparateIndexedAMD")); + d->BlendEquationIndexedAMD = reinterpret_cast(context->getProcAddress("glBlendEquationIndexedAMD")); + d->BlendFuncSeparateIndexedAMD = reinterpret_cast(context->getProcAddress("glBlendFuncSeparateIndexedAMD")); + d->BlendFuncIndexedAMD = reinterpret_cast(context->getProcAddress("glBlendFuncIndexedAMD")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_AMD_multi_draw_indirect::QOpenGLExtension_AMD_multi_draw_indirect() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_AMD_multi_draw_indirectPrivate)) +{ +} + +bool QOpenGLExtension_AMD_multi_draw_indirect::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_AMD_multi_draw_indirect); + + d->MultiDrawElementsIndirectAMD = reinterpret_cast(context->getProcAddress("glMultiDrawElementsIndirectAMD")); + d->MultiDrawArraysIndirectAMD = reinterpret_cast(context->getProcAddress("glMultiDrawArraysIndirectAMD")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_AMD_name_gen_delete::QOpenGLExtension_AMD_name_gen_delete() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_AMD_name_gen_deletePrivate)) +{ +} + +bool QOpenGLExtension_AMD_name_gen_delete::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_AMD_name_gen_delete); + + d->IsNameAMD = reinterpret_cast(context->getProcAddress("glIsNameAMD")); + d->DeleteNamesAMD = reinterpret_cast(context->getProcAddress("glDeleteNamesAMD")); + d->GenNamesAMD = reinterpret_cast(context->getProcAddress("glGenNamesAMD")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_AMD_performance_monitor::QOpenGLExtension_AMD_performance_monitor() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_AMD_performance_monitorPrivate)) +{ +} + +bool QOpenGLExtension_AMD_performance_monitor::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_AMD_performance_monitor); + + d->GetPerfMonitorCounterDataAMD = reinterpret_cast(context->getProcAddress("glGetPerfMonitorCounterDataAMD")); + d->EndPerfMonitorAMD = reinterpret_cast(context->getProcAddress("glEndPerfMonitorAMD")); + d->BeginPerfMonitorAMD = reinterpret_cast(context->getProcAddress("glBeginPerfMonitorAMD")); + d->SelectPerfMonitorCountersAMD = reinterpret_cast(context->getProcAddress("glSelectPerfMonitorCountersAMD")); + d->DeletePerfMonitorsAMD = reinterpret_cast(context->getProcAddress("glDeletePerfMonitorsAMD")); + d->GenPerfMonitorsAMD = reinterpret_cast(context->getProcAddress("glGenPerfMonitorsAMD")); + d->GetPerfMonitorCounterInfoAMD = reinterpret_cast(context->getProcAddress("glGetPerfMonitorCounterInfoAMD")); + d->GetPerfMonitorCounterStringAMD = reinterpret_cast(context->getProcAddress("glGetPerfMonitorCounterStringAMD")); + d->GetPerfMonitorGroupStringAMD = reinterpret_cast(context->getProcAddress("glGetPerfMonitorGroupStringAMD")); + d->GetPerfMonitorCountersAMD = reinterpret_cast(context->getProcAddress("glGetPerfMonitorCountersAMD")); + d->GetPerfMonitorGroupsAMD = reinterpret_cast(context->getProcAddress("glGetPerfMonitorGroupsAMD")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_AMD_sample_positions::QOpenGLExtension_AMD_sample_positions() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_AMD_sample_positionsPrivate)) +{ +} + +bool QOpenGLExtension_AMD_sample_positions::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_AMD_sample_positions); + + d->SetMultisamplefvAMD = reinterpret_cast(context->getProcAddress("glSetMultisamplefvAMD")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_AMD_sparse_texture::QOpenGLExtension_AMD_sparse_texture() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_AMD_sparse_texturePrivate)) +{ +} + +bool QOpenGLExtension_AMD_sparse_texture::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_AMD_sparse_texture); + + d->TexStorageSparseAMD = reinterpret_cast(context->getProcAddress("glTexStorageSparseAMD")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_AMD_stencil_operation_extended::QOpenGLExtension_AMD_stencil_operation_extended() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_AMD_stencil_operation_extendedPrivate)) +{ +} + +bool QOpenGLExtension_AMD_stencil_operation_extended::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_AMD_stencil_operation_extended); + + d->StencilOpValueAMD = reinterpret_cast(context->getProcAddress("glStencilOpValueAMD")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_AMD_vertex_shader_tesselator::QOpenGLExtension_AMD_vertex_shader_tesselator() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_AMD_vertex_shader_tesselatorPrivate)) +{ +} + +bool QOpenGLExtension_AMD_vertex_shader_tesselator::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_AMD_vertex_shader_tesselator); + + d->TessellationModeAMD = reinterpret_cast(context->getProcAddress("glTessellationModeAMD")); + d->TessellationFactorAMD = reinterpret_cast(context->getProcAddress("glTessellationFactorAMD")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_APPLE_element_array::QOpenGLExtension_APPLE_element_array() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_APPLE_element_arrayPrivate)) +{ +} + +bool QOpenGLExtension_APPLE_element_array::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_APPLE_element_array); + + d->MultiDrawRangeElementArrayAPPLE = reinterpret_cast(context->getProcAddress("glMultiDrawRangeElementArrayAPPLE")); + d->MultiDrawElementArrayAPPLE = reinterpret_cast(context->getProcAddress("glMultiDrawElementArrayAPPLE")); + d->DrawRangeElementArrayAPPLE = reinterpret_cast(context->getProcAddress("glDrawRangeElementArrayAPPLE")); + d->DrawElementArrayAPPLE = reinterpret_cast(context->getProcAddress("glDrawElementArrayAPPLE")); + d->ElementPointerAPPLE = reinterpret_cast(context->getProcAddress("glElementPointerAPPLE")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_APPLE_fence::QOpenGLExtension_APPLE_fence() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_APPLE_fencePrivate)) +{ +} + +bool QOpenGLExtension_APPLE_fence::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_APPLE_fence); + + d->FinishObjectAPPLE = reinterpret_cast(context->getProcAddress("glFinishObjectAPPLE")); + d->TestObjectAPPLE = reinterpret_cast(context->getProcAddress("glTestObjectAPPLE")); + d->FinishFenceAPPLE = reinterpret_cast(context->getProcAddress("glFinishFenceAPPLE")); + d->TestFenceAPPLE = reinterpret_cast(context->getProcAddress("glTestFenceAPPLE")); + d->IsFenceAPPLE = reinterpret_cast(context->getProcAddress("glIsFenceAPPLE")); + d->SetFenceAPPLE = reinterpret_cast(context->getProcAddress("glSetFenceAPPLE")); + d->DeleteFencesAPPLE = reinterpret_cast(context->getProcAddress("glDeleteFencesAPPLE")); + d->GenFencesAPPLE = reinterpret_cast(context->getProcAddress("glGenFencesAPPLE")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_APPLE_flush_buffer_range::QOpenGLExtension_APPLE_flush_buffer_range() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_APPLE_flush_buffer_rangePrivate)) +{ +} + +bool QOpenGLExtension_APPLE_flush_buffer_range::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_APPLE_flush_buffer_range); + + d->FlushMappedBufferRangeAPPLE = reinterpret_cast(context->getProcAddress("glFlushMappedBufferRangeAPPLE")); + d->BufferParameteriAPPLE = reinterpret_cast(context->getProcAddress("glBufferParameteriAPPLE")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_APPLE_object_purgeable::QOpenGLExtension_APPLE_object_purgeable() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_APPLE_object_purgeablePrivate)) +{ +} + +bool QOpenGLExtension_APPLE_object_purgeable::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_APPLE_object_purgeable); + + d->GetObjectParameterivAPPLE = reinterpret_cast(context->getProcAddress("glGetObjectParameterivAPPLE")); + d->ObjectUnpurgeableAPPLE = reinterpret_cast(context->getProcAddress("glObjectUnpurgeableAPPLE")); + d->ObjectPurgeableAPPLE = reinterpret_cast(context->getProcAddress("glObjectPurgeableAPPLE")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_APPLE_texture_range::QOpenGLExtension_APPLE_texture_range() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_APPLE_texture_rangePrivate)) +{ +} + +bool QOpenGLExtension_APPLE_texture_range::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_APPLE_texture_range); + + d->GetTexParameterPointervAPPLE = reinterpret_cast(context->getProcAddress("glGetTexParameterPointervAPPLE")); + d->TextureRangeAPPLE = reinterpret_cast(context->getProcAddress("glTextureRangeAPPLE")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_APPLE_vertex_array_object::QOpenGLExtension_APPLE_vertex_array_object() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_APPLE_vertex_array_objectPrivate)) +{ +} + +bool QOpenGLExtension_APPLE_vertex_array_object::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_APPLE_vertex_array_object); + + d->IsVertexArrayAPPLE = reinterpret_cast(context->getProcAddress("glIsVertexArrayAPPLE")); + d->GenVertexArraysAPPLE = reinterpret_cast(context->getProcAddress("glGenVertexArraysAPPLE")); + d->DeleteVertexArraysAPPLE = reinterpret_cast(context->getProcAddress("glDeleteVertexArraysAPPLE")); + d->BindVertexArrayAPPLE = reinterpret_cast(context->getProcAddress("glBindVertexArrayAPPLE")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_APPLE_vertex_array_range::QOpenGLExtension_APPLE_vertex_array_range() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_APPLE_vertex_array_rangePrivate)) +{ +} + +bool QOpenGLExtension_APPLE_vertex_array_range::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_APPLE_vertex_array_range); + + d->VertexArrayParameteriAPPLE = reinterpret_cast(context->getProcAddress("glVertexArrayParameteriAPPLE")); + d->FlushVertexArrayRangeAPPLE = reinterpret_cast(context->getProcAddress("glFlushVertexArrayRangeAPPLE")); + d->VertexArrayRangeAPPLE = reinterpret_cast(context->getProcAddress("glVertexArrayRangeAPPLE")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_APPLE_vertex_program_evaluators::QOpenGLExtension_APPLE_vertex_program_evaluators() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_APPLE_vertex_program_evaluatorsPrivate)) +{ +} + +bool QOpenGLExtension_APPLE_vertex_program_evaluators::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_APPLE_vertex_program_evaluators); + + d->MapVertexAttrib2fAPPLE = reinterpret_cast(context->getProcAddress("glMapVertexAttrib2fAPPLE")); + d->MapVertexAttrib2dAPPLE = reinterpret_cast(context->getProcAddress("glMapVertexAttrib2dAPPLE")); + d->MapVertexAttrib1fAPPLE = reinterpret_cast(context->getProcAddress("glMapVertexAttrib1fAPPLE")); + d->MapVertexAttrib1dAPPLE = reinterpret_cast(context->getProcAddress("glMapVertexAttrib1dAPPLE")); + d->IsVertexAttribEnabledAPPLE = reinterpret_cast(context->getProcAddress("glIsVertexAttribEnabledAPPLE")); + d->DisableVertexAttribAPPLE = reinterpret_cast(context->getProcAddress("glDisableVertexAttribAPPLE")); + d->EnableVertexAttribAPPLE = reinterpret_cast(context->getProcAddress("glEnableVertexAttribAPPLE")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_ES2_compatibility::QOpenGLExtension_ARB_ES2_compatibility() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_ES2_compatibilityPrivate)) +{ +} + +bool QOpenGLExtension_ARB_ES2_compatibility::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_ES2_compatibility); + + d->ClearDepthf = reinterpret_cast(context->getProcAddress("glClearDepthf")); + d->DepthRangef = reinterpret_cast(context->getProcAddress("glDepthRangef")); + d->GetShaderPrecisionFormat = reinterpret_cast(context->getProcAddress("glGetShaderPrecisionFormat")); + d->ShaderBinary = reinterpret_cast(context->getProcAddress("glShaderBinary")); + d->ReleaseShaderCompiler = reinterpret_cast(context->getProcAddress("glReleaseShaderCompiler")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_base_instance::QOpenGLExtension_ARB_base_instance() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_base_instancePrivate)) +{ +} + +bool QOpenGLExtension_ARB_base_instance::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_base_instance); + + d->DrawElementsInstancedBaseVertexBaseInstance = reinterpret_cast(context->getProcAddress("glDrawElementsInstancedBaseVertexBaseInstance")); + d->DrawElementsInstancedBaseInstance = reinterpret_cast(context->getProcAddress("glDrawElementsInstancedBaseInstance")); + d->DrawArraysInstancedBaseInstance = reinterpret_cast(context->getProcAddress("glDrawArraysInstancedBaseInstance")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_blend_func_extended::QOpenGLExtension_ARB_blend_func_extended() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_blend_func_extendedPrivate)) +{ +} + +bool QOpenGLExtension_ARB_blend_func_extended::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_blend_func_extended); + + d->GetFragDataIndex = reinterpret_cast(context->getProcAddress("glGetFragDataIndex")); + d->BindFragDataLocationIndexed = reinterpret_cast(context->getProcAddress("glBindFragDataLocationIndexed")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_cl_event::QOpenGLExtension_ARB_cl_event() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_cl_eventPrivate)) +{ +} + +bool QOpenGLExtension_ARB_cl_event::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_cl_event); + + d->CreateSyncFromCLeventARB = reinterpret_cast(context->getProcAddress("glCreateSyncFromCLeventARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_clear_buffer_object::QOpenGLExtension_ARB_clear_buffer_object() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_clear_buffer_objectPrivate)) +{ +} + +bool QOpenGLExtension_ARB_clear_buffer_object::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_clear_buffer_object); + + d->ClearBufferSubData = reinterpret_cast(context->getProcAddress("glClearBufferSubData")); + d->ClearBufferData = reinterpret_cast(context->getProcAddress("glClearBufferData")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_color_buffer_float::QOpenGLExtension_ARB_color_buffer_float() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_color_buffer_floatPrivate)) +{ +} + +bool QOpenGLExtension_ARB_color_buffer_float::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_color_buffer_float); + + d->ClampColorARB = reinterpret_cast(context->getProcAddress("glClampColorARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_compute_shader::QOpenGLExtension_ARB_compute_shader() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_compute_shaderPrivate)) +{ +} + +bool QOpenGLExtension_ARB_compute_shader::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_compute_shader); + + d->DispatchComputeIndirect = reinterpret_cast(context->getProcAddress("glDispatchComputeIndirect")); + d->DispatchCompute = reinterpret_cast(context->getProcAddress("glDispatchCompute")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_copy_buffer::QOpenGLExtension_ARB_copy_buffer() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_copy_bufferPrivate)) +{ +} + +bool QOpenGLExtension_ARB_copy_buffer::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_copy_buffer); + + d->CopyBufferSubData = reinterpret_cast(context->getProcAddress("glCopyBufferSubData")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_copy_image::QOpenGLExtension_ARB_copy_image() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_copy_imagePrivate)) +{ +} + +bool QOpenGLExtension_ARB_copy_image::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_copy_image); + + d->CopyImageSubData = reinterpret_cast(context->getProcAddress("glCopyImageSubData")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_debug_output::QOpenGLExtension_ARB_debug_output() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_debug_outputPrivate)) +{ +} + +bool QOpenGLExtension_ARB_debug_output::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_debug_output); + + d->GetDebugMessageLogARB = reinterpret_cast(context->getProcAddress("glGetDebugMessageLogARB")); + d->DebugMessageCallbackARB = reinterpret_cast(context->getProcAddress("glDebugMessageCallbackARB")); + d->DebugMessageInsertARB = reinterpret_cast(context->getProcAddress("glDebugMessageInsertARB")); + d->DebugMessageControlARB = reinterpret_cast(context->getProcAddress("glDebugMessageControlARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_draw_buffers::QOpenGLExtension_ARB_draw_buffers() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_draw_buffersPrivate)) +{ +} + +bool QOpenGLExtension_ARB_draw_buffers::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_draw_buffers); + + d->DrawBuffersARB = reinterpret_cast(context->getProcAddress("glDrawBuffersARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_draw_buffers_blend::QOpenGLExtension_ARB_draw_buffers_blend() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_draw_buffers_blendPrivate)) +{ +} + +bool QOpenGLExtension_ARB_draw_buffers_blend::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_draw_buffers_blend); + + d->BlendFuncSeparateiARB = reinterpret_cast(context->getProcAddress("glBlendFuncSeparateiARB")); + d->BlendFunciARB = reinterpret_cast(context->getProcAddress("glBlendFunciARB")); + d->BlendEquationSeparateiARB = reinterpret_cast(context->getProcAddress("glBlendEquationSeparateiARB")); + d->BlendEquationiARB = reinterpret_cast(context->getProcAddress("glBlendEquationiARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_draw_elements_base_vertex::QOpenGLExtension_ARB_draw_elements_base_vertex() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_draw_elements_base_vertexPrivate)) +{ +} + +bool QOpenGLExtension_ARB_draw_elements_base_vertex::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_draw_elements_base_vertex); + + d->MultiDrawElementsBaseVertex = reinterpret_cast(context->getProcAddress("glMultiDrawElementsBaseVertex")); + d->DrawElementsInstancedBaseVertex = reinterpret_cast(context->getProcAddress("glDrawElementsInstancedBaseVertex")); + d->DrawRangeElementsBaseVertex = reinterpret_cast(context->getProcAddress("glDrawRangeElementsBaseVertex")); + d->DrawElementsBaseVertex = reinterpret_cast(context->getProcAddress("glDrawElementsBaseVertex")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_draw_indirect::QOpenGLExtension_ARB_draw_indirect() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_draw_indirectPrivate)) +{ +} + +bool QOpenGLExtension_ARB_draw_indirect::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_draw_indirect); + + d->DrawElementsIndirect = reinterpret_cast(context->getProcAddress("glDrawElementsIndirect")); + d->DrawArraysIndirect = reinterpret_cast(context->getProcAddress("glDrawArraysIndirect")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_draw_instanced::QOpenGLExtension_ARB_draw_instanced() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_draw_instancedPrivate)) +{ +} + +bool QOpenGLExtension_ARB_draw_instanced::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_draw_instanced); + + d->DrawElementsInstancedARB = reinterpret_cast(context->getProcAddress("glDrawElementsInstancedARB")); + d->DrawArraysInstancedARB = reinterpret_cast(context->getProcAddress("glDrawArraysInstancedARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_framebuffer_no_attachments::QOpenGLExtension_ARB_framebuffer_no_attachments() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_framebuffer_no_attachmentsPrivate)) +{ +} + +bool QOpenGLExtension_ARB_framebuffer_no_attachments::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_framebuffer_no_attachments); + + d->GetFramebufferParameteriv = reinterpret_cast(context->getProcAddress("glGetFramebufferParameteriv")); + d->FramebufferParameteri = reinterpret_cast(context->getProcAddress("glFramebufferParameteri")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_framebuffer_object::QOpenGLExtension_ARB_framebuffer_object() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_framebuffer_objectPrivate)) +{ +} + +bool QOpenGLExtension_ARB_framebuffer_object::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_framebuffer_object); + + d->FramebufferTextureLayer = reinterpret_cast(context->getProcAddress("glFramebufferTextureLayer")); + d->RenderbufferStorageMultisample = reinterpret_cast(context->getProcAddress("glRenderbufferStorageMultisample")); + d->BlitFramebuffer = reinterpret_cast(context->getProcAddress("glBlitFramebuffer")); + d->GenerateMipmap = reinterpret_cast(context->getProcAddress("glGenerateMipmap")); + d->GetFramebufferAttachmentParameteriv = reinterpret_cast(context->getProcAddress("glGetFramebufferAttachmentParameteriv")); + d->FramebufferRenderbuffer = reinterpret_cast(context->getProcAddress("glFramebufferRenderbuffer")); + d->FramebufferTexture3D = reinterpret_cast(context->getProcAddress("glFramebufferTexture3D")); + d->FramebufferTexture2D = reinterpret_cast(context->getProcAddress("glFramebufferTexture2D")); + d->FramebufferTexture1D = reinterpret_cast(context->getProcAddress("glFramebufferTexture1D")); + d->CheckFramebufferStatus = reinterpret_cast(context->getProcAddress("glCheckFramebufferStatus")); + d->GenFramebuffers = reinterpret_cast(context->getProcAddress("glGenFramebuffers")); + d->DeleteFramebuffers = reinterpret_cast(context->getProcAddress("glDeleteFramebuffers")); + d->BindFramebuffer = reinterpret_cast(context->getProcAddress("glBindFramebuffer")); + d->IsFramebuffer = reinterpret_cast(context->getProcAddress("glIsFramebuffer")); + d->GetRenderbufferParameteriv = reinterpret_cast(context->getProcAddress("glGetRenderbufferParameteriv")); + d->RenderbufferStorage = reinterpret_cast(context->getProcAddress("glRenderbufferStorage")); + d->GenRenderbuffers = reinterpret_cast(context->getProcAddress("glGenRenderbuffers")); + d->DeleteRenderbuffers = reinterpret_cast(context->getProcAddress("glDeleteRenderbuffers")); + d->BindRenderbuffer = reinterpret_cast(context->getProcAddress("glBindRenderbuffer")); + d->IsRenderbuffer = reinterpret_cast(context->getProcAddress("glIsRenderbuffer")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_geometry_shader4::QOpenGLExtension_ARB_geometry_shader4() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_geometry_shader4Private)) +{ +} + +bool QOpenGLExtension_ARB_geometry_shader4::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_geometry_shader4); + + d->FramebufferTextureFaceARB = reinterpret_cast(context->getProcAddress("glFramebufferTextureFaceARB")); + d->FramebufferTextureLayerARB = reinterpret_cast(context->getProcAddress("glFramebufferTextureLayerARB")); + d->FramebufferTextureARB = reinterpret_cast(context->getProcAddress("glFramebufferTextureARB")); + d->ProgramParameteriARB = reinterpret_cast(context->getProcAddress("glProgramParameteriARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_get_program_binary::QOpenGLExtension_ARB_get_program_binary() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_get_program_binaryPrivate)) +{ +} + +bool QOpenGLExtension_ARB_get_program_binary::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_get_program_binary); + + d->ProgramParameteri = reinterpret_cast(context->getProcAddress("glProgramParameteri")); + d->ProgramBinary = reinterpret_cast(context->getProcAddress("glProgramBinary")); + d->GetProgramBinary = reinterpret_cast(context->getProcAddress("glGetProgramBinary")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_gpu_shader_fp64::QOpenGLExtension_ARB_gpu_shader_fp64() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_gpu_shader_fp64Private)) +{ +} + +bool QOpenGLExtension_ARB_gpu_shader_fp64::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_gpu_shader_fp64); + + d->GetUniformdv = reinterpret_cast(context->getProcAddress("glGetUniformdv")); + d->UniformMatrix4x3dv = reinterpret_cast(context->getProcAddress("glUniformMatrix4x3dv")); + d->UniformMatrix4x2dv = reinterpret_cast(context->getProcAddress("glUniformMatrix4x2dv")); + d->UniformMatrix3x4dv = reinterpret_cast(context->getProcAddress("glUniformMatrix3x4dv")); + d->UniformMatrix3x2dv = reinterpret_cast(context->getProcAddress("glUniformMatrix3x2dv")); + d->UniformMatrix2x4dv = reinterpret_cast(context->getProcAddress("glUniformMatrix2x4dv")); + d->UniformMatrix2x3dv = reinterpret_cast(context->getProcAddress("glUniformMatrix2x3dv")); + d->UniformMatrix4dv = reinterpret_cast(context->getProcAddress("glUniformMatrix4dv")); + d->UniformMatrix3dv = reinterpret_cast(context->getProcAddress("glUniformMatrix3dv")); + d->UniformMatrix2dv = reinterpret_cast(context->getProcAddress("glUniformMatrix2dv")); + d->Uniform4dv = reinterpret_cast(context->getProcAddress("glUniform4dv")); + d->Uniform3dv = reinterpret_cast(context->getProcAddress("glUniform3dv")); + d->Uniform2dv = reinterpret_cast(context->getProcAddress("glUniform2dv")); + d->Uniform1dv = reinterpret_cast(context->getProcAddress("glUniform1dv")); + d->Uniform4d = reinterpret_cast(context->getProcAddress("glUniform4d")); + d->Uniform3d = reinterpret_cast(context->getProcAddress("glUniform3d")); + d->Uniform2d = reinterpret_cast(context->getProcAddress("glUniform2d")); + d->Uniform1d = reinterpret_cast(context->getProcAddress("glUniform1d")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_instanced_arrays::QOpenGLExtension_ARB_instanced_arrays() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_instanced_arraysPrivate)) +{ +} + +bool QOpenGLExtension_ARB_instanced_arrays::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_instanced_arrays); + + d->VertexAttribDivisorARB = reinterpret_cast(context->getProcAddress("glVertexAttribDivisorARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_internalformat_query::QOpenGLExtension_ARB_internalformat_query() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_internalformat_queryPrivate)) +{ +} + +bool QOpenGLExtension_ARB_internalformat_query::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_internalformat_query); + + d->GetInternalformativ = reinterpret_cast(context->getProcAddress("glGetInternalformativ")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_internalformat_query2::QOpenGLExtension_ARB_internalformat_query2() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_internalformat_query2Private)) +{ +} + +bool QOpenGLExtension_ARB_internalformat_query2::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_internalformat_query2); + + d->GetInternalformati64v = reinterpret_cast(context->getProcAddress("glGetInternalformati64v")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_invalidate_subdata::QOpenGLExtension_ARB_invalidate_subdata() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_invalidate_subdataPrivate)) +{ +} + +bool QOpenGLExtension_ARB_invalidate_subdata::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_invalidate_subdata); + + d->InvalidateSubFramebuffer = reinterpret_cast(context->getProcAddress("glInvalidateSubFramebuffer")); + d->InvalidateFramebuffer = reinterpret_cast(context->getProcAddress("glInvalidateFramebuffer")); + d->InvalidateBufferData = reinterpret_cast(context->getProcAddress("glInvalidateBufferData")); + d->InvalidateBufferSubData = reinterpret_cast(context->getProcAddress("glInvalidateBufferSubData")); + d->InvalidateTexImage = reinterpret_cast(context->getProcAddress("glInvalidateTexImage")); + d->InvalidateTexSubImage = reinterpret_cast(context->getProcAddress("glInvalidateTexSubImage")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_map_buffer_range::QOpenGLExtension_ARB_map_buffer_range() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_map_buffer_rangePrivate)) +{ +} + +bool QOpenGLExtension_ARB_map_buffer_range::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_map_buffer_range); + + d->FlushMappedBufferRange = reinterpret_cast(context->getProcAddress("glFlushMappedBufferRange")); + d->MapBufferRange = reinterpret_cast(context->getProcAddress("glMapBufferRange")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_matrix_palette::QOpenGLExtension_ARB_matrix_palette() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_matrix_palettePrivate)) +{ +} + +bool QOpenGLExtension_ARB_matrix_palette::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_matrix_palette); + + d->MatrixIndexPointerARB = reinterpret_cast(context->getProcAddress("glMatrixIndexPointerARB")); + d->MatrixIndexuivARB = reinterpret_cast(context->getProcAddress("glMatrixIndexuivARB")); + d->MatrixIndexusvARB = reinterpret_cast(context->getProcAddress("glMatrixIndexusvARB")); + d->MatrixIndexubvARB = reinterpret_cast(context->getProcAddress("glMatrixIndexubvARB")); + d->CurrentPaletteMatrixARB = reinterpret_cast(context->getProcAddress("glCurrentPaletteMatrixARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_multi_draw_indirect::QOpenGLExtension_ARB_multi_draw_indirect() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_multi_draw_indirectPrivate)) +{ +} + +bool QOpenGLExtension_ARB_multi_draw_indirect::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_multi_draw_indirect); + + d->MultiDrawElementsIndirect = reinterpret_cast(context->getProcAddress("glMultiDrawElementsIndirect")); + d->MultiDrawArraysIndirect = reinterpret_cast(context->getProcAddress("glMultiDrawArraysIndirect")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_multisample::QOpenGLExtension_ARB_multisample() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_multisamplePrivate)) +{ +} + +bool QOpenGLExtension_ARB_multisample::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_multisample); + + d->SampleCoverageARB = reinterpret_cast(context->getProcAddress("glSampleCoverageARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_multitexture::QOpenGLExtension_ARB_multitexture() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_multitexturePrivate)) +{ +} + +bool QOpenGLExtension_ARB_multitexture::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_multitexture); + + d->MultiTexCoord4svARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord4svARB")); + d->MultiTexCoord4sARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord4sARB")); + d->MultiTexCoord4ivARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord4ivARB")); + d->MultiTexCoord4iARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord4iARB")); + d->MultiTexCoord4fvARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord4fvARB")); + d->MultiTexCoord4fARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord4fARB")); + d->MultiTexCoord4dvARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord4dvARB")); + d->MultiTexCoord4dARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord4dARB")); + d->MultiTexCoord3svARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord3svARB")); + d->MultiTexCoord3sARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord3sARB")); + d->MultiTexCoord3ivARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord3ivARB")); + d->MultiTexCoord3iARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord3iARB")); + d->MultiTexCoord3fvARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord3fvARB")); + d->MultiTexCoord3fARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord3fARB")); + d->MultiTexCoord3dvARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord3dvARB")); + d->MultiTexCoord3dARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord3dARB")); + d->MultiTexCoord2svARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord2svARB")); + d->MultiTexCoord2sARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord2sARB")); + d->MultiTexCoord2ivARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord2ivARB")); + d->MultiTexCoord2iARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord2iARB")); + d->MultiTexCoord2fvARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord2fvARB")); + d->MultiTexCoord2fARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord2fARB")); + d->MultiTexCoord2dvARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord2dvARB")); + d->MultiTexCoord2dARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord2dARB")); + d->MultiTexCoord1svARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord1svARB")); + d->MultiTexCoord1sARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord1sARB")); + d->MultiTexCoord1ivARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord1ivARB")); + d->MultiTexCoord1iARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord1iARB")); + d->MultiTexCoord1fvARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord1fvARB")); + d->MultiTexCoord1fARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord1fARB")); + d->MultiTexCoord1dvARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord1dvARB")); + d->MultiTexCoord1dARB = reinterpret_cast(context->getProcAddress("glMultiTexCoord1dARB")); + d->ClientActiveTextureARB = reinterpret_cast(context->getProcAddress("glClientActiveTextureARB")); + d->ActiveTextureARB = reinterpret_cast(context->getProcAddress("glActiveTextureARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_occlusion_query::QOpenGLExtension_ARB_occlusion_query() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_occlusion_queryPrivate)) +{ +} + +bool QOpenGLExtension_ARB_occlusion_query::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_occlusion_query); + + d->GetQueryObjectuivARB = reinterpret_cast(context->getProcAddress("glGetQueryObjectuivARB")); + d->GetQueryObjectivARB = reinterpret_cast(context->getProcAddress("glGetQueryObjectivARB")); + d->GetQueryivARB = reinterpret_cast(context->getProcAddress("glGetQueryivARB")); + d->EndQueryARB = reinterpret_cast(context->getProcAddress("glEndQueryARB")); + d->BeginQueryARB = reinterpret_cast(context->getProcAddress("glBeginQueryARB")); + d->IsQueryARB = reinterpret_cast(context->getProcAddress("glIsQueryARB")); + d->DeleteQueriesARB = reinterpret_cast(context->getProcAddress("glDeleteQueriesARB")); + d->GenQueriesARB = reinterpret_cast(context->getProcAddress("glGenQueriesARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_point_parameters::QOpenGLExtension_ARB_point_parameters() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_point_parametersPrivate)) +{ +} + +bool QOpenGLExtension_ARB_point_parameters::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_point_parameters); + + d->PointParameterfvARB = reinterpret_cast(context->getProcAddress("glPointParameterfvARB")); + d->PointParameterfARB = reinterpret_cast(context->getProcAddress("glPointParameterfARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_program_interface_query::QOpenGLExtension_ARB_program_interface_query() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_program_interface_queryPrivate)) +{ +} + +bool QOpenGLExtension_ARB_program_interface_query::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_program_interface_query); + + d->GetProgramResourceLocationIndex = reinterpret_cast(context->getProcAddress("glGetProgramResourceLocationIndex")); + d->GetProgramResourceLocation = reinterpret_cast(context->getProcAddress("glGetProgramResourceLocation")); + d->GetProgramResourceiv = reinterpret_cast(context->getProcAddress("glGetProgramResourceiv")); + d->GetProgramResourceName = reinterpret_cast(context->getProcAddress("glGetProgramResourceName")); + d->GetProgramResourceIndex = reinterpret_cast(context->getProcAddress("glGetProgramResourceIndex")); + d->GetProgramInterfaceiv = reinterpret_cast(context->getProcAddress("glGetProgramInterfaceiv")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_provoking_vertex::QOpenGLExtension_ARB_provoking_vertex() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_provoking_vertexPrivate)) +{ +} + +bool QOpenGLExtension_ARB_provoking_vertex::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_provoking_vertex); + + d->ProvokingVertex = reinterpret_cast(context->getProcAddress("glProvokingVertex")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_robustness::QOpenGLExtension_ARB_robustness() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_robustnessPrivate)) +{ +} + +bool QOpenGLExtension_ARB_robustness::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_robustness); + + d->GetnUniformdvARB = reinterpret_cast(context->getProcAddress("glGetnUniformdvARB")); + d->GetnUniformuivARB = reinterpret_cast(context->getProcAddress("glGetnUniformuivARB")); + d->GetnUniformivARB = reinterpret_cast(context->getProcAddress("glGetnUniformivARB")); + d->GetnUniformfvARB = reinterpret_cast(context->getProcAddress("glGetnUniformfvARB")); + d->GetnCompressedTexImageARB = reinterpret_cast(context->getProcAddress("glGetnCompressedTexImageARB")); + d->ReadnPixelsARB = reinterpret_cast(context->getProcAddress("glReadnPixelsARB")); + d->GetnTexImageARB = reinterpret_cast(context->getProcAddress("glGetnTexImageARB")); + d->GetnMinmaxARB = reinterpret_cast(context->getProcAddress("glGetnMinmaxARB")); + d->GetnHistogramARB = reinterpret_cast(context->getProcAddress("glGetnHistogramARB")); + d->GetnSeparableFilterARB = reinterpret_cast(context->getProcAddress("glGetnSeparableFilterARB")); + d->GetnConvolutionFilterARB = reinterpret_cast(context->getProcAddress("glGetnConvolutionFilterARB")); + d->GetnColorTableARB = reinterpret_cast(context->getProcAddress("glGetnColorTableARB")); + d->GetnPolygonStippleARB = reinterpret_cast(context->getProcAddress("glGetnPolygonStippleARB")); + d->GetnPixelMapusvARB = reinterpret_cast(context->getProcAddress("glGetnPixelMapusvARB")); + d->GetnPixelMapuivARB = reinterpret_cast(context->getProcAddress("glGetnPixelMapuivARB")); + d->GetnPixelMapfvARB = reinterpret_cast(context->getProcAddress("glGetnPixelMapfvARB")); + d->GetnMapivARB = reinterpret_cast(context->getProcAddress("glGetnMapivARB")); + d->GetnMapfvARB = reinterpret_cast(context->getProcAddress("glGetnMapfvARB")); + d->GetnMapdvARB = reinterpret_cast(context->getProcAddress("glGetnMapdvARB")); + d->GetGraphicsResetStatusARB = reinterpret_cast(context->getProcAddress("glGetGraphicsResetStatusARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_sample_shading::QOpenGLExtension_ARB_sample_shading() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_sample_shadingPrivate)) +{ +} + +bool QOpenGLExtension_ARB_sample_shading::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_sample_shading); + + d->MinSampleShadingARB = reinterpret_cast(context->getProcAddress("glMinSampleShadingARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_sampler_objects::QOpenGLExtension_ARB_sampler_objects() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_sampler_objectsPrivate)) +{ +} + +bool QOpenGLExtension_ARB_sampler_objects::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_sampler_objects); + + d->GetSamplerParameterIuiv = reinterpret_cast(context->getProcAddress("glGetSamplerParameterIuiv")); + d->GetSamplerParameterfv = reinterpret_cast(context->getProcAddress("glGetSamplerParameterfv")); + d->GetSamplerParameterIiv = reinterpret_cast(context->getProcAddress("glGetSamplerParameterIiv")); + d->GetSamplerParameteriv = reinterpret_cast(context->getProcAddress("glGetSamplerParameteriv")); + d->SamplerParameterIuiv = reinterpret_cast(context->getProcAddress("glSamplerParameterIuiv")); + d->SamplerParameterIiv = reinterpret_cast(context->getProcAddress("glSamplerParameterIiv")); + d->SamplerParameterfv = reinterpret_cast(context->getProcAddress("glSamplerParameterfv")); + d->SamplerParameterf = reinterpret_cast(context->getProcAddress("glSamplerParameterf")); + d->SamplerParameteriv = reinterpret_cast(context->getProcAddress("glSamplerParameteriv")); + d->SamplerParameteri = reinterpret_cast(context->getProcAddress("glSamplerParameteri")); + d->BindSampler = reinterpret_cast(context->getProcAddress("glBindSampler")); + d->IsSampler = reinterpret_cast(context->getProcAddress("glIsSampler")); + d->DeleteSamplers = reinterpret_cast(context->getProcAddress("glDeleteSamplers")); + d->GenSamplers = reinterpret_cast(context->getProcAddress("glGenSamplers")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_separate_shader_objects::QOpenGLExtension_ARB_separate_shader_objects() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_separate_shader_objectsPrivate)) +{ +} + +bool QOpenGLExtension_ARB_separate_shader_objects::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_separate_shader_objects); + + d->GetProgramPipelineInfoLog = reinterpret_cast(context->getProcAddress("glGetProgramPipelineInfoLog")); + d->ValidateProgramPipeline = reinterpret_cast(context->getProcAddress("glValidateProgramPipeline")); + d->ProgramUniformMatrix4x3dv = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix4x3dv")); + d->ProgramUniformMatrix3x4dv = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix3x4dv")); + d->ProgramUniformMatrix4x2dv = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix4x2dv")); + d->ProgramUniformMatrix2x4dv = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix2x4dv")); + d->ProgramUniformMatrix3x2dv = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix3x2dv")); + d->ProgramUniformMatrix2x3dv = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix2x3dv")); + d->ProgramUniformMatrix4x3fv = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix4x3fv")); + d->ProgramUniformMatrix3x4fv = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix3x4fv")); + d->ProgramUniformMatrix4x2fv = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix4x2fv")); + d->ProgramUniformMatrix2x4fv = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix2x4fv")); + d->ProgramUniformMatrix3x2fv = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix3x2fv")); + d->ProgramUniformMatrix2x3fv = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix2x3fv")); + d->ProgramUniformMatrix4dv = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix4dv")); + d->ProgramUniformMatrix3dv = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix3dv")); + d->ProgramUniformMatrix2dv = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix2dv")); + d->ProgramUniformMatrix4fv = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix4fv")); + d->ProgramUniformMatrix3fv = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix3fv")); + d->ProgramUniformMatrix2fv = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix2fv")); + d->ProgramUniform4uiv = reinterpret_cast(context->getProcAddress("glProgramUniform4uiv")); + d->ProgramUniform4ui = reinterpret_cast(context->getProcAddress("glProgramUniform4ui")); + d->ProgramUniform4dv = reinterpret_cast(context->getProcAddress("glProgramUniform4dv")); + d->ProgramUniform4d = reinterpret_cast(context->getProcAddress("glProgramUniform4d")); + d->ProgramUniform4fv = reinterpret_cast(context->getProcAddress("glProgramUniform4fv")); + d->ProgramUniform4f = reinterpret_cast(context->getProcAddress("glProgramUniform4f")); + d->ProgramUniform4iv = reinterpret_cast(context->getProcAddress("glProgramUniform4iv")); + d->ProgramUniform4i = reinterpret_cast(context->getProcAddress("glProgramUniform4i")); + d->ProgramUniform3uiv = reinterpret_cast(context->getProcAddress("glProgramUniform3uiv")); + d->ProgramUniform3ui = reinterpret_cast(context->getProcAddress("glProgramUniform3ui")); + d->ProgramUniform3dv = reinterpret_cast(context->getProcAddress("glProgramUniform3dv")); + d->ProgramUniform3d = reinterpret_cast(context->getProcAddress("glProgramUniform3d")); + d->ProgramUniform3fv = reinterpret_cast(context->getProcAddress("glProgramUniform3fv")); + d->ProgramUniform3f = reinterpret_cast(context->getProcAddress("glProgramUniform3f")); + d->ProgramUniform3iv = reinterpret_cast(context->getProcAddress("glProgramUniform3iv")); + d->ProgramUniform3i = reinterpret_cast(context->getProcAddress("glProgramUniform3i")); + d->ProgramUniform2uiv = reinterpret_cast(context->getProcAddress("glProgramUniform2uiv")); + d->ProgramUniform2ui = reinterpret_cast(context->getProcAddress("glProgramUniform2ui")); + d->ProgramUniform2dv = reinterpret_cast(context->getProcAddress("glProgramUniform2dv")); + d->ProgramUniform2d = reinterpret_cast(context->getProcAddress("glProgramUniform2d")); + d->ProgramUniform2fv = reinterpret_cast(context->getProcAddress("glProgramUniform2fv")); + d->ProgramUniform2f = reinterpret_cast(context->getProcAddress("glProgramUniform2f")); + d->ProgramUniform2iv = reinterpret_cast(context->getProcAddress("glProgramUniform2iv")); + d->ProgramUniform2i = reinterpret_cast(context->getProcAddress("glProgramUniform2i")); + d->ProgramUniform1uiv = reinterpret_cast(context->getProcAddress("glProgramUniform1uiv")); + d->ProgramUniform1ui = reinterpret_cast(context->getProcAddress("glProgramUniform1ui")); + d->ProgramUniform1dv = reinterpret_cast(context->getProcAddress("glProgramUniform1dv")); + d->ProgramUniform1d = reinterpret_cast(context->getProcAddress("glProgramUniform1d")); + d->ProgramUniform1fv = reinterpret_cast(context->getProcAddress("glProgramUniform1fv")); + d->ProgramUniform1f = reinterpret_cast(context->getProcAddress("glProgramUniform1f")); + d->ProgramUniform1iv = reinterpret_cast(context->getProcAddress("glProgramUniform1iv")); + d->ProgramUniform1i = reinterpret_cast(context->getProcAddress("glProgramUniform1i")); + d->GetProgramPipelineiv = reinterpret_cast(context->getProcAddress("glGetProgramPipelineiv")); + d->IsProgramPipeline = reinterpret_cast(context->getProcAddress("glIsProgramPipeline")); + d->GenProgramPipelines = reinterpret_cast(context->getProcAddress("glGenProgramPipelines")); + d->DeleteProgramPipelines = reinterpret_cast(context->getProcAddress("glDeleteProgramPipelines")); + d->BindProgramPipeline = reinterpret_cast(context->getProcAddress("glBindProgramPipeline")); + d->CreateShaderProgramv = reinterpret_cast(context->getProcAddress("glCreateShaderProgramv")); + d->ActiveShaderProgram = reinterpret_cast(context->getProcAddress("glActiveShaderProgram")); + d->UseProgramStages = reinterpret_cast(context->getProcAddress("glUseProgramStages")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_shader_atomic_counters::QOpenGLExtension_ARB_shader_atomic_counters() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_shader_atomic_countersPrivate)) +{ +} + +bool QOpenGLExtension_ARB_shader_atomic_counters::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_shader_atomic_counters); + + d->GetActiveAtomicCounterBufferiv = reinterpret_cast(context->getProcAddress("glGetActiveAtomicCounterBufferiv")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_shader_image_load_store::QOpenGLExtension_ARB_shader_image_load_store() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_shader_image_load_storePrivate)) +{ +} + +bool QOpenGLExtension_ARB_shader_image_load_store::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_shader_image_load_store); + + d->MemoryBarrier = reinterpret_cast(context->getProcAddress("glMemoryBarrier")); + d->BindImageTexture = reinterpret_cast(context->getProcAddress("glBindImageTexture")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_shader_objects::QOpenGLExtension_ARB_shader_objects() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_shader_objectsPrivate)) +{ +} + +bool QOpenGLExtension_ARB_shader_objects::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_shader_objects); + + d->GetShaderSourceARB = reinterpret_cast(context->getProcAddress("glGetShaderSourceARB")); + d->GetUniformivARB = reinterpret_cast(context->getProcAddress("glGetUniformivARB")); + d->GetUniformfvARB = reinterpret_cast(context->getProcAddress("glGetUniformfvARB")); + d->GetActiveUniformARB = reinterpret_cast(context->getProcAddress("glGetActiveUniformARB")); + d->GetUniformLocationARB = reinterpret_cast(context->getProcAddress("glGetUniformLocationARB")); + d->GetAttachedObjectsARB = reinterpret_cast(context->getProcAddress("glGetAttachedObjectsARB")); + d->GetInfoLogARB = reinterpret_cast(context->getProcAddress("glGetInfoLogARB")); + d->GetObjectParameterivARB = reinterpret_cast(context->getProcAddress("glGetObjectParameterivARB")); + d->GetObjectParameterfvARB = reinterpret_cast(context->getProcAddress("glGetObjectParameterfvARB")); + d->UniformMatrix4fvARB = reinterpret_cast(context->getProcAddress("glUniformMatrix4fvARB")); + d->UniformMatrix3fvARB = reinterpret_cast(context->getProcAddress("glUniformMatrix3fvARB")); + d->UniformMatrix2fvARB = reinterpret_cast(context->getProcAddress("glUniformMatrix2fvARB")); + d->Uniform4ivARB = reinterpret_cast(context->getProcAddress("glUniform4ivARB")); + d->Uniform3ivARB = reinterpret_cast(context->getProcAddress("glUniform3ivARB")); + d->Uniform2ivARB = reinterpret_cast(context->getProcAddress("glUniform2ivARB")); + d->Uniform1ivARB = reinterpret_cast(context->getProcAddress("glUniform1ivARB")); + d->Uniform4fvARB = reinterpret_cast(context->getProcAddress("glUniform4fvARB")); + d->Uniform3fvARB = reinterpret_cast(context->getProcAddress("glUniform3fvARB")); + d->Uniform2fvARB = reinterpret_cast(context->getProcAddress("glUniform2fvARB")); + d->Uniform1fvARB = reinterpret_cast(context->getProcAddress("glUniform1fvARB")); + d->Uniform4iARB = reinterpret_cast(context->getProcAddress("glUniform4iARB")); + d->Uniform3iARB = reinterpret_cast(context->getProcAddress("glUniform3iARB")); + d->Uniform2iARB = reinterpret_cast(context->getProcAddress("glUniform2iARB")); + d->Uniform1iARB = reinterpret_cast(context->getProcAddress("glUniform1iARB")); + d->Uniform4fARB = reinterpret_cast(context->getProcAddress("glUniform4fARB")); + d->Uniform3fARB = reinterpret_cast(context->getProcAddress("glUniform3fARB")); + d->Uniform2fARB = reinterpret_cast(context->getProcAddress("glUniform2fARB")); + d->Uniform1fARB = reinterpret_cast(context->getProcAddress("glUniform1fARB")); + d->ValidateProgramARB = reinterpret_cast(context->getProcAddress("glValidateProgramARB")); + d->UseProgramObjectARB = reinterpret_cast(context->getProcAddress("glUseProgramObjectARB")); + d->LinkProgramARB = reinterpret_cast(context->getProcAddress("glLinkProgramARB")); + d->AttachObjectARB = reinterpret_cast(context->getProcAddress("glAttachObjectARB")); + d->CreateProgramObjectARB = reinterpret_cast(context->getProcAddress("glCreateProgramObjectARB")); + d->CompileShaderARB = reinterpret_cast(context->getProcAddress("glCompileShaderARB")); + d->ShaderSourceARB = reinterpret_cast(context->getProcAddress("glShaderSourceARB")); + d->CreateShaderObjectARB = reinterpret_cast(context->getProcAddress("glCreateShaderObjectARB")); + d->DetachObjectARB = reinterpret_cast(context->getProcAddress("glDetachObjectARB")); + d->GetHandleARB = reinterpret_cast(context->getProcAddress("glGetHandleARB")); + d->DeleteObjectARB = reinterpret_cast(context->getProcAddress("glDeleteObjectARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_shader_storage_buffer_object::QOpenGLExtension_ARB_shader_storage_buffer_object() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_shader_storage_buffer_objectPrivate)) +{ +} + +bool QOpenGLExtension_ARB_shader_storage_buffer_object::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_shader_storage_buffer_object); + + d->ShaderStorageBlockBinding = reinterpret_cast(context->getProcAddress("glShaderStorageBlockBinding")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_shader_subroutine::QOpenGLExtension_ARB_shader_subroutine() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_shader_subroutinePrivate)) +{ +} + +bool QOpenGLExtension_ARB_shader_subroutine::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_shader_subroutine); + + d->GetProgramStageiv = reinterpret_cast(context->getProcAddress("glGetProgramStageiv")); + d->GetUniformSubroutineuiv = reinterpret_cast(context->getProcAddress("glGetUniformSubroutineuiv")); + d->UniformSubroutinesuiv = reinterpret_cast(context->getProcAddress("glUniformSubroutinesuiv")); + d->GetActiveSubroutineName = reinterpret_cast(context->getProcAddress("glGetActiveSubroutineName")); + d->GetActiveSubroutineUniformName = reinterpret_cast(context->getProcAddress("glGetActiveSubroutineUniformName")); + d->GetActiveSubroutineUniformiv = reinterpret_cast(context->getProcAddress("glGetActiveSubroutineUniformiv")); + d->GetSubroutineIndex = reinterpret_cast(context->getProcAddress("glGetSubroutineIndex")); + d->GetSubroutineUniformLocation = reinterpret_cast(context->getProcAddress("glGetSubroutineUniformLocation")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_shading_language_include::QOpenGLExtension_ARB_shading_language_include() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_shading_language_includePrivate)) +{ +} + +bool QOpenGLExtension_ARB_shading_language_include::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_shading_language_include); + + d->GetNamedStringivARB = reinterpret_cast(context->getProcAddress("glGetNamedStringivARB")); + d->GetNamedStringARB = reinterpret_cast(context->getProcAddress("glGetNamedStringARB")); + d->IsNamedStringARB = reinterpret_cast(context->getProcAddress("glIsNamedStringARB")); + d->CompileShaderIncludeARB = reinterpret_cast(context->getProcAddress("glCompileShaderIncludeARB")); + d->DeleteNamedStringARB = reinterpret_cast(context->getProcAddress("glDeleteNamedStringARB")); + d->NamedStringARB = reinterpret_cast(context->getProcAddress("glNamedStringARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_sync::QOpenGLExtension_ARB_sync() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_syncPrivate)) +{ +} + +bool QOpenGLExtension_ARB_sync::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_sync); + + d->GetSynciv = reinterpret_cast(context->getProcAddress("glGetSynciv")); + d->GetInteger64v = reinterpret_cast(context->getProcAddress("glGetInteger64v")); + d->WaitSync = reinterpret_cast(context->getProcAddress("glWaitSync")); + d->ClientWaitSync = reinterpret_cast(context->getProcAddress("glClientWaitSync")); + d->DeleteSync = reinterpret_cast(context->getProcAddress("glDeleteSync")); + d->IsSync = reinterpret_cast(context->getProcAddress("glIsSync")); + d->FenceSync = reinterpret_cast(context->getProcAddress("glFenceSync")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_tessellation_shader::QOpenGLExtension_ARB_tessellation_shader() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_tessellation_shaderPrivate)) +{ +} + +bool QOpenGLExtension_ARB_tessellation_shader::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_tessellation_shader); + + d->PatchParameterfv = reinterpret_cast(context->getProcAddress("glPatchParameterfv")); + d->PatchParameteri = reinterpret_cast(context->getProcAddress("glPatchParameteri")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_texture_buffer_object::QOpenGLExtension_ARB_texture_buffer_object() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_texture_buffer_objectPrivate)) +{ +} + +bool QOpenGLExtension_ARB_texture_buffer_object::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_texture_buffer_object); + + d->TexBufferARB = reinterpret_cast(context->getProcAddress("glTexBufferARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_texture_buffer_range::QOpenGLExtension_ARB_texture_buffer_range() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_texture_buffer_rangePrivate)) +{ +} + +bool QOpenGLExtension_ARB_texture_buffer_range::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_texture_buffer_range); + + d->TexBufferRange = reinterpret_cast(context->getProcAddress("glTexBufferRange")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_texture_compression::QOpenGLExtension_ARB_texture_compression() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_texture_compressionPrivate)) +{ +} + +bool QOpenGLExtension_ARB_texture_compression::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_texture_compression); + + d->GetCompressedTexImageARB = reinterpret_cast(context->getProcAddress("glGetCompressedTexImageARB")); + d->CompressedTexSubImage1DARB = reinterpret_cast(context->getProcAddress("glCompressedTexSubImage1DARB")); + d->CompressedTexSubImage2DARB = reinterpret_cast(context->getProcAddress("glCompressedTexSubImage2DARB")); + d->CompressedTexSubImage3DARB = reinterpret_cast(context->getProcAddress("glCompressedTexSubImage3DARB")); + d->CompressedTexImage1DARB = reinterpret_cast(context->getProcAddress("glCompressedTexImage1DARB")); + d->CompressedTexImage2DARB = reinterpret_cast(context->getProcAddress("glCompressedTexImage2DARB")); + d->CompressedTexImage3DARB = reinterpret_cast(context->getProcAddress("glCompressedTexImage3DARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_texture_multisample::QOpenGLExtension_ARB_texture_multisample() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_texture_multisamplePrivate)) +{ +} + +bool QOpenGLExtension_ARB_texture_multisample::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_texture_multisample); + + d->SampleMaski = reinterpret_cast(context->getProcAddress("glSampleMaski")); + d->GetMultisamplefv = reinterpret_cast(context->getProcAddress("glGetMultisamplefv")); + d->TexImage3DMultisample = reinterpret_cast(context->getProcAddress("glTexImage3DMultisample")); + d->TexImage2DMultisample = reinterpret_cast(context->getProcAddress("glTexImage2DMultisample")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_texture_storage::QOpenGLExtension_ARB_texture_storage() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_texture_storagePrivate)) +{ +} + +bool QOpenGLExtension_ARB_texture_storage::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_texture_storage); + + d->TexStorage3D = reinterpret_cast(context->getProcAddress("glTexStorage3D")); + d->TexStorage2D = reinterpret_cast(context->getProcAddress("glTexStorage2D")); + d->TexStorage1D = reinterpret_cast(context->getProcAddress("glTexStorage1D")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_texture_storage_multisample::QOpenGLExtension_ARB_texture_storage_multisample() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_texture_storage_multisamplePrivate)) +{ +} + +bool QOpenGLExtension_ARB_texture_storage_multisample::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_texture_storage_multisample); + + d->TexStorage3DMultisample = reinterpret_cast(context->getProcAddress("glTexStorage3DMultisample")); + d->TexStorage2DMultisample = reinterpret_cast(context->getProcAddress("glTexStorage2DMultisample")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_texture_view::QOpenGLExtension_ARB_texture_view() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_texture_viewPrivate)) +{ +} + +bool QOpenGLExtension_ARB_texture_view::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_texture_view); + + d->TextureView = reinterpret_cast(context->getProcAddress("glTextureView")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_timer_query::QOpenGLExtension_ARB_timer_query() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_timer_queryPrivate)) +{ +} + +bool QOpenGLExtension_ARB_timer_query::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_timer_query); + + d->GetQueryObjectui64v = reinterpret_cast(context->getProcAddress("glGetQueryObjectui64v")); + d->GetQueryObjecti64v = reinterpret_cast(context->getProcAddress("glGetQueryObjecti64v")); + d->QueryCounter = reinterpret_cast(context->getProcAddress("glQueryCounter")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_transform_feedback2::QOpenGLExtension_ARB_transform_feedback2() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_transform_feedback2Private)) +{ +} + +bool QOpenGLExtension_ARB_transform_feedback2::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_transform_feedback2); + + d->DrawTransformFeedback = reinterpret_cast(context->getProcAddress("glDrawTransformFeedback")); + d->ResumeTransformFeedback = reinterpret_cast(context->getProcAddress("glResumeTransformFeedback")); + d->PauseTransformFeedback = reinterpret_cast(context->getProcAddress("glPauseTransformFeedback")); + d->IsTransformFeedback = reinterpret_cast(context->getProcAddress("glIsTransformFeedback")); + d->GenTransformFeedbacks = reinterpret_cast(context->getProcAddress("glGenTransformFeedbacks")); + d->DeleteTransformFeedbacks = reinterpret_cast(context->getProcAddress("glDeleteTransformFeedbacks")); + d->BindTransformFeedback = reinterpret_cast(context->getProcAddress("glBindTransformFeedback")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_transform_feedback3::QOpenGLExtension_ARB_transform_feedback3() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_transform_feedback3Private)) +{ +} + +bool QOpenGLExtension_ARB_transform_feedback3::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_transform_feedback3); + + d->GetQueryIndexediv = reinterpret_cast(context->getProcAddress("glGetQueryIndexediv")); + d->EndQueryIndexed = reinterpret_cast(context->getProcAddress("glEndQueryIndexed")); + d->BeginQueryIndexed = reinterpret_cast(context->getProcAddress("glBeginQueryIndexed")); + d->DrawTransformFeedbackStream = reinterpret_cast(context->getProcAddress("glDrawTransformFeedbackStream")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_transform_feedback_instanced::QOpenGLExtension_ARB_transform_feedback_instanced() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_transform_feedback_instancedPrivate)) +{ +} + +bool QOpenGLExtension_ARB_transform_feedback_instanced::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_transform_feedback_instanced); + + d->DrawTransformFeedbackStreamInstanced = reinterpret_cast(context->getProcAddress("glDrawTransformFeedbackStreamInstanced")); + d->DrawTransformFeedbackInstanced = reinterpret_cast(context->getProcAddress("glDrawTransformFeedbackInstanced")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_transpose_matrix::QOpenGLExtension_ARB_transpose_matrix() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_transpose_matrixPrivate)) +{ +} + +bool QOpenGLExtension_ARB_transpose_matrix::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_transpose_matrix); + + d->MultTransposeMatrixdARB = reinterpret_cast(context->getProcAddress("glMultTransposeMatrixdARB")); + d->MultTransposeMatrixfARB = reinterpret_cast(context->getProcAddress("glMultTransposeMatrixfARB")); + d->LoadTransposeMatrixdARB = reinterpret_cast(context->getProcAddress("glLoadTransposeMatrixdARB")); + d->LoadTransposeMatrixfARB = reinterpret_cast(context->getProcAddress("glLoadTransposeMatrixfARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_uniform_buffer_object::QOpenGLExtension_ARB_uniform_buffer_object() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_uniform_buffer_objectPrivate)) +{ +} + +bool QOpenGLExtension_ARB_uniform_buffer_object::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_uniform_buffer_object); + + d->UniformBlockBinding = reinterpret_cast(context->getProcAddress("glUniformBlockBinding")); + d->GetActiveUniformBlockName = reinterpret_cast(context->getProcAddress("glGetActiveUniformBlockName")); + d->GetActiveUniformBlockiv = reinterpret_cast(context->getProcAddress("glGetActiveUniformBlockiv")); + d->GetUniformBlockIndex = reinterpret_cast(context->getProcAddress("glGetUniformBlockIndex")); + d->GetActiveUniformName = reinterpret_cast(context->getProcAddress("glGetActiveUniformName")); + d->GetActiveUniformsiv = reinterpret_cast(context->getProcAddress("glGetActiveUniformsiv")); + d->GetUniformIndices = reinterpret_cast(context->getProcAddress("glGetUniformIndices")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_vertex_array_object::QOpenGLExtension_ARB_vertex_array_object() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_vertex_array_objectPrivate)) +{ +} + +bool QOpenGLExtension_ARB_vertex_array_object::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_vertex_array_object); + + d->IsVertexArray = reinterpret_cast(context->getProcAddress("glIsVertexArray")); + d->GenVertexArrays = reinterpret_cast(context->getProcAddress("glGenVertexArrays")); + d->DeleteVertexArrays = reinterpret_cast(context->getProcAddress("glDeleteVertexArrays")); + d->BindVertexArray = reinterpret_cast(context->getProcAddress("glBindVertexArray")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_vertex_attrib_64bit::QOpenGLExtension_ARB_vertex_attrib_64bit() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_vertex_attrib_64bitPrivate)) +{ +} + +bool QOpenGLExtension_ARB_vertex_attrib_64bit::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_vertex_attrib_64bit); + + d->GetVertexAttribLdv = reinterpret_cast(context->getProcAddress("glGetVertexAttribLdv")); + d->VertexAttribLPointer = reinterpret_cast(context->getProcAddress("glVertexAttribLPointer")); + d->VertexAttribL4dv = reinterpret_cast(context->getProcAddress("glVertexAttribL4dv")); + d->VertexAttribL3dv = reinterpret_cast(context->getProcAddress("glVertexAttribL3dv")); + d->VertexAttribL2dv = reinterpret_cast(context->getProcAddress("glVertexAttribL2dv")); + d->VertexAttribL1dv = reinterpret_cast(context->getProcAddress("glVertexAttribL1dv")); + d->VertexAttribL4d = reinterpret_cast(context->getProcAddress("glVertexAttribL4d")); + d->VertexAttribL3d = reinterpret_cast(context->getProcAddress("glVertexAttribL3d")); + d->VertexAttribL2d = reinterpret_cast(context->getProcAddress("glVertexAttribL2d")); + d->VertexAttribL1d = reinterpret_cast(context->getProcAddress("glVertexAttribL1d")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_vertex_attrib_binding::QOpenGLExtension_ARB_vertex_attrib_binding() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_vertex_attrib_bindingPrivate)) +{ +} + +bool QOpenGLExtension_ARB_vertex_attrib_binding::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_vertex_attrib_binding); + + d->VertexBindingDivisor = reinterpret_cast(context->getProcAddress("glVertexBindingDivisor")); + d->VertexAttribBinding = reinterpret_cast(context->getProcAddress("glVertexAttribBinding")); + d->VertexAttribLFormat = reinterpret_cast(context->getProcAddress("glVertexAttribLFormat")); + d->VertexAttribIFormat = reinterpret_cast(context->getProcAddress("glVertexAttribIFormat")); + d->VertexAttribFormat = reinterpret_cast(context->getProcAddress("glVertexAttribFormat")); + d->BindVertexBuffer = reinterpret_cast(context->getProcAddress("glBindVertexBuffer")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_vertex_blend::QOpenGLExtension_ARB_vertex_blend() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_vertex_blendPrivate)) +{ +} + +bool QOpenGLExtension_ARB_vertex_blend::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_vertex_blend); + + d->VertexBlendARB = reinterpret_cast(context->getProcAddress("glVertexBlendARB")); + d->WeightPointerARB = reinterpret_cast(context->getProcAddress("glWeightPointerARB")); + d->WeightuivARB = reinterpret_cast(context->getProcAddress("glWeightuivARB")); + d->WeightusvARB = reinterpret_cast(context->getProcAddress("glWeightusvARB")); + d->WeightubvARB = reinterpret_cast(context->getProcAddress("glWeightubvARB")); + d->WeightdvARB = reinterpret_cast(context->getProcAddress("glWeightdvARB")); + d->WeightfvARB = reinterpret_cast(context->getProcAddress("glWeightfvARB")); + d->WeightivARB = reinterpret_cast(context->getProcAddress("glWeightivARB")); + d->WeightsvARB = reinterpret_cast(context->getProcAddress("glWeightsvARB")); + d->WeightbvARB = reinterpret_cast(context->getProcAddress("glWeightbvARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_vertex_buffer_object::QOpenGLExtension_ARB_vertex_buffer_object() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_vertex_buffer_objectPrivate)) +{ +} + +bool QOpenGLExtension_ARB_vertex_buffer_object::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_vertex_buffer_object); + + d->GetBufferPointervARB = reinterpret_cast(context->getProcAddress("glGetBufferPointervARB")); + d->GetBufferParameterivARB = reinterpret_cast(context->getProcAddress("glGetBufferParameterivARB")); + d->UnmapBufferARB = reinterpret_cast(context->getProcAddress("glUnmapBufferARB")); + d->MapBufferARB = reinterpret_cast(context->getProcAddress("glMapBufferARB")); + d->GetBufferSubDataARB = reinterpret_cast(context->getProcAddress("glGetBufferSubDataARB")); + d->BufferSubDataARB = reinterpret_cast(context->getProcAddress("glBufferSubDataARB")); + d->BufferDataARB = reinterpret_cast(context->getProcAddress("glBufferDataARB")); + d->IsBufferARB = reinterpret_cast(context->getProcAddress("glIsBufferARB")); + d->GenBuffersARB = reinterpret_cast(context->getProcAddress("glGenBuffersARB")); + d->DeleteBuffersARB = reinterpret_cast(context->getProcAddress("glDeleteBuffersARB")); + d->BindBufferARB = reinterpret_cast(context->getProcAddress("glBindBufferARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_vertex_program::QOpenGLExtension_ARB_vertex_program() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_vertex_programPrivate)) +{ +} + +bool QOpenGLExtension_ARB_vertex_program::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_vertex_program); + + d->IsProgramARB = reinterpret_cast(context->getProcAddress("glIsProgramARB")); + d->GetVertexAttribPointervARB = reinterpret_cast(context->getProcAddress("glGetVertexAttribPointervARB")); + d->GetVertexAttribivARB = reinterpret_cast(context->getProcAddress("glGetVertexAttribivARB")); + d->GetVertexAttribfvARB = reinterpret_cast(context->getProcAddress("glGetVertexAttribfvARB")); + d->GetVertexAttribdvARB = reinterpret_cast(context->getProcAddress("glGetVertexAttribdvARB")); + d->GetProgramStringARB = reinterpret_cast(context->getProcAddress("glGetProgramStringARB")); + d->GetProgramivARB = reinterpret_cast(context->getProcAddress("glGetProgramivARB")); + d->GetProgramLocalParameterfvARB = reinterpret_cast(context->getProcAddress("glGetProgramLocalParameterfvARB")); + d->GetProgramLocalParameterdvARB = reinterpret_cast(context->getProcAddress("glGetProgramLocalParameterdvARB")); + d->GetProgramEnvParameterfvARB = reinterpret_cast(context->getProcAddress("glGetProgramEnvParameterfvARB")); + d->GetProgramEnvParameterdvARB = reinterpret_cast(context->getProcAddress("glGetProgramEnvParameterdvARB")); + d->ProgramLocalParameter4fvARB = reinterpret_cast(context->getProcAddress("glProgramLocalParameter4fvARB")); + d->ProgramLocalParameter4fARB = reinterpret_cast(context->getProcAddress("glProgramLocalParameter4fARB")); + d->ProgramLocalParameter4dvARB = reinterpret_cast(context->getProcAddress("glProgramLocalParameter4dvARB")); + d->ProgramLocalParameter4dARB = reinterpret_cast(context->getProcAddress("glProgramLocalParameter4dARB")); + d->ProgramEnvParameter4fvARB = reinterpret_cast(context->getProcAddress("glProgramEnvParameter4fvARB")); + d->ProgramEnvParameter4fARB = reinterpret_cast(context->getProcAddress("glProgramEnvParameter4fARB")); + d->ProgramEnvParameter4dvARB = reinterpret_cast(context->getProcAddress("glProgramEnvParameter4dvARB")); + d->ProgramEnvParameter4dARB = reinterpret_cast(context->getProcAddress("glProgramEnvParameter4dARB")); + d->GenProgramsARB = reinterpret_cast(context->getProcAddress("glGenProgramsARB")); + d->DeleteProgramsARB = reinterpret_cast(context->getProcAddress("glDeleteProgramsARB")); + d->BindProgramARB = reinterpret_cast(context->getProcAddress("glBindProgramARB")); + d->ProgramStringARB = reinterpret_cast(context->getProcAddress("glProgramStringARB")); + d->DisableVertexAttribArrayARB = reinterpret_cast(context->getProcAddress("glDisableVertexAttribArrayARB")); + d->EnableVertexAttribArrayARB = reinterpret_cast(context->getProcAddress("glEnableVertexAttribArrayARB")); + d->VertexAttribPointerARB = reinterpret_cast(context->getProcAddress("glVertexAttribPointerARB")); + d->VertexAttrib4usvARB = reinterpret_cast(context->getProcAddress("glVertexAttrib4usvARB")); + d->VertexAttrib4uivARB = reinterpret_cast(context->getProcAddress("glVertexAttrib4uivARB")); + d->VertexAttrib4ubvARB = reinterpret_cast(context->getProcAddress("glVertexAttrib4ubvARB")); + d->VertexAttrib4svARB = reinterpret_cast(context->getProcAddress("glVertexAttrib4svARB")); + d->VertexAttrib4sARB = reinterpret_cast(context->getProcAddress("glVertexAttrib4sARB")); + d->VertexAttrib4ivARB = reinterpret_cast(context->getProcAddress("glVertexAttrib4ivARB")); + d->VertexAttrib4fvARB = reinterpret_cast(context->getProcAddress("glVertexAttrib4fvARB")); + d->VertexAttrib4fARB = reinterpret_cast(context->getProcAddress("glVertexAttrib4fARB")); + d->VertexAttrib4dvARB = reinterpret_cast(context->getProcAddress("glVertexAttrib4dvARB")); + d->VertexAttrib4dARB = reinterpret_cast(context->getProcAddress("glVertexAttrib4dARB")); + d->VertexAttrib4bvARB = reinterpret_cast(context->getProcAddress("glVertexAttrib4bvARB")); + d->VertexAttrib4NusvARB = reinterpret_cast(context->getProcAddress("glVertexAttrib4NusvARB")); + d->VertexAttrib4NuivARB = reinterpret_cast(context->getProcAddress("glVertexAttrib4NuivARB")); + d->VertexAttrib4NubvARB = reinterpret_cast(context->getProcAddress("glVertexAttrib4NubvARB")); + d->VertexAttrib4NubARB = reinterpret_cast(context->getProcAddress("glVertexAttrib4NubARB")); + d->VertexAttrib4NsvARB = reinterpret_cast(context->getProcAddress("glVertexAttrib4NsvARB")); + d->VertexAttrib4NivARB = reinterpret_cast(context->getProcAddress("glVertexAttrib4NivARB")); + d->VertexAttrib4NbvARB = reinterpret_cast(context->getProcAddress("glVertexAttrib4NbvARB")); + d->VertexAttrib3svARB = reinterpret_cast(context->getProcAddress("glVertexAttrib3svARB")); + d->VertexAttrib3sARB = reinterpret_cast(context->getProcAddress("glVertexAttrib3sARB")); + d->VertexAttrib3fvARB = reinterpret_cast(context->getProcAddress("glVertexAttrib3fvARB")); + d->VertexAttrib3fARB = reinterpret_cast(context->getProcAddress("glVertexAttrib3fARB")); + d->VertexAttrib3dvARB = reinterpret_cast(context->getProcAddress("glVertexAttrib3dvARB")); + d->VertexAttrib3dARB = reinterpret_cast(context->getProcAddress("glVertexAttrib3dARB")); + d->VertexAttrib2svARB = reinterpret_cast(context->getProcAddress("glVertexAttrib2svARB")); + d->VertexAttrib2sARB = reinterpret_cast(context->getProcAddress("glVertexAttrib2sARB")); + d->VertexAttrib2fvARB = reinterpret_cast(context->getProcAddress("glVertexAttrib2fvARB")); + d->VertexAttrib2fARB = reinterpret_cast(context->getProcAddress("glVertexAttrib2fARB")); + d->VertexAttrib2dvARB = reinterpret_cast(context->getProcAddress("glVertexAttrib2dvARB")); + d->VertexAttrib2dARB = reinterpret_cast(context->getProcAddress("glVertexAttrib2dARB")); + d->VertexAttrib1svARB = reinterpret_cast(context->getProcAddress("glVertexAttrib1svARB")); + d->VertexAttrib1sARB = reinterpret_cast(context->getProcAddress("glVertexAttrib1sARB")); + d->VertexAttrib1fvARB = reinterpret_cast(context->getProcAddress("glVertexAttrib1fvARB")); + d->VertexAttrib1fARB = reinterpret_cast(context->getProcAddress("glVertexAttrib1fARB")); + d->VertexAttrib1dvARB = reinterpret_cast(context->getProcAddress("glVertexAttrib1dvARB")); + d->VertexAttrib1dARB = reinterpret_cast(context->getProcAddress("glVertexAttrib1dARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_vertex_shader::QOpenGLExtension_ARB_vertex_shader() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_vertex_shaderPrivate)) +{ +} + +bool QOpenGLExtension_ARB_vertex_shader::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_vertex_shader); + + d->GetAttribLocationARB = reinterpret_cast(context->getProcAddress("glGetAttribLocationARB")); + d->GetActiveAttribARB = reinterpret_cast(context->getProcAddress("glGetActiveAttribARB")); + d->BindAttribLocationARB = reinterpret_cast(context->getProcAddress("glBindAttribLocationARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_vertex_type_2_10_10_10_rev::QOpenGLExtension_ARB_vertex_type_2_10_10_10_rev() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_vertex_type_2_10_10_10_revPrivate)) +{ +} + +bool QOpenGLExtension_ARB_vertex_type_2_10_10_10_rev::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_vertex_type_2_10_10_10_rev); + + d->VertexAttribP4uiv = reinterpret_cast(context->getProcAddress("glVertexAttribP4uiv")); + d->VertexAttribP4ui = reinterpret_cast(context->getProcAddress("glVertexAttribP4ui")); + d->VertexAttribP3uiv = reinterpret_cast(context->getProcAddress("glVertexAttribP3uiv")); + d->VertexAttribP3ui = reinterpret_cast(context->getProcAddress("glVertexAttribP3ui")); + d->VertexAttribP2uiv = reinterpret_cast(context->getProcAddress("glVertexAttribP2uiv")); + d->VertexAttribP2ui = reinterpret_cast(context->getProcAddress("glVertexAttribP2ui")); + d->VertexAttribP1uiv = reinterpret_cast(context->getProcAddress("glVertexAttribP1uiv")); + d->VertexAttribP1ui = reinterpret_cast(context->getProcAddress("glVertexAttribP1ui")); + d->SecondaryColorP3uiv = reinterpret_cast(context->getProcAddress("glSecondaryColorP3uiv")); + d->SecondaryColorP3ui = reinterpret_cast(context->getProcAddress("glSecondaryColorP3ui")); + d->ColorP4uiv = reinterpret_cast(context->getProcAddress("glColorP4uiv")); + d->ColorP4ui = reinterpret_cast(context->getProcAddress("glColorP4ui")); + d->ColorP3uiv = reinterpret_cast(context->getProcAddress("glColorP3uiv")); + d->ColorP3ui = reinterpret_cast(context->getProcAddress("glColorP3ui")); + d->NormalP3uiv = reinterpret_cast(context->getProcAddress("glNormalP3uiv")); + d->NormalP3ui = reinterpret_cast(context->getProcAddress("glNormalP3ui")); + d->MultiTexCoordP4uiv = reinterpret_cast(context->getProcAddress("glMultiTexCoordP4uiv")); + d->MultiTexCoordP4ui = reinterpret_cast(context->getProcAddress("glMultiTexCoordP4ui")); + d->MultiTexCoordP3uiv = reinterpret_cast(context->getProcAddress("glMultiTexCoordP3uiv")); + d->MultiTexCoordP3ui = reinterpret_cast(context->getProcAddress("glMultiTexCoordP3ui")); + d->MultiTexCoordP2uiv = reinterpret_cast(context->getProcAddress("glMultiTexCoordP2uiv")); + d->MultiTexCoordP2ui = reinterpret_cast(context->getProcAddress("glMultiTexCoordP2ui")); + d->MultiTexCoordP1uiv = reinterpret_cast(context->getProcAddress("glMultiTexCoordP1uiv")); + d->MultiTexCoordP1ui = reinterpret_cast(context->getProcAddress("glMultiTexCoordP1ui")); + d->TexCoordP4uiv = reinterpret_cast(context->getProcAddress("glTexCoordP4uiv")); + d->TexCoordP4ui = reinterpret_cast(context->getProcAddress("glTexCoordP4ui")); + d->TexCoordP3uiv = reinterpret_cast(context->getProcAddress("glTexCoordP3uiv")); + d->TexCoordP3ui = reinterpret_cast(context->getProcAddress("glTexCoordP3ui")); + d->TexCoordP2uiv = reinterpret_cast(context->getProcAddress("glTexCoordP2uiv")); + d->TexCoordP2ui = reinterpret_cast(context->getProcAddress("glTexCoordP2ui")); + d->TexCoordP1uiv = reinterpret_cast(context->getProcAddress("glTexCoordP1uiv")); + d->TexCoordP1ui = reinterpret_cast(context->getProcAddress("glTexCoordP1ui")); + d->VertexP4uiv = reinterpret_cast(context->getProcAddress("glVertexP4uiv")); + d->VertexP4ui = reinterpret_cast(context->getProcAddress("glVertexP4ui")); + d->VertexP3uiv = reinterpret_cast(context->getProcAddress("glVertexP3uiv")); + d->VertexP3ui = reinterpret_cast(context->getProcAddress("glVertexP3ui")); + d->VertexP2uiv = reinterpret_cast(context->getProcAddress("glVertexP2uiv")); + d->VertexP2ui = reinterpret_cast(context->getProcAddress("glVertexP2ui")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_viewport_array::QOpenGLExtension_ARB_viewport_array() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_viewport_arrayPrivate)) +{ +} + +bool QOpenGLExtension_ARB_viewport_array::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_viewport_array); + + d->GetDoublei_v = reinterpret_cast(context->getProcAddress("glGetDoublei_v")); + d->GetFloati_v = reinterpret_cast(context->getProcAddress("glGetFloati_v")); + d->DepthRangeIndexed = reinterpret_cast(context->getProcAddress("glDepthRangeIndexed")); + d->DepthRangeArrayv = reinterpret_cast(context->getProcAddress("glDepthRangeArrayv")); + d->ScissorIndexedv = reinterpret_cast(context->getProcAddress("glScissorIndexedv")); + d->ScissorIndexed = reinterpret_cast(context->getProcAddress("glScissorIndexed")); + d->ScissorArrayv = reinterpret_cast(context->getProcAddress("glScissorArrayv")); + d->ViewportIndexedfv = reinterpret_cast(context->getProcAddress("glViewportIndexedfv")); + d->ViewportIndexedf = reinterpret_cast(context->getProcAddress("glViewportIndexedf")); + d->ViewportArrayv = reinterpret_cast(context->getProcAddress("glViewportArrayv")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ARB_window_pos::QOpenGLExtension_ARB_window_pos() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ARB_window_posPrivate)) +{ +} + +bool QOpenGLExtension_ARB_window_pos::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ARB_window_pos); + + d->WindowPos3svARB = reinterpret_cast(context->getProcAddress("glWindowPos3svARB")); + d->WindowPos3sARB = reinterpret_cast(context->getProcAddress("glWindowPos3sARB")); + d->WindowPos3ivARB = reinterpret_cast(context->getProcAddress("glWindowPos3ivARB")); + d->WindowPos3iARB = reinterpret_cast(context->getProcAddress("glWindowPos3iARB")); + d->WindowPos3fvARB = reinterpret_cast(context->getProcAddress("glWindowPos3fvARB")); + d->WindowPos3fARB = reinterpret_cast(context->getProcAddress("glWindowPos3fARB")); + d->WindowPos3dvARB = reinterpret_cast(context->getProcAddress("glWindowPos3dvARB")); + d->WindowPos3dARB = reinterpret_cast(context->getProcAddress("glWindowPos3dARB")); + d->WindowPos2svARB = reinterpret_cast(context->getProcAddress("glWindowPos2svARB")); + d->WindowPos2sARB = reinterpret_cast(context->getProcAddress("glWindowPos2sARB")); + d->WindowPos2ivARB = reinterpret_cast(context->getProcAddress("glWindowPos2ivARB")); + d->WindowPos2iARB = reinterpret_cast(context->getProcAddress("glWindowPos2iARB")); + d->WindowPos2fvARB = reinterpret_cast(context->getProcAddress("glWindowPos2fvARB")); + d->WindowPos2fARB = reinterpret_cast(context->getProcAddress("glWindowPos2fARB")); + d->WindowPos2dvARB = reinterpret_cast(context->getProcAddress("glWindowPos2dvARB")); + d->WindowPos2dARB = reinterpret_cast(context->getProcAddress("glWindowPos2dARB")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ATI_draw_buffers::QOpenGLExtension_ATI_draw_buffers() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ATI_draw_buffersPrivate)) +{ +} + +bool QOpenGLExtension_ATI_draw_buffers::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ATI_draw_buffers); + + d->DrawBuffersATI = reinterpret_cast(context->getProcAddress("glDrawBuffersATI")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ATI_element_array::QOpenGLExtension_ATI_element_array() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ATI_element_arrayPrivate)) +{ +} + +bool QOpenGLExtension_ATI_element_array::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ATI_element_array); + + d->DrawRangeElementArrayATI = reinterpret_cast(context->getProcAddress("glDrawRangeElementArrayATI")); + d->DrawElementArrayATI = reinterpret_cast(context->getProcAddress("glDrawElementArrayATI")); + d->ElementPointerATI = reinterpret_cast(context->getProcAddress("glElementPointerATI")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ATI_envmap_bumpmap::QOpenGLExtension_ATI_envmap_bumpmap() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ATI_envmap_bumpmapPrivate)) +{ +} + +bool QOpenGLExtension_ATI_envmap_bumpmap::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ATI_envmap_bumpmap); + + d->GetTexBumpParameterfvATI = reinterpret_cast(context->getProcAddress("glGetTexBumpParameterfvATI")); + d->GetTexBumpParameterivATI = reinterpret_cast(context->getProcAddress("glGetTexBumpParameterivATI")); + d->TexBumpParameterfvATI = reinterpret_cast(context->getProcAddress("glTexBumpParameterfvATI")); + d->TexBumpParameterivATI = reinterpret_cast(context->getProcAddress("glTexBumpParameterivATI")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ATI_fragment_shader::QOpenGLExtension_ATI_fragment_shader() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ATI_fragment_shaderPrivate)) +{ +} + +bool QOpenGLExtension_ATI_fragment_shader::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ATI_fragment_shader); + + d->SetFragmentShaderConstantATI = reinterpret_cast(context->getProcAddress("glSetFragmentShaderConstantATI")); + d->AlphaFragmentOp3ATI = reinterpret_cast(context->getProcAddress("glAlphaFragmentOp3ATI")); + d->AlphaFragmentOp2ATI = reinterpret_cast(context->getProcAddress("glAlphaFragmentOp2ATI")); + d->AlphaFragmentOp1ATI = reinterpret_cast(context->getProcAddress("glAlphaFragmentOp1ATI")); + d->ColorFragmentOp3ATI = reinterpret_cast(context->getProcAddress("glColorFragmentOp3ATI")); + d->ColorFragmentOp2ATI = reinterpret_cast(context->getProcAddress("glColorFragmentOp2ATI")); + d->ColorFragmentOp1ATI = reinterpret_cast(context->getProcAddress("glColorFragmentOp1ATI")); + d->SampleMapATI = reinterpret_cast(context->getProcAddress("glSampleMapATI")); + d->PassTexCoordATI = reinterpret_cast(context->getProcAddress("glPassTexCoordATI")); + d->EndFragmentShaderATI = reinterpret_cast(context->getProcAddress("glEndFragmentShaderATI")); + d->BeginFragmentShaderATI = reinterpret_cast(context->getProcAddress("glBeginFragmentShaderATI")); + d->DeleteFragmentShaderATI = reinterpret_cast(context->getProcAddress("glDeleteFragmentShaderATI")); + d->BindFragmentShaderATI = reinterpret_cast(context->getProcAddress("glBindFragmentShaderATI")); + d->GenFragmentShadersATI = reinterpret_cast(context->getProcAddress("glGenFragmentShadersATI")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ATI_map_object_buffer::QOpenGLExtension_ATI_map_object_buffer() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ATI_map_object_bufferPrivate)) +{ +} + +bool QOpenGLExtension_ATI_map_object_buffer::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ATI_map_object_buffer); + + d->UnmapObjectBufferATI = reinterpret_cast(context->getProcAddress("glUnmapObjectBufferATI")); + d->MapObjectBufferATI = reinterpret_cast(context->getProcAddress("glMapObjectBufferATI")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ATI_pn_triangles::QOpenGLExtension_ATI_pn_triangles() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ATI_pn_trianglesPrivate)) +{ +} + +bool QOpenGLExtension_ATI_pn_triangles::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ATI_pn_triangles); + + d->PNTrianglesfATI = reinterpret_cast(context->getProcAddress("glPNTrianglesfATI")); + d->PNTrianglesiATI = reinterpret_cast(context->getProcAddress("glPNTrianglesiATI")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ATI_separate_stencil::QOpenGLExtension_ATI_separate_stencil() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ATI_separate_stencilPrivate)) +{ +} + +bool QOpenGLExtension_ATI_separate_stencil::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ATI_separate_stencil); + + d->StencilFuncSeparateATI = reinterpret_cast(context->getProcAddress("glStencilFuncSeparateATI")); + d->StencilOpSeparateATI = reinterpret_cast(context->getProcAddress("glStencilOpSeparateATI")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ATI_vertex_array_object::QOpenGLExtension_ATI_vertex_array_object() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ATI_vertex_array_objectPrivate)) +{ +} + +bool QOpenGLExtension_ATI_vertex_array_object::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ATI_vertex_array_object); + + d->GetVariantArrayObjectivATI = reinterpret_cast(context->getProcAddress("glGetVariantArrayObjectivATI")); + d->GetVariantArrayObjectfvATI = reinterpret_cast(context->getProcAddress("glGetVariantArrayObjectfvATI")); + d->VariantArrayObjectATI = reinterpret_cast(context->getProcAddress("glVariantArrayObjectATI")); + d->GetArrayObjectivATI = reinterpret_cast(context->getProcAddress("glGetArrayObjectivATI")); + d->GetArrayObjectfvATI = reinterpret_cast(context->getProcAddress("glGetArrayObjectfvATI")); + d->ArrayObjectATI = reinterpret_cast(context->getProcAddress("glArrayObjectATI")); + d->FreeObjectBufferATI = reinterpret_cast(context->getProcAddress("glFreeObjectBufferATI")); + d->GetObjectBufferivATI = reinterpret_cast(context->getProcAddress("glGetObjectBufferivATI")); + d->GetObjectBufferfvATI = reinterpret_cast(context->getProcAddress("glGetObjectBufferfvATI")); + d->UpdateObjectBufferATI = reinterpret_cast(context->getProcAddress("glUpdateObjectBufferATI")); + d->IsObjectBufferATI = reinterpret_cast(context->getProcAddress("glIsObjectBufferATI")); + d->NewObjectBufferATI = reinterpret_cast(context->getProcAddress("glNewObjectBufferATI")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ATI_vertex_attrib_array_object::QOpenGLExtension_ATI_vertex_attrib_array_object() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ATI_vertex_attrib_array_objectPrivate)) +{ +} + +bool QOpenGLExtension_ATI_vertex_attrib_array_object::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ATI_vertex_attrib_array_object); + + d->GetVertexAttribArrayObjectivATI = reinterpret_cast(context->getProcAddress("glGetVertexAttribArrayObjectivATI")); + d->GetVertexAttribArrayObjectfvATI = reinterpret_cast(context->getProcAddress("glGetVertexAttribArrayObjectfvATI")); + d->VertexAttribArrayObjectATI = reinterpret_cast(context->getProcAddress("glVertexAttribArrayObjectATI")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_ATI_vertex_streams::QOpenGLExtension_ATI_vertex_streams() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ATI_vertex_streamsPrivate)) +{ +} + +bool QOpenGLExtension_ATI_vertex_streams::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ATI_vertex_streams); + + d->VertexBlendEnvfATI = reinterpret_cast(context->getProcAddress("glVertexBlendEnvfATI")); + d->VertexBlendEnviATI = reinterpret_cast(context->getProcAddress("glVertexBlendEnviATI")); + d->ClientActiveVertexStreamATI = reinterpret_cast(context->getProcAddress("glClientActiveVertexStreamATI")); + d->NormalStream3dvATI = reinterpret_cast(context->getProcAddress("glNormalStream3dvATI")); + d->NormalStream3dATI = reinterpret_cast(context->getProcAddress("glNormalStream3dATI")); + d->NormalStream3fvATI = reinterpret_cast(context->getProcAddress("glNormalStream3fvATI")); + d->NormalStream3fATI = reinterpret_cast(context->getProcAddress("glNormalStream3fATI")); + d->NormalStream3ivATI = reinterpret_cast(context->getProcAddress("glNormalStream3ivATI")); + d->NormalStream3iATI = reinterpret_cast(context->getProcAddress("glNormalStream3iATI")); + d->NormalStream3svATI = reinterpret_cast(context->getProcAddress("glNormalStream3svATI")); + d->NormalStream3sATI = reinterpret_cast(context->getProcAddress("glNormalStream3sATI")); + d->NormalStream3bvATI = reinterpret_cast(context->getProcAddress("glNormalStream3bvATI")); + d->NormalStream3bATI = reinterpret_cast(context->getProcAddress("glNormalStream3bATI")); + d->VertexStream4dvATI = reinterpret_cast(context->getProcAddress("glVertexStream4dvATI")); + d->VertexStream4dATI = reinterpret_cast(context->getProcAddress("glVertexStream4dATI")); + d->VertexStream4fvATI = reinterpret_cast(context->getProcAddress("glVertexStream4fvATI")); + d->VertexStream4fATI = reinterpret_cast(context->getProcAddress("glVertexStream4fATI")); + d->VertexStream4ivATI = reinterpret_cast(context->getProcAddress("glVertexStream4ivATI")); + d->VertexStream4iATI = reinterpret_cast(context->getProcAddress("glVertexStream4iATI")); + d->VertexStream4svATI = reinterpret_cast(context->getProcAddress("glVertexStream4svATI")); + d->VertexStream4sATI = reinterpret_cast(context->getProcAddress("glVertexStream4sATI")); + d->VertexStream3dvATI = reinterpret_cast(context->getProcAddress("glVertexStream3dvATI")); + d->VertexStream3dATI = reinterpret_cast(context->getProcAddress("glVertexStream3dATI")); + d->VertexStream3fvATI = reinterpret_cast(context->getProcAddress("glVertexStream3fvATI")); + d->VertexStream3fATI = reinterpret_cast(context->getProcAddress("glVertexStream3fATI")); + d->VertexStream3ivATI = reinterpret_cast(context->getProcAddress("glVertexStream3ivATI")); + d->VertexStream3iATI = reinterpret_cast(context->getProcAddress("glVertexStream3iATI")); + d->VertexStream3svATI = reinterpret_cast(context->getProcAddress("glVertexStream3svATI")); + d->VertexStream3sATI = reinterpret_cast(context->getProcAddress("glVertexStream3sATI")); + d->VertexStream2dvATI = reinterpret_cast(context->getProcAddress("glVertexStream2dvATI")); + d->VertexStream2dATI = reinterpret_cast(context->getProcAddress("glVertexStream2dATI")); + d->VertexStream2fvATI = reinterpret_cast(context->getProcAddress("glVertexStream2fvATI")); + d->VertexStream2fATI = reinterpret_cast(context->getProcAddress("glVertexStream2fATI")); + d->VertexStream2ivATI = reinterpret_cast(context->getProcAddress("glVertexStream2ivATI")); + d->VertexStream2iATI = reinterpret_cast(context->getProcAddress("glVertexStream2iATI")); + d->VertexStream2svATI = reinterpret_cast(context->getProcAddress("glVertexStream2svATI")); + d->VertexStream2sATI = reinterpret_cast(context->getProcAddress("glVertexStream2sATI")); + d->VertexStream1dvATI = reinterpret_cast(context->getProcAddress("glVertexStream1dvATI")); + d->VertexStream1dATI = reinterpret_cast(context->getProcAddress("glVertexStream1dATI")); + d->VertexStream1fvATI = reinterpret_cast(context->getProcAddress("glVertexStream1fvATI")); + d->VertexStream1fATI = reinterpret_cast(context->getProcAddress("glVertexStream1fATI")); + d->VertexStream1ivATI = reinterpret_cast(context->getProcAddress("glVertexStream1ivATI")); + d->VertexStream1iATI = reinterpret_cast(context->getProcAddress("glVertexStream1iATI")); + d->VertexStream1svATI = reinterpret_cast(context->getProcAddress("glVertexStream1svATI")); + d->VertexStream1sATI = reinterpret_cast(context->getProcAddress("glVertexStream1sATI")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_bindable_uniform::QOpenGLExtension_EXT_bindable_uniform() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_bindable_uniformPrivate)) +{ +} + +bool QOpenGLExtension_EXT_bindable_uniform::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_bindable_uniform); + + d->GetUniformOffsetEXT = reinterpret_cast(context->getProcAddress("glGetUniformOffsetEXT")); + d->GetUniformBufferSizeEXT = reinterpret_cast(context->getProcAddress("glGetUniformBufferSizeEXT")); + d->UniformBufferEXT = reinterpret_cast(context->getProcAddress("glUniformBufferEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_blend_color::QOpenGLExtension_EXT_blend_color() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_blend_colorPrivate)) +{ +} + +bool QOpenGLExtension_EXT_blend_color::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_blend_color); + + d->BlendColorEXT = reinterpret_cast(context->getProcAddress("glBlendColorEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_blend_equation_separate::QOpenGLExtension_EXT_blend_equation_separate() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_blend_equation_separatePrivate)) +{ +} + +bool QOpenGLExtension_EXT_blend_equation_separate::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_blend_equation_separate); + + d->BlendEquationSeparateEXT = reinterpret_cast(context->getProcAddress("glBlendEquationSeparateEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_blend_func_separate::QOpenGLExtension_EXT_blend_func_separate() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_blend_func_separatePrivate)) +{ +} + +bool QOpenGLExtension_EXT_blend_func_separate::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_blend_func_separate); + + d->BlendFuncSeparateEXT = reinterpret_cast(context->getProcAddress("glBlendFuncSeparateEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_blend_minmax::QOpenGLExtension_EXT_blend_minmax() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_blend_minmaxPrivate)) +{ +} + +bool QOpenGLExtension_EXT_blend_minmax::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_blend_minmax); + + d->BlendEquationEXT = reinterpret_cast(context->getProcAddress("glBlendEquationEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_color_subtable::QOpenGLExtension_EXT_color_subtable() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_color_subtablePrivate)) +{ +} + +bool QOpenGLExtension_EXT_color_subtable::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_color_subtable); + + d->CopyColorSubTableEXT = reinterpret_cast(context->getProcAddress("glCopyColorSubTableEXT")); + d->ColorSubTableEXT = reinterpret_cast(context->getProcAddress("glColorSubTableEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_compiled_vertex_array::QOpenGLExtension_EXT_compiled_vertex_array() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_compiled_vertex_arrayPrivate)) +{ +} + +bool QOpenGLExtension_EXT_compiled_vertex_array::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_compiled_vertex_array); + + d->UnlockArraysEXT = reinterpret_cast(context->getProcAddress("glUnlockArraysEXT")); + d->LockArraysEXT = reinterpret_cast(context->getProcAddress("glLockArraysEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_convolution::QOpenGLExtension_EXT_convolution() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_convolutionPrivate)) +{ +} + +bool QOpenGLExtension_EXT_convolution::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_convolution); + + d->SeparableFilter2DEXT = reinterpret_cast(context->getProcAddress("glSeparableFilter2DEXT")); + d->GetSeparableFilterEXT = reinterpret_cast(context->getProcAddress("glGetSeparableFilterEXT")); + d->GetConvolutionParameterivEXT = reinterpret_cast(context->getProcAddress("glGetConvolutionParameterivEXT")); + d->GetConvolutionParameterfvEXT = reinterpret_cast(context->getProcAddress("glGetConvolutionParameterfvEXT")); + d->GetConvolutionFilterEXT = reinterpret_cast(context->getProcAddress("glGetConvolutionFilterEXT")); + d->CopyConvolutionFilter2DEXT = reinterpret_cast(context->getProcAddress("glCopyConvolutionFilter2DEXT")); + d->CopyConvolutionFilter1DEXT = reinterpret_cast(context->getProcAddress("glCopyConvolutionFilter1DEXT")); + d->ConvolutionParameterivEXT = reinterpret_cast(context->getProcAddress("glConvolutionParameterivEXT")); + d->ConvolutionParameteriEXT = reinterpret_cast(context->getProcAddress("glConvolutionParameteriEXT")); + d->ConvolutionParameterfvEXT = reinterpret_cast(context->getProcAddress("glConvolutionParameterfvEXT")); + d->ConvolutionParameterfEXT = reinterpret_cast(context->getProcAddress("glConvolutionParameterfEXT")); + d->ConvolutionFilter2DEXT = reinterpret_cast(context->getProcAddress("glConvolutionFilter2DEXT")); + d->ConvolutionFilter1DEXT = reinterpret_cast(context->getProcAddress("glConvolutionFilter1DEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_coordinate_frame::QOpenGLExtension_EXT_coordinate_frame() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_coordinate_framePrivate)) +{ +} + +bool QOpenGLExtension_EXT_coordinate_frame::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_coordinate_frame); + + d->BinormalPointerEXT = reinterpret_cast(context->getProcAddress("glBinormalPointerEXT")); + d->TangentPointerEXT = reinterpret_cast(context->getProcAddress("glTangentPointerEXT")); + d->Binormal3svEXT = reinterpret_cast(context->getProcAddress("glBinormal3svEXT")); + d->Binormal3sEXT = reinterpret_cast(context->getProcAddress("glBinormal3sEXT")); + d->Binormal3ivEXT = reinterpret_cast(context->getProcAddress("glBinormal3ivEXT")); + d->Binormal3iEXT = reinterpret_cast(context->getProcAddress("glBinormal3iEXT")); + d->Binormal3fvEXT = reinterpret_cast(context->getProcAddress("glBinormal3fvEXT")); + d->Binormal3fEXT = reinterpret_cast(context->getProcAddress("glBinormal3fEXT")); + d->Binormal3dvEXT = reinterpret_cast(context->getProcAddress("glBinormal3dvEXT")); + d->Binormal3dEXT = reinterpret_cast(context->getProcAddress("glBinormal3dEXT")); + d->Binormal3bvEXT = reinterpret_cast(context->getProcAddress("glBinormal3bvEXT")); + d->Binormal3bEXT = reinterpret_cast(context->getProcAddress("glBinormal3bEXT")); + d->Tangent3svEXT = reinterpret_cast(context->getProcAddress("glTangent3svEXT")); + d->Tangent3sEXT = reinterpret_cast(context->getProcAddress("glTangent3sEXT")); + d->Tangent3ivEXT = reinterpret_cast(context->getProcAddress("glTangent3ivEXT")); + d->Tangent3iEXT = reinterpret_cast(context->getProcAddress("glTangent3iEXT")); + d->Tangent3fvEXT = reinterpret_cast(context->getProcAddress("glTangent3fvEXT")); + d->Tangent3fEXT = reinterpret_cast(context->getProcAddress("glTangent3fEXT")); + d->Tangent3dvEXT = reinterpret_cast(context->getProcAddress("glTangent3dvEXT")); + d->Tangent3dEXT = reinterpret_cast(context->getProcAddress("glTangent3dEXT")); + d->Tangent3bvEXT = reinterpret_cast(context->getProcAddress("glTangent3bvEXT")); + d->Tangent3bEXT = reinterpret_cast(context->getProcAddress("glTangent3bEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_copy_texture::QOpenGLExtension_EXT_copy_texture() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_copy_texturePrivate)) +{ +} + +bool QOpenGLExtension_EXT_copy_texture::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_copy_texture); + + d->CopyTexSubImage3DEXT = reinterpret_cast(context->getProcAddress("glCopyTexSubImage3DEXT")); + d->CopyTexSubImage2DEXT = reinterpret_cast(context->getProcAddress("glCopyTexSubImage2DEXT")); + d->CopyTexSubImage1DEXT = reinterpret_cast(context->getProcAddress("glCopyTexSubImage1DEXT")); + d->CopyTexImage2DEXT = reinterpret_cast(context->getProcAddress("glCopyTexImage2DEXT")); + d->CopyTexImage1DEXT = reinterpret_cast(context->getProcAddress("glCopyTexImage1DEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_cull_vertex::QOpenGLExtension_EXT_cull_vertex() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_cull_vertexPrivate)) +{ +} + +bool QOpenGLExtension_EXT_cull_vertex::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_cull_vertex); + + d->CullParameterfvEXT = reinterpret_cast(context->getProcAddress("glCullParameterfvEXT")); + d->CullParameterdvEXT = reinterpret_cast(context->getProcAddress("glCullParameterdvEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_depth_bounds_test::QOpenGLExtension_EXT_depth_bounds_test() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_depth_bounds_testPrivate)) +{ +} + +bool QOpenGLExtension_EXT_depth_bounds_test::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_depth_bounds_test); + + d->DepthBoundsEXT = reinterpret_cast(context->getProcAddress("glDepthBoundsEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_direct_state_access::QOpenGLExtension_EXT_direct_state_access() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_direct_state_accessPrivate)) +{ +} + +bool QOpenGLExtension_EXT_direct_state_access::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_direct_state_access); + + d->ProgramUniformMatrix4x3dvEXT = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix4x3dvEXT")); + d->ProgramUniformMatrix4x2dvEXT = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix4x2dvEXT")); + d->ProgramUniformMatrix3x4dvEXT = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix3x4dvEXT")); + d->ProgramUniformMatrix3x2dvEXT = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix3x2dvEXT")); + d->ProgramUniformMatrix2x4dvEXT = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix2x4dvEXT")); + d->ProgramUniformMatrix2x3dvEXT = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix2x3dvEXT")); + d->ProgramUniformMatrix4dvEXT = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix4dvEXT")); + d->ProgramUniformMatrix3dvEXT = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix3dvEXT")); + d->ProgramUniformMatrix2dvEXT = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix2dvEXT")); + d->ProgramUniform4dvEXT = reinterpret_cast(context->getProcAddress("glProgramUniform4dvEXT")); + d->ProgramUniform3dvEXT = reinterpret_cast(context->getProcAddress("glProgramUniform3dvEXT")); + d->ProgramUniform2dvEXT = reinterpret_cast(context->getProcAddress("glProgramUniform2dvEXT")); + d->ProgramUniform1dvEXT = reinterpret_cast(context->getProcAddress("glProgramUniform1dvEXT")); + d->ProgramUniform4dEXT = reinterpret_cast(context->getProcAddress("glProgramUniform4dEXT")); + d->ProgramUniform3dEXT = reinterpret_cast(context->getProcAddress("glProgramUniform3dEXT")); + d->ProgramUniform2dEXT = reinterpret_cast(context->getProcAddress("glProgramUniform2dEXT")); + d->ProgramUniform1dEXT = reinterpret_cast(context->getProcAddress("glProgramUniform1dEXT")); + d->MultiTexRenderbufferEXT = reinterpret_cast(context->getProcAddress("glMultiTexRenderbufferEXT")); + d->TextureRenderbufferEXT = reinterpret_cast(context->getProcAddress("glTextureRenderbufferEXT")); + d->NamedFramebufferTextureFaceEXT = reinterpret_cast(context->getProcAddress("glNamedFramebufferTextureFaceEXT")); + d->NamedFramebufferTextureLayerEXT = reinterpret_cast(context->getProcAddress("glNamedFramebufferTextureLayerEXT")); + d->NamedFramebufferTextureEXT = reinterpret_cast(context->getProcAddress("glNamedFramebufferTextureEXT")); + d->NamedRenderbufferStorageMultisampleCoverageEXT = reinterpret_cast(context->getProcAddress("glNamedRenderbufferStorageMultisampleCoverageEXT")); + d->NamedRenderbufferStorageMultisampleEXT = reinterpret_cast(context->getProcAddress("glNamedRenderbufferStorageMultisampleEXT")); + d->GetFramebufferParameterivEXT = reinterpret_cast(context->getProcAddress("glGetFramebufferParameterivEXT")); + d->FramebufferReadBufferEXT = reinterpret_cast(context->getProcAddress("glFramebufferReadBufferEXT")); + d->FramebufferDrawBuffersEXT = reinterpret_cast(context->getProcAddress("glFramebufferDrawBuffersEXT")); + d->FramebufferDrawBufferEXT = reinterpret_cast(context->getProcAddress("glFramebufferDrawBufferEXT")); + d->GenerateMultiTexMipmapEXT = reinterpret_cast(context->getProcAddress("glGenerateMultiTexMipmapEXT")); + d->GenerateTextureMipmapEXT = reinterpret_cast(context->getProcAddress("glGenerateTextureMipmapEXT")); + d->GetNamedFramebufferAttachmentParameterivEXT = reinterpret_cast(context->getProcAddress("glGetNamedFramebufferAttachmentParameterivEXT")); + d->NamedFramebufferRenderbufferEXT = reinterpret_cast(context->getProcAddress("glNamedFramebufferRenderbufferEXT")); + d->NamedFramebufferTexture3DEXT = reinterpret_cast(context->getProcAddress("glNamedFramebufferTexture3DEXT")); + d->NamedFramebufferTexture2DEXT = reinterpret_cast(context->getProcAddress("glNamedFramebufferTexture2DEXT")); + d->NamedFramebufferTexture1DEXT = reinterpret_cast(context->getProcAddress("glNamedFramebufferTexture1DEXT")); + d->CheckNamedFramebufferStatusEXT = reinterpret_cast(context->getProcAddress("glCheckNamedFramebufferStatusEXT")); + d->GetNamedRenderbufferParameterivEXT = reinterpret_cast(context->getProcAddress("glGetNamedRenderbufferParameterivEXT")); + d->NamedRenderbufferStorageEXT = reinterpret_cast(context->getProcAddress("glNamedRenderbufferStorageEXT")); + d->MultiTexBufferEXT = reinterpret_cast(context->getProcAddress("glMultiTexBufferEXT")); + d->TextureBufferEXT = reinterpret_cast(context->getProcAddress("glTextureBufferEXT")); + d->GetNamedBufferSubDataEXT = reinterpret_cast(context->getProcAddress("glGetNamedBufferSubDataEXT")); + d->GetNamedBufferPointervEXT = reinterpret_cast(context->getProcAddress("glGetNamedBufferPointervEXT")); + d->GetNamedBufferParameterivEXT = reinterpret_cast(context->getProcAddress("glGetNamedBufferParameterivEXT")); + d->NamedCopyBufferSubDataEXT = reinterpret_cast(context->getProcAddress("glNamedCopyBufferSubDataEXT")); + d->FlushMappedNamedBufferRangeEXT = reinterpret_cast(context->getProcAddress("glFlushMappedNamedBufferRangeEXT")); + d->MapNamedBufferRangeEXT = reinterpret_cast(context->getProcAddress("glMapNamedBufferRangeEXT")); + d->UnmapNamedBufferEXT = reinterpret_cast(context->getProcAddress("glUnmapNamedBufferEXT")); + d->MapNamedBufferEXT = reinterpret_cast(context->getProcAddress("glMapNamedBufferEXT")); + d->NamedBufferSubDataEXT = reinterpret_cast(context->getProcAddress("glNamedBufferSubDataEXT")); + d->NamedBufferDataEXT = reinterpret_cast(context->getProcAddress("glNamedBufferDataEXT")); + d->ProgramUniform4uivEXT = reinterpret_cast(context->getProcAddress("glProgramUniform4uivEXT")); + d->ProgramUniform3uivEXT = reinterpret_cast(context->getProcAddress("glProgramUniform3uivEXT")); + d->ProgramUniform2uivEXT = reinterpret_cast(context->getProcAddress("glProgramUniform2uivEXT")); + d->ProgramUniform1uivEXT = reinterpret_cast(context->getProcAddress("glProgramUniform1uivEXT")); + d->ProgramUniform4uiEXT = reinterpret_cast(context->getProcAddress("glProgramUniform4uiEXT")); + d->ProgramUniform3uiEXT = reinterpret_cast(context->getProcAddress("glProgramUniform3uiEXT")); + d->ProgramUniform2uiEXT = reinterpret_cast(context->getProcAddress("glProgramUniform2uiEXT")); + d->ProgramUniform1uiEXT = reinterpret_cast(context->getProcAddress("glProgramUniform1uiEXT")); + d->ProgramUniformMatrix4x3fvEXT = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix4x3fvEXT")); + d->ProgramUniformMatrix3x4fvEXT = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix3x4fvEXT")); + d->ProgramUniformMatrix4x2fvEXT = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix4x2fvEXT")); + d->ProgramUniformMatrix2x4fvEXT = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix2x4fvEXT")); + d->ProgramUniformMatrix3x2fvEXT = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix3x2fvEXT")); + d->ProgramUniformMatrix2x3fvEXT = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix2x3fvEXT")); + d->ProgramUniformMatrix4fvEXT = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix4fvEXT")); + d->ProgramUniformMatrix3fvEXT = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix3fvEXT")); + d->ProgramUniformMatrix2fvEXT = reinterpret_cast(context->getProcAddress("glProgramUniformMatrix2fvEXT")); + d->ProgramUniform4ivEXT = reinterpret_cast(context->getProcAddress("glProgramUniform4ivEXT")); + d->ProgramUniform3ivEXT = reinterpret_cast(context->getProcAddress("glProgramUniform3ivEXT")); + d->ProgramUniform2ivEXT = reinterpret_cast(context->getProcAddress("glProgramUniform2ivEXT")); + d->ProgramUniform1ivEXT = reinterpret_cast(context->getProcAddress("glProgramUniform1ivEXT")); + d->ProgramUniform4fvEXT = reinterpret_cast(context->getProcAddress("glProgramUniform4fvEXT")); + d->ProgramUniform3fvEXT = reinterpret_cast(context->getProcAddress("glProgramUniform3fvEXT")); + d->ProgramUniform2fvEXT = reinterpret_cast(context->getProcAddress("glProgramUniform2fvEXT")); + d->ProgramUniform1fvEXT = reinterpret_cast(context->getProcAddress("glProgramUniform1fvEXT")); + d->ProgramUniform4iEXT = reinterpret_cast(context->getProcAddress("glProgramUniform4iEXT")); + d->ProgramUniform3iEXT = reinterpret_cast(context->getProcAddress("glProgramUniform3iEXT")); + d->ProgramUniform2iEXT = reinterpret_cast(context->getProcAddress("glProgramUniform2iEXT")); + d->ProgramUniform1iEXT = reinterpret_cast(context->getProcAddress("glProgramUniform1iEXT")); + d->ProgramUniform4fEXT = reinterpret_cast(context->getProcAddress("glProgramUniform4fEXT")); + d->ProgramUniform3fEXT = reinterpret_cast(context->getProcAddress("glProgramUniform3fEXT")); + d->ProgramUniform2fEXT = reinterpret_cast(context->getProcAddress("glProgramUniform2fEXT")); + d->ProgramUniform1fEXT = reinterpret_cast(context->getProcAddress("glProgramUniform1fEXT")); + d->GetMultiTexParameterIuivEXT = reinterpret_cast(context->getProcAddress("glGetMultiTexParameterIuivEXT")); + d->GetMultiTexParameterIivEXT = reinterpret_cast(context->getProcAddress("glGetMultiTexParameterIivEXT")); + d->MultiTexParameterIuivEXT = reinterpret_cast(context->getProcAddress("glMultiTexParameterIuivEXT")); + d->MultiTexParameterIivEXT = reinterpret_cast(context->getProcAddress("glMultiTexParameterIivEXT")); + d->GetTextureParameterIuivEXT = reinterpret_cast(context->getProcAddress("glGetTextureParameterIuivEXT")); + d->GetTextureParameterIivEXT = reinterpret_cast(context->getProcAddress("glGetTextureParameterIivEXT")); + d->TextureParameterIuivEXT = reinterpret_cast(context->getProcAddress("glTextureParameterIuivEXT")); + d->TextureParameterIivEXT = reinterpret_cast(context->getProcAddress("glTextureParameterIivEXT")); + d->GetNamedProgramLocalParameterIuivEXT = reinterpret_cast(context->getProcAddress("glGetNamedProgramLocalParameterIuivEXT")); + d->GetNamedProgramLocalParameterIivEXT = reinterpret_cast(context->getProcAddress("glGetNamedProgramLocalParameterIivEXT")); + d->NamedProgramLocalParametersI4uivEXT = reinterpret_cast(context->getProcAddress("glNamedProgramLocalParametersI4uivEXT")); + d->NamedProgramLocalParameterI4uivEXT = reinterpret_cast(context->getProcAddress("glNamedProgramLocalParameterI4uivEXT")); + d->NamedProgramLocalParameterI4uiEXT = reinterpret_cast(context->getProcAddress("glNamedProgramLocalParameterI4uiEXT")); + d->NamedProgramLocalParametersI4ivEXT = reinterpret_cast(context->getProcAddress("glNamedProgramLocalParametersI4ivEXT")); + d->NamedProgramLocalParameterI4ivEXT = reinterpret_cast(context->getProcAddress("glNamedProgramLocalParameterI4ivEXT")); + d->NamedProgramLocalParameterI4iEXT = reinterpret_cast(context->getProcAddress("glNamedProgramLocalParameterI4iEXT")); + d->NamedProgramLocalParameters4fvEXT = reinterpret_cast(context->getProcAddress("glNamedProgramLocalParameters4fvEXT")); + d->GetNamedProgramStringEXT = reinterpret_cast(context->getProcAddress("glGetNamedProgramStringEXT")); + d->GetNamedProgramivEXT = reinterpret_cast(context->getProcAddress("glGetNamedProgramivEXT")); + d->GetNamedProgramLocalParameterfvEXT = reinterpret_cast(context->getProcAddress("glGetNamedProgramLocalParameterfvEXT")); + d->GetNamedProgramLocalParameterdvEXT = reinterpret_cast(context->getProcAddress("glGetNamedProgramLocalParameterdvEXT")); + d->NamedProgramLocalParameter4fvEXT = reinterpret_cast(context->getProcAddress("glNamedProgramLocalParameter4fvEXT")); + d->NamedProgramLocalParameter4fEXT = reinterpret_cast(context->getProcAddress("glNamedProgramLocalParameter4fEXT")); + d->NamedProgramLocalParameter4dvEXT = reinterpret_cast(context->getProcAddress("glNamedProgramLocalParameter4dvEXT")); + d->NamedProgramLocalParameter4dEXT = reinterpret_cast(context->getProcAddress("glNamedProgramLocalParameter4dEXT")); + d->NamedProgramStringEXT = reinterpret_cast(context->getProcAddress("glNamedProgramStringEXT")); + d->GetCompressedMultiTexImageEXT = reinterpret_cast(context->getProcAddress("glGetCompressedMultiTexImageEXT")); + d->CompressedMultiTexSubImage1DEXT = reinterpret_cast(context->getProcAddress("glCompressedMultiTexSubImage1DEXT")); + d->CompressedMultiTexSubImage2DEXT = reinterpret_cast(context->getProcAddress("glCompressedMultiTexSubImage2DEXT")); + d->CompressedMultiTexSubImage3DEXT = reinterpret_cast(context->getProcAddress("glCompressedMultiTexSubImage3DEXT")); + d->CompressedMultiTexImage1DEXT = reinterpret_cast(context->getProcAddress("glCompressedMultiTexImage1DEXT")); + d->CompressedMultiTexImage2DEXT = reinterpret_cast(context->getProcAddress("glCompressedMultiTexImage2DEXT")); + d->CompressedMultiTexImage3DEXT = reinterpret_cast(context->getProcAddress("glCompressedMultiTexImage3DEXT")); + d->GetCompressedTextureImageEXT = reinterpret_cast(context->getProcAddress("glGetCompressedTextureImageEXT")); + d->CompressedTextureSubImage1DEXT = reinterpret_cast(context->getProcAddress("glCompressedTextureSubImage1DEXT")); + d->CompressedTextureSubImage2DEXT = reinterpret_cast(context->getProcAddress("glCompressedTextureSubImage2DEXT")); + d->CompressedTextureSubImage3DEXT = reinterpret_cast(context->getProcAddress("glCompressedTextureSubImage3DEXT")); + d->CompressedTextureImage1DEXT = reinterpret_cast(context->getProcAddress("glCompressedTextureImage1DEXT")); + d->CompressedTextureImage2DEXT = reinterpret_cast(context->getProcAddress("glCompressedTextureImage2DEXT")); + d->CompressedTextureImage3DEXT = reinterpret_cast(context->getProcAddress("glCompressedTextureImage3DEXT")); + d->GetPointerIndexedvEXT = reinterpret_cast(context->getProcAddress("glGetPointerIndexedvEXT")); + d->GetDoubleIndexedvEXT = reinterpret_cast(context->getProcAddress("glGetDoubleIndexedvEXT")); + d->GetFloatIndexedvEXT = reinterpret_cast(context->getProcAddress("glGetFloatIndexedvEXT")); + d->GetMultiTexGenivEXT = reinterpret_cast(context->getProcAddress("glGetMultiTexGenivEXT")); + d->GetMultiTexGenfvEXT = reinterpret_cast(context->getProcAddress("glGetMultiTexGenfvEXT")); + d->GetMultiTexGendvEXT = reinterpret_cast(context->getProcAddress("glGetMultiTexGendvEXT")); + d->GetMultiTexEnvivEXT = reinterpret_cast(context->getProcAddress("glGetMultiTexEnvivEXT")); + d->GetMultiTexEnvfvEXT = reinterpret_cast(context->getProcAddress("glGetMultiTexEnvfvEXT")); + d->MultiTexGenivEXT = reinterpret_cast(context->getProcAddress("glMultiTexGenivEXT")); + d->MultiTexGeniEXT = reinterpret_cast(context->getProcAddress("glMultiTexGeniEXT")); + d->MultiTexGenfvEXT = reinterpret_cast(context->getProcAddress("glMultiTexGenfvEXT")); + d->MultiTexGenfEXT = reinterpret_cast(context->getProcAddress("glMultiTexGenfEXT")); + d->MultiTexGendvEXT = reinterpret_cast(context->getProcAddress("glMultiTexGendvEXT")); + d->MultiTexGendEXT = reinterpret_cast(context->getProcAddress("glMultiTexGendEXT")); + d->MultiTexEnvivEXT = reinterpret_cast(context->getProcAddress("glMultiTexEnvivEXT")); + d->MultiTexEnviEXT = reinterpret_cast(context->getProcAddress("glMultiTexEnviEXT")); + d->MultiTexEnvfvEXT = reinterpret_cast(context->getProcAddress("glMultiTexEnvfvEXT")); + d->MultiTexEnvfEXT = reinterpret_cast(context->getProcAddress("glMultiTexEnvfEXT")); + d->MultiTexCoordPointerEXT = reinterpret_cast(context->getProcAddress("glMultiTexCoordPointerEXT")); + d->DisableClientStateIndexedEXT = reinterpret_cast(context->getProcAddress("glDisableClientStateIndexedEXT")); + d->EnableClientStateIndexedEXT = reinterpret_cast(context->getProcAddress("glEnableClientStateIndexedEXT")); + d->BindMultiTextureEXT = reinterpret_cast(context->getProcAddress("glBindMultiTextureEXT")); + d->CopyMultiTexSubImage3DEXT = reinterpret_cast(context->getProcAddress("glCopyMultiTexSubImage3DEXT")); + d->MultiTexSubImage3DEXT = reinterpret_cast(context->getProcAddress("glMultiTexSubImage3DEXT")); + d->MultiTexImage3DEXT = reinterpret_cast(context->getProcAddress("glMultiTexImage3DEXT")); + d->GetMultiTexLevelParameterivEXT = reinterpret_cast(context->getProcAddress("glGetMultiTexLevelParameterivEXT")); + d->GetMultiTexLevelParameterfvEXT = reinterpret_cast(context->getProcAddress("glGetMultiTexLevelParameterfvEXT")); + d->GetMultiTexParameterivEXT = reinterpret_cast(context->getProcAddress("glGetMultiTexParameterivEXT")); + d->GetMultiTexParameterfvEXT = reinterpret_cast(context->getProcAddress("glGetMultiTexParameterfvEXT")); + d->GetMultiTexImageEXT = reinterpret_cast(context->getProcAddress("glGetMultiTexImageEXT")); + d->CopyMultiTexSubImage2DEXT = reinterpret_cast(context->getProcAddress("glCopyMultiTexSubImage2DEXT")); + d->CopyMultiTexSubImage1DEXT = reinterpret_cast(context->getProcAddress("glCopyMultiTexSubImage1DEXT")); + d->CopyMultiTexImage2DEXT = reinterpret_cast(context->getProcAddress("glCopyMultiTexImage2DEXT")); + d->CopyMultiTexImage1DEXT = reinterpret_cast(context->getProcAddress("glCopyMultiTexImage1DEXT")); + d->MultiTexSubImage2DEXT = reinterpret_cast(context->getProcAddress("glMultiTexSubImage2DEXT")); + d->MultiTexSubImage1DEXT = reinterpret_cast(context->getProcAddress("glMultiTexSubImage1DEXT")); + d->MultiTexImage2DEXT = reinterpret_cast(context->getProcAddress("glMultiTexImage2DEXT")); + d->MultiTexImage1DEXT = reinterpret_cast(context->getProcAddress("glMultiTexImage1DEXT")); + d->MultiTexParameterivEXT = reinterpret_cast(context->getProcAddress("glMultiTexParameterivEXT")); + d->MultiTexParameteriEXT = reinterpret_cast(context->getProcAddress("glMultiTexParameteriEXT")); + d->MultiTexParameterfvEXT = reinterpret_cast(context->getProcAddress("glMultiTexParameterfvEXT")); + d->MultiTexParameterfEXT = reinterpret_cast(context->getProcAddress("glMultiTexParameterfEXT")); + d->CopyTextureSubImage3DEXT = reinterpret_cast(context->getProcAddress("glCopyTextureSubImage3DEXT")); + d->TextureSubImage3DEXT = reinterpret_cast(context->getProcAddress("glTextureSubImage3DEXT")); + d->TextureImage3DEXT = reinterpret_cast(context->getProcAddress("glTextureImage3DEXT")); + d->GetTextureLevelParameterivEXT = reinterpret_cast(context->getProcAddress("glGetTextureLevelParameterivEXT")); + d->GetTextureLevelParameterfvEXT = reinterpret_cast(context->getProcAddress("glGetTextureLevelParameterfvEXT")); + d->GetTextureParameterivEXT = reinterpret_cast(context->getProcAddress("glGetTextureParameterivEXT")); + d->GetTextureParameterfvEXT = reinterpret_cast(context->getProcAddress("glGetTextureParameterfvEXT")); + d->GetTextureImageEXT = reinterpret_cast(context->getProcAddress("glGetTextureImageEXT")); + d->CopyTextureSubImage2DEXT = reinterpret_cast(context->getProcAddress("glCopyTextureSubImage2DEXT")); + d->CopyTextureSubImage1DEXT = reinterpret_cast(context->getProcAddress("glCopyTextureSubImage1DEXT")); + d->CopyTextureImage2DEXT = reinterpret_cast(context->getProcAddress("glCopyTextureImage2DEXT")); + d->CopyTextureImage1DEXT = reinterpret_cast(context->getProcAddress("glCopyTextureImage1DEXT")); + d->TextureSubImage2DEXT = reinterpret_cast(context->getProcAddress("glTextureSubImage2DEXT")); + d->TextureSubImage1DEXT = reinterpret_cast(context->getProcAddress("glTextureSubImage1DEXT")); + d->TextureImage2DEXT = reinterpret_cast(context->getProcAddress("glTextureImage2DEXT")); + d->TextureImage1DEXT = reinterpret_cast(context->getProcAddress("glTextureImage1DEXT")); + d->TextureParameterivEXT = reinterpret_cast(context->getProcAddress("glTextureParameterivEXT")); + d->TextureParameteriEXT = reinterpret_cast(context->getProcAddress("glTextureParameteriEXT")); + d->TextureParameterfvEXT = reinterpret_cast(context->getProcAddress("glTextureParameterfvEXT")); + d->TextureParameterfEXT = reinterpret_cast(context->getProcAddress("glTextureParameterfEXT")); + d->MatrixMultTransposedEXT = reinterpret_cast(context->getProcAddress("glMatrixMultTransposedEXT")); + d->MatrixMultTransposefEXT = reinterpret_cast(context->getProcAddress("glMatrixMultTransposefEXT")); + d->MatrixLoadTransposedEXT = reinterpret_cast(context->getProcAddress("glMatrixLoadTransposedEXT")); + d->MatrixLoadTransposefEXT = reinterpret_cast(context->getProcAddress("glMatrixLoadTransposefEXT")); + d->MatrixPushEXT = reinterpret_cast(context->getProcAddress("glMatrixPushEXT")); + d->MatrixPopEXT = reinterpret_cast(context->getProcAddress("glMatrixPopEXT")); + d->MatrixOrthoEXT = reinterpret_cast(context->getProcAddress("glMatrixOrthoEXT")); + d->MatrixFrustumEXT = reinterpret_cast(context->getProcAddress("glMatrixFrustumEXT")); + d->MatrixTranslatedEXT = reinterpret_cast(context->getProcAddress("glMatrixTranslatedEXT")); + d->MatrixTranslatefEXT = reinterpret_cast(context->getProcAddress("glMatrixTranslatefEXT")); + d->MatrixScaledEXT = reinterpret_cast(context->getProcAddress("glMatrixScaledEXT")); + d->MatrixScalefEXT = reinterpret_cast(context->getProcAddress("glMatrixScalefEXT")); + d->MatrixRotatedEXT = reinterpret_cast(context->getProcAddress("glMatrixRotatedEXT")); + d->MatrixRotatefEXT = reinterpret_cast(context->getProcAddress("glMatrixRotatefEXT")); + d->MatrixLoadIdentityEXT = reinterpret_cast(context->getProcAddress("glMatrixLoadIdentityEXT")); + d->MatrixMultdEXT = reinterpret_cast(context->getProcAddress("glMatrixMultdEXT")); + d->MatrixMultfEXT = reinterpret_cast(context->getProcAddress("glMatrixMultfEXT")); + d->MatrixLoaddEXT = reinterpret_cast(context->getProcAddress("glMatrixLoaddEXT")); + d->MatrixLoadfEXT = reinterpret_cast(context->getProcAddress("glMatrixLoadfEXT")); + d->PushClientAttribDefaultEXT = reinterpret_cast(context->getProcAddress("glPushClientAttribDefaultEXT")); + d->ClientAttribDefaultEXT = reinterpret_cast(context->getProcAddress("glClientAttribDefaultEXT")); + d->TextureStorage3DMultisampleEXT = reinterpret_cast(context->getProcAddress("glTextureStorage3DMultisampleEXT")); + d->TextureStorage2DMultisampleEXT = reinterpret_cast(context->getProcAddress("glTextureStorage2DMultisampleEXT")); + d->TextureBufferRangeEXT = reinterpret_cast(context->getProcAddress("glTextureBufferRangeEXT")); + d->GetNamedFramebufferParameterivEXT = reinterpret_cast(context->getProcAddress("glGetNamedFramebufferParameterivEXT")); + d->NamedFramebufferParameteriEXT = reinterpret_cast(context->getProcAddress("glNamedFramebufferParameteriEXT")); + d->VertexArrayVertexBindingDivisorEXT = reinterpret_cast(context->getProcAddress("glVertexArrayVertexBindingDivisorEXT")); + d->VertexArrayVertexAttribBindingEXT = reinterpret_cast(context->getProcAddress("glVertexArrayVertexAttribBindingEXT")); + d->VertexArrayVertexAttribLFormatEXT = reinterpret_cast(context->getProcAddress("glVertexArrayVertexAttribLFormatEXT")); + d->VertexArrayVertexAttribIFormatEXT = reinterpret_cast(context->getProcAddress("glVertexArrayVertexAttribIFormatEXT")); + d->VertexArrayVertexAttribFormatEXT = reinterpret_cast(context->getProcAddress("glVertexArrayVertexAttribFormatEXT")); + d->VertexArrayBindVertexBufferEXT = reinterpret_cast(context->getProcAddress("glVertexArrayBindVertexBufferEXT")); + d->ClearNamedBufferSubDataEXT = reinterpret_cast(context->getProcAddress("glClearNamedBufferSubDataEXT")); + d->ClearNamedBufferDataEXT = reinterpret_cast(context->getProcAddress("glClearNamedBufferDataEXT")); + d->TextureStorage3DEXT = reinterpret_cast(context->getProcAddress("glTextureStorage3DEXT")); + d->TextureStorage2DEXT = reinterpret_cast(context->getProcAddress("glTextureStorage2DEXT")); + d->TextureStorage1DEXT = reinterpret_cast(context->getProcAddress("glTextureStorage1DEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_draw_buffers2::QOpenGLExtension_EXT_draw_buffers2() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_draw_buffers2Private)) +{ +} + +bool QOpenGLExtension_EXT_draw_buffers2::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_draw_buffers2); + + d->IsEnabledIndexedEXT = reinterpret_cast(context->getProcAddress("glIsEnabledIndexedEXT")); + d->DisableIndexedEXT = reinterpret_cast(context->getProcAddress("glDisableIndexedEXT")); + d->EnableIndexedEXT = reinterpret_cast(context->getProcAddress("glEnableIndexedEXT")); + d->GetIntegerIndexedvEXT = reinterpret_cast(context->getProcAddress("glGetIntegerIndexedvEXT")); + d->GetBooleanIndexedvEXT = reinterpret_cast(context->getProcAddress("glGetBooleanIndexedvEXT")); + d->ColorMaskIndexedEXT = reinterpret_cast(context->getProcAddress("glColorMaskIndexedEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_draw_instanced::QOpenGLExtension_EXT_draw_instanced() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_draw_instancedPrivate)) +{ +} + +bool QOpenGLExtension_EXT_draw_instanced::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_draw_instanced); + + d->DrawElementsInstancedEXT = reinterpret_cast(context->getProcAddress("glDrawElementsInstancedEXT")); + d->DrawArraysInstancedEXT = reinterpret_cast(context->getProcAddress("glDrawArraysInstancedEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_draw_range_elements::QOpenGLExtension_EXT_draw_range_elements() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_draw_range_elementsPrivate)) +{ +} + +bool QOpenGLExtension_EXT_draw_range_elements::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_draw_range_elements); + + d->DrawRangeElementsEXT = reinterpret_cast(context->getProcAddress("glDrawRangeElementsEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_fog_coord::QOpenGLExtension_EXT_fog_coord() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_fog_coordPrivate)) +{ +} + +bool QOpenGLExtension_EXT_fog_coord::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_fog_coord); + + d->FogCoordPointerEXT = reinterpret_cast(context->getProcAddress("glFogCoordPointerEXT")); + d->FogCoorddvEXT = reinterpret_cast(context->getProcAddress("glFogCoorddvEXT")); + d->FogCoorddEXT = reinterpret_cast(context->getProcAddress("glFogCoorddEXT")); + d->FogCoordfvEXT = reinterpret_cast(context->getProcAddress("glFogCoordfvEXT")); + d->FogCoordfEXT = reinterpret_cast(context->getProcAddress("glFogCoordfEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_framebuffer_blit::QOpenGLExtension_EXT_framebuffer_blit() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_framebuffer_blitPrivate)) +{ +} + +bool QOpenGLExtension_EXT_framebuffer_blit::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_framebuffer_blit); + + d->BlitFramebufferEXT = reinterpret_cast(context->getProcAddress("glBlitFramebufferEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_framebuffer_multisample::QOpenGLExtension_EXT_framebuffer_multisample() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_framebuffer_multisamplePrivate)) +{ +} + +bool QOpenGLExtension_EXT_framebuffer_multisample::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_framebuffer_multisample); + + d->RenderbufferStorageMultisampleEXT = reinterpret_cast(context->getProcAddress("glRenderbufferStorageMultisampleEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_framebuffer_object::QOpenGLExtension_EXT_framebuffer_object() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_framebuffer_objectPrivate)) +{ +} + +bool QOpenGLExtension_EXT_framebuffer_object::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_framebuffer_object); + + d->GenerateMipmapEXT = reinterpret_cast(context->getProcAddress("glGenerateMipmapEXT")); + d->GetFramebufferAttachmentParameterivEXT = reinterpret_cast(context->getProcAddress("glGetFramebufferAttachmentParameterivEXT")); + d->FramebufferRenderbufferEXT = reinterpret_cast(context->getProcAddress("glFramebufferRenderbufferEXT")); + d->FramebufferTexture3DEXT = reinterpret_cast(context->getProcAddress("glFramebufferTexture3DEXT")); + d->FramebufferTexture2DEXT = reinterpret_cast(context->getProcAddress("glFramebufferTexture2DEXT")); + d->FramebufferTexture1DEXT = reinterpret_cast(context->getProcAddress("glFramebufferTexture1DEXT")); + d->CheckFramebufferStatusEXT = reinterpret_cast(context->getProcAddress("glCheckFramebufferStatusEXT")); + d->GenFramebuffersEXT = reinterpret_cast(context->getProcAddress("glGenFramebuffersEXT")); + d->DeleteFramebuffersEXT = reinterpret_cast(context->getProcAddress("glDeleteFramebuffersEXT")); + d->BindFramebufferEXT = reinterpret_cast(context->getProcAddress("glBindFramebufferEXT")); + d->IsFramebufferEXT = reinterpret_cast(context->getProcAddress("glIsFramebufferEXT")); + d->GetRenderbufferParameterivEXT = reinterpret_cast(context->getProcAddress("glGetRenderbufferParameterivEXT")); + d->RenderbufferStorageEXT = reinterpret_cast(context->getProcAddress("glRenderbufferStorageEXT")); + d->GenRenderbuffersEXT = reinterpret_cast(context->getProcAddress("glGenRenderbuffersEXT")); + d->DeleteRenderbuffersEXT = reinterpret_cast(context->getProcAddress("glDeleteRenderbuffersEXT")); + d->BindRenderbufferEXT = reinterpret_cast(context->getProcAddress("glBindRenderbufferEXT")); + d->IsRenderbufferEXT = reinterpret_cast(context->getProcAddress("glIsRenderbufferEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_geometry_shader4::QOpenGLExtension_EXT_geometry_shader4() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_geometry_shader4Private)) +{ +} + +bool QOpenGLExtension_EXT_geometry_shader4::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_geometry_shader4); + + d->ProgramParameteriEXT = reinterpret_cast(context->getProcAddress("glProgramParameteriEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_gpu_program_parameters::QOpenGLExtension_EXT_gpu_program_parameters() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_gpu_program_parametersPrivate)) +{ +} + +bool QOpenGLExtension_EXT_gpu_program_parameters::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_gpu_program_parameters); + + d->ProgramLocalParameters4fvEXT = reinterpret_cast(context->getProcAddress("glProgramLocalParameters4fvEXT")); + d->ProgramEnvParameters4fvEXT = reinterpret_cast(context->getProcAddress("glProgramEnvParameters4fvEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_gpu_shader4::QOpenGLExtension_EXT_gpu_shader4() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_gpu_shader4Private)) +{ +} + +bool QOpenGLExtension_EXT_gpu_shader4::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_gpu_shader4); + + d->Uniform4uivEXT = reinterpret_cast(context->getProcAddress("glUniform4uivEXT")); + d->Uniform3uivEXT = reinterpret_cast(context->getProcAddress("glUniform3uivEXT")); + d->Uniform2uivEXT = reinterpret_cast(context->getProcAddress("glUniform2uivEXT")); + d->Uniform1uivEXT = reinterpret_cast(context->getProcAddress("glUniform1uivEXT")); + d->Uniform4uiEXT = reinterpret_cast(context->getProcAddress("glUniform4uiEXT")); + d->Uniform3uiEXT = reinterpret_cast(context->getProcAddress("glUniform3uiEXT")); + d->Uniform2uiEXT = reinterpret_cast(context->getProcAddress("glUniform2uiEXT")); + d->Uniform1uiEXT = reinterpret_cast(context->getProcAddress("glUniform1uiEXT")); + d->GetFragDataLocationEXT = reinterpret_cast(context->getProcAddress("glGetFragDataLocationEXT")); + d->BindFragDataLocationEXT = reinterpret_cast(context->getProcAddress("glBindFragDataLocationEXT")); + d->GetUniformuivEXT = reinterpret_cast(context->getProcAddress("glGetUniformuivEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_histogram::QOpenGLExtension_EXT_histogram() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_histogramPrivate)) +{ +} + +bool QOpenGLExtension_EXT_histogram::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_histogram); + + d->ResetMinmaxEXT = reinterpret_cast(context->getProcAddress("glResetMinmaxEXT")); + d->ResetHistogramEXT = reinterpret_cast(context->getProcAddress("glResetHistogramEXT")); + d->MinmaxEXT = reinterpret_cast(context->getProcAddress("glMinmaxEXT")); + d->HistogramEXT = reinterpret_cast(context->getProcAddress("glHistogramEXT")); + d->GetMinmaxParameterivEXT = reinterpret_cast(context->getProcAddress("glGetMinmaxParameterivEXT")); + d->GetMinmaxParameterfvEXT = reinterpret_cast(context->getProcAddress("glGetMinmaxParameterfvEXT")); + d->GetMinmaxEXT = reinterpret_cast(context->getProcAddress("glGetMinmaxEXT")); + d->GetHistogramParameterivEXT = reinterpret_cast(context->getProcAddress("glGetHistogramParameterivEXT")); + d->GetHistogramParameterfvEXT = reinterpret_cast(context->getProcAddress("glGetHistogramParameterfvEXT")); + d->GetHistogramEXT = reinterpret_cast(context->getProcAddress("glGetHistogramEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_index_func::QOpenGLExtension_EXT_index_func() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_index_funcPrivate)) +{ +} + +bool QOpenGLExtension_EXT_index_func::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_index_func); + + d->IndexFuncEXT = reinterpret_cast(context->getProcAddress("glIndexFuncEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_index_material::QOpenGLExtension_EXT_index_material() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_index_materialPrivate)) +{ +} + +bool QOpenGLExtension_EXT_index_material::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_index_material); + + d->IndexMaterialEXT = reinterpret_cast(context->getProcAddress("glIndexMaterialEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_light_texture::QOpenGLExtension_EXT_light_texture() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_light_texturePrivate)) +{ +} + +bool QOpenGLExtension_EXT_light_texture::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_light_texture); + + d->TextureMaterialEXT = reinterpret_cast(context->getProcAddress("glTextureMaterialEXT")); + d->TextureLightEXT = reinterpret_cast(context->getProcAddress("glTextureLightEXT")); + d->ApplyTextureEXT = reinterpret_cast(context->getProcAddress("glApplyTextureEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_multi_draw_arrays::QOpenGLExtension_EXT_multi_draw_arrays() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_multi_draw_arraysPrivate)) +{ +} + +bool QOpenGLExtension_EXT_multi_draw_arrays::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_multi_draw_arrays); + + d->MultiDrawElementsEXT = reinterpret_cast(context->getProcAddress("glMultiDrawElementsEXT")); + d->MultiDrawArraysEXT = reinterpret_cast(context->getProcAddress("glMultiDrawArraysEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_multisample::QOpenGLExtension_EXT_multisample() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_multisamplePrivate)) +{ +} + +bool QOpenGLExtension_EXT_multisample::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_multisample); + + d->SamplePatternEXT = reinterpret_cast(context->getProcAddress("glSamplePatternEXT")); + d->SampleMaskEXT = reinterpret_cast(context->getProcAddress("glSampleMaskEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_paletted_texture::QOpenGLExtension_EXT_paletted_texture() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_paletted_texturePrivate)) +{ +} + +bool QOpenGLExtension_EXT_paletted_texture::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_paletted_texture); + + d->GetColorTableParameterfvEXT = reinterpret_cast(context->getProcAddress("glGetColorTableParameterfvEXT")); + d->GetColorTableParameterivEXT = reinterpret_cast(context->getProcAddress("glGetColorTableParameterivEXT")); + d->GetColorTableEXT = reinterpret_cast(context->getProcAddress("glGetColorTableEXT")); + d->ColorTableEXT = reinterpret_cast(context->getProcAddress("glColorTableEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_pixel_transform::QOpenGLExtension_EXT_pixel_transform() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_pixel_transformPrivate)) +{ +} + +bool QOpenGLExtension_EXT_pixel_transform::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_pixel_transform); + + d->GetPixelTransformParameterfvEXT = reinterpret_cast(context->getProcAddress("glGetPixelTransformParameterfvEXT")); + d->GetPixelTransformParameterivEXT = reinterpret_cast(context->getProcAddress("glGetPixelTransformParameterivEXT")); + d->PixelTransformParameterfvEXT = reinterpret_cast(context->getProcAddress("glPixelTransformParameterfvEXT")); + d->PixelTransformParameterivEXT = reinterpret_cast(context->getProcAddress("glPixelTransformParameterivEXT")); + d->PixelTransformParameterfEXT = reinterpret_cast(context->getProcAddress("glPixelTransformParameterfEXT")); + d->PixelTransformParameteriEXT = reinterpret_cast(context->getProcAddress("glPixelTransformParameteriEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_point_parameters::QOpenGLExtension_EXT_point_parameters() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_point_parametersPrivate)) +{ +} + +bool QOpenGLExtension_EXT_point_parameters::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_point_parameters); + + d->PointParameterfvEXT = reinterpret_cast(context->getProcAddress("glPointParameterfvEXT")); + d->PointParameterfEXT = reinterpret_cast(context->getProcAddress("glPointParameterfEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_polygon_offset::QOpenGLExtension_EXT_polygon_offset() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_polygon_offsetPrivate)) +{ +} + +bool QOpenGLExtension_EXT_polygon_offset::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_polygon_offset); + + d->PolygonOffsetEXT = reinterpret_cast(context->getProcAddress("glPolygonOffsetEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_provoking_vertex::QOpenGLExtension_EXT_provoking_vertex() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_provoking_vertexPrivate)) +{ +} + +bool QOpenGLExtension_EXT_provoking_vertex::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_provoking_vertex); + + d->ProvokingVertexEXT = reinterpret_cast(context->getProcAddress("glProvokingVertexEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_secondary_color::QOpenGLExtension_EXT_secondary_color() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_secondary_colorPrivate)) +{ +} + +bool QOpenGLExtension_EXT_secondary_color::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_secondary_color); + + d->SecondaryColorPointerEXT = reinterpret_cast(context->getProcAddress("glSecondaryColorPointerEXT")); + d->SecondaryColor3usvEXT = reinterpret_cast(context->getProcAddress("glSecondaryColor3usvEXT")); + d->SecondaryColor3usEXT = reinterpret_cast(context->getProcAddress("glSecondaryColor3usEXT")); + d->SecondaryColor3uivEXT = reinterpret_cast(context->getProcAddress("glSecondaryColor3uivEXT")); + d->SecondaryColor3uiEXT = reinterpret_cast(context->getProcAddress("glSecondaryColor3uiEXT")); + d->SecondaryColor3ubvEXT = reinterpret_cast(context->getProcAddress("glSecondaryColor3ubvEXT")); + d->SecondaryColor3ubEXT = reinterpret_cast(context->getProcAddress("glSecondaryColor3ubEXT")); + d->SecondaryColor3svEXT = reinterpret_cast(context->getProcAddress("glSecondaryColor3svEXT")); + d->SecondaryColor3sEXT = reinterpret_cast(context->getProcAddress("glSecondaryColor3sEXT")); + d->SecondaryColor3ivEXT = reinterpret_cast(context->getProcAddress("glSecondaryColor3ivEXT")); + d->SecondaryColor3iEXT = reinterpret_cast(context->getProcAddress("glSecondaryColor3iEXT")); + d->SecondaryColor3fvEXT = reinterpret_cast(context->getProcAddress("glSecondaryColor3fvEXT")); + d->SecondaryColor3fEXT = reinterpret_cast(context->getProcAddress("glSecondaryColor3fEXT")); + d->SecondaryColor3dvEXT = reinterpret_cast(context->getProcAddress("glSecondaryColor3dvEXT")); + d->SecondaryColor3dEXT = reinterpret_cast(context->getProcAddress("glSecondaryColor3dEXT")); + d->SecondaryColor3bvEXT = reinterpret_cast(context->getProcAddress("glSecondaryColor3bvEXT")); + d->SecondaryColor3bEXT = reinterpret_cast(context->getProcAddress("glSecondaryColor3bEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_separate_shader_objects::QOpenGLExtension_EXT_separate_shader_objects() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_separate_shader_objectsPrivate)) +{ +} + +bool QOpenGLExtension_EXT_separate_shader_objects::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_separate_shader_objects); + + d->CreateShaderProgramEXT = reinterpret_cast(context->getProcAddress("glCreateShaderProgramEXT")); + d->ActiveProgramEXT = reinterpret_cast(context->getProcAddress("glActiveProgramEXT")); + d->UseShaderProgramEXT = reinterpret_cast(context->getProcAddress("glUseShaderProgramEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_shader_image_load_store::QOpenGLExtension_EXT_shader_image_load_store() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_shader_image_load_storePrivate)) +{ +} + +bool QOpenGLExtension_EXT_shader_image_load_store::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_shader_image_load_store); + + d->MemoryBarrierEXT = reinterpret_cast(context->getProcAddress("glMemoryBarrierEXT")); + d->BindImageTextureEXT = reinterpret_cast(context->getProcAddress("glBindImageTextureEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_stencil_clear_tag::QOpenGLExtension_EXT_stencil_clear_tag() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_stencil_clear_tagPrivate)) +{ +} + +bool QOpenGLExtension_EXT_stencil_clear_tag::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_stencil_clear_tag); + + d->StencilClearTagEXT = reinterpret_cast(context->getProcAddress("glStencilClearTagEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_stencil_two_side::QOpenGLExtension_EXT_stencil_two_side() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_stencil_two_sidePrivate)) +{ +} + +bool QOpenGLExtension_EXT_stencil_two_side::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_stencil_two_side); + + d->ActiveStencilFaceEXT = reinterpret_cast(context->getProcAddress("glActiveStencilFaceEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_subtexture::QOpenGLExtension_EXT_subtexture() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_subtexturePrivate)) +{ +} + +bool QOpenGLExtension_EXT_subtexture::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_subtexture); + + d->TexSubImage2DEXT = reinterpret_cast(context->getProcAddress("glTexSubImage2DEXT")); + d->TexSubImage1DEXT = reinterpret_cast(context->getProcAddress("glTexSubImage1DEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_texture3D::QOpenGLExtension_EXT_texture3D() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_texture3DPrivate)) +{ +} + +bool QOpenGLExtension_EXT_texture3D::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_texture3D); + + d->TexSubImage3DEXT = reinterpret_cast(context->getProcAddress("glTexSubImage3DEXT")); + d->TexImage3DEXT = reinterpret_cast(context->getProcAddress("glTexImage3DEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_texture_buffer_object::QOpenGLExtension_EXT_texture_buffer_object() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_texture_buffer_objectPrivate)) +{ +} + +bool QOpenGLExtension_EXT_texture_buffer_object::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_texture_buffer_object); + + d->TexBufferEXT = reinterpret_cast(context->getProcAddress("glTexBufferEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_texture_integer::QOpenGLExtension_EXT_texture_integer() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_texture_integerPrivate)) +{ +} + +bool QOpenGLExtension_EXT_texture_integer::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_texture_integer); + + d->ClearColorIuiEXT = reinterpret_cast(context->getProcAddress("glClearColorIuiEXT")); + d->ClearColorIiEXT = reinterpret_cast(context->getProcAddress("glClearColorIiEXT")); + d->GetTexParameterIuivEXT = reinterpret_cast(context->getProcAddress("glGetTexParameterIuivEXT")); + d->GetTexParameterIivEXT = reinterpret_cast(context->getProcAddress("glGetTexParameterIivEXT")); + d->TexParameterIuivEXT = reinterpret_cast(context->getProcAddress("glTexParameterIuivEXT")); + d->TexParameterIivEXT = reinterpret_cast(context->getProcAddress("glTexParameterIivEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_texture_object::QOpenGLExtension_EXT_texture_object() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_texture_objectPrivate)) +{ +} + +bool QOpenGLExtension_EXT_texture_object::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_texture_object); + + d->PrioritizeTexturesEXT = reinterpret_cast(context->getProcAddress("glPrioritizeTexturesEXT")); + d->IsTextureEXT = reinterpret_cast(context->getProcAddress("glIsTextureEXT")); + d->GenTexturesEXT = reinterpret_cast(context->getProcAddress("glGenTexturesEXT")); + d->DeleteTexturesEXT = reinterpret_cast(context->getProcAddress("glDeleteTexturesEXT")); + d->BindTextureEXT = reinterpret_cast(context->getProcAddress("glBindTextureEXT")); + d->AreTexturesResidentEXT = reinterpret_cast(context->getProcAddress("glAreTexturesResidentEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_texture_perturb_normal::QOpenGLExtension_EXT_texture_perturb_normal() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_texture_perturb_normalPrivate)) +{ +} + +bool QOpenGLExtension_EXT_texture_perturb_normal::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_texture_perturb_normal); + + d->TextureNormalEXT = reinterpret_cast(context->getProcAddress("glTextureNormalEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_timer_query::QOpenGLExtension_EXT_timer_query() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_timer_queryPrivate)) +{ +} + +bool QOpenGLExtension_EXT_timer_query::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_timer_query); + + d->GetQueryObjectui64vEXT = reinterpret_cast(context->getProcAddress("glGetQueryObjectui64vEXT")); + d->GetQueryObjecti64vEXT = reinterpret_cast(context->getProcAddress("glGetQueryObjecti64vEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_transform_feedback::QOpenGLExtension_EXT_transform_feedback() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_transform_feedbackPrivate)) +{ +} + +bool QOpenGLExtension_EXT_transform_feedback::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_transform_feedback); + + d->GetTransformFeedbackVaryingEXT = reinterpret_cast(context->getProcAddress("glGetTransformFeedbackVaryingEXT")); + d->TransformFeedbackVaryingsEXT = reinterpret_cast(context->getProcAddress("glTransformFeedbackVaryingsEXT")); + d->BindBufferBaseEXT = reinterpret_cast(context->getProcAddress("glBindBufferBaseEXT")); + d->BindBufferOffsetEXT = reinterpret_cast(context->getProcAddress("glBindBufferOffsetEXT")); + d->BindBufferRangeEXT = reinterpret_cast(context->getProcAddress("glBindBufferRangeEXT")); + d->EndTransformFeedbackEXT = reinterpret_cast(context->getProcAddress("glEndTransformFeedbackEXT")); + d->BeginTransformFeedbackEXT = reinterpret_cast(context->getProcAddress("glBeginTransformFeedbackEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_vertex_array::QOpenGLExtension_EXT_vertex_array() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_vertex_arrayPrivate)) +{ +} + +bool QOpenGLExtension_EXT_vertex_array::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_vertex_array); + + d->VertexPointerEXT = reinterpret_cast(context->getProcAddress("glVertexPointerEXT")); + d->TexCoordPointerEXT = reinterpret_cast(context->getProcAddress("glTexCoordPointerEXT")); + d->NormalPointerEXT = reinterpret_cast(context->getProcAddress("glNormalPointerEXT")); + d->IndexPointerEXT = reinterpret_cast(context->getProcAddress("glIndexPointerEXT")); + d->GetPointervEXT = reinterpret_cast(context->getProcAddress("glGetPointervEXT")); + d->EdgeFlagPointerEXT = reinterpret_cast(context->getProcAddress("glEdgeFlagPointerEXT")); + d->DrawArraysEXT = reinterpret_cast(context->getProcAddress("glDrawArraysEXT")); + d->ColorPointerEXT = reinterpret_cast(context->getProcAddress("glColorPointerEXT")); + d->ArrayElementEXT = reinterpret_cast(context->getProcAddress("glArrayElementEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_vertex_attrib_64bit::QOpenGLExtension_EXT_vertex_attrib_64bit() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_vertex_attrib_64bitPrivate)) +{ +} + +bool QOpenGLExtension_EXT_vertex_attrib_64bit::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_vertex_attrib_64bit); + + d->VertexArrayVertexAttribLOffsetEXT = reinterpret_cast(context->getProcAddress("glVertexArrayVertexAttribLOffsetEXT")); + d->GetVertexAttribLdvEXT = reinterpret_cast(context->getProcAddress("glGetVertexAttribLdvEXT")); + d->VertexAttribLPointerEXT = reinterpret_cast(context->getProcAddress("glVertexAttribLPointerEXT")); + d->VertexAttribL4dvEXT = reinterpret_cast(context->getProcAddress("glVertexAttribL4dvEXT")); + d->VertexAttribL3dvEXT = reinterpret_cast(context->getProcAddress("glVertexAttribL3dvEXT")); + d->VertexAttribL2dvEXT = reinterpret_cast(context->getProcAddress("glVertexAttribL2dvEXT")); + d->VertexAttribL1dvEXT = reinterpret_cast(context->getProcAddress("glVertexAttribL1dvEXT")); + d->VertexAttribL4dEXT = reinterpret_cast(context->getProcAddress("glVertexAttribL4dEXT")); + d->VertexAttribL3dEXT = reinterpret_cast(context->getProcAddress("glVertexAttribL3dEXT")); + d->VertexAttribL2dEXT = reinterpret_cast(context->getProcAddress("glVertexAttribL2dEXT")); + d->VertexAttribL1dEXT = reinterpret_cast(context->getProcAddress("glVertexAttribL1dEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_vertex_shader::QOpenGLExtension_EXT_vertex_shader() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_vertex_shaderPrivate)) +{ +} + +bool QOpenGLExtension_EXT_vertex_shader::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_vertex_shader); + + d->GetLocalConstantFloatvEXT = reinterpret_cast(context->getProcAddress("glGetLocalConstantFloatvEXT")); + d->GetLocalConstantIntegervEXT = reinterpret_cast(context->getProcAddress("glGetLocalConstantIntegervEXT")); + d->GetLocalConstantBooleanvEXT = reinterpret_cast(context->getProcAddress("glGetLocalConstantBooleanvEXT")); + d->GetInvariantFloatvEXT = reinterpret_cast(context->getProcAddress("glGetInvariantFloatvEXT")); + d->GetInvariantIntegervEXT = reinterpret_cast(context->getProcAddress("glGetInvariantIntegervEXT")); + d->GetInvariantBooleanvEXT = reinterpret_cast(context->getProcAddress("glGetInvariantBooleanvEXT")); + d->GetVariantPointervEXT = reinterpret_cast(context->getProcAddress("glGetVariantPointervEXT")); + d->GetVariantFloatvEXT = reinterpret_cast(context->getProcAddress("glGetVariantFloatvEXT")); + d->GetVariantIntegervEXT = reinterpret_cast(context->getProcAddress("glGetVariantIntegervEXT")); + d->GetVariantBooleanvEXT = reinterpret_cast(context->getProcAddress("glGetVariantBooleanvEXT")); + d->IsVariantEnabledEXT = reinterpret_cast(context->getProcAddress("glIsVariantEnabledEXT")); + d->BindParameterEXT = reinterpret_cast(context->getProcAddress("glBindParameterEXT")); + d->BindTextureUnitParameterEXT = reinterpret_cast(context->getProcAddress("glBindTextureUnitParameterEXT")); + d->BindTexGenParameterEXT = reinterpret_cast(context->getProcAddress("glBindTexGenParameterEXT")); + d->BindMaterialParameterEXT = reinterpret_cast(context->getProcAddress("glBindMaterialParameterEXT")); + d->BindLightParameterEXT = reinterpret_cast(context->getProcAddress("glBindLightParameterEXT")); + d->DisableVariantClientStateEXT = reinterpret_cast(context->getProcAddress("glDisableVariantClientStateEXT")); + d->EnableVariantClientStateEXT = reinterpret_cast(context->getProcAddress("glEnableVariantClientStateEXT")); + d->VariantPointerEXT = reinterpret_cast(context->getProcAddress("glVariantPointerEXT")); + d->VariantuivEXT = reinterpret_cast(context->getProcAddress("glVariantuivEXT")); + d->VariantusvEXT = reinterpret_cast(context->getProcAddress("glVariantusvEXT")); + d->VariantubvEXT = reinterpret_cast(context->getProcAddress("glVariantubvEXT")); + d->VariantdvEXT = reinterpret_cast(context->getProcAddress("glVariantdvEXT")); + d->VariantfvEXT = reinterpret_cast(context->getProcAddress("glVariantfvEXT")); + d->VariantivEXT = reinterpret_cast(context->getProcAddress("glVariantivEXT")); + d->VariantsvEXT = reinterpret_cast(context->getProcAddress("glVariantsvEXT")); + d->VariantbvEXT = reinterpret_cast(context->getProcAddress("glVariantbvEXT")); + d->SetLocalConstantEXT = reinterpret_cast(context->getProcAddress("glSetLocalConstantEXT")); + d->SetInvariantEXT = reinterpret_cast(context->getProcAddress("glSetInvariantEXT")); + d->GenSymbolsEXT = reinterpret_cast(context->getProcAddress("glGenSymbolsEXT")); + d->ExtractComponentEXT = reinterpret_cast(context->getProcAddress("glExtractComponentEXT")); + d->InsertComponentEXT = reinterpret_cast(context->getProcAddress("glInsertComponentEXT")); + d->WriteMaskEXT = reinterpret_cast(context->getProcAddress("glWriteMaskEXT")); + d->SwizzleEXT = reinterpret_cast(context->getProcAddress("glSwizzleEXT")); + d->ShaderOp3EXT = reinterpret_cast(context->getProcAddress("glShaderOp3EXT")); + d->ShaderOp2EXT = reinterpret_cast(context->getProcAddress("glShaderOp2EXT")); + d->ShaderOp1EXT = reinterpret_cast(context->getProcAddress("glShaderOp1EXT")); + d->DeleteVertexShaderEXT = reinterpret_cast(context->getProcAddress("glDeleteVertexShaderEXT")); + d->GenVertexShadersEXT = reinterpret_cast(context->getProcAddress("glGenVertexShadersEXT")); + d->BindVertexShaderEXT = reinterpret_cast(context->getProcAddress("glBindVertexShaderEXT")); + d->EndVertexShaderEXT = reinterpret_cast(context->getProcAddress("glEndVertexShaderEXT")); + d->BeginVertexShaderEXT = reinterpret_cast(context->getProcAddress("glBeginVertexShaderEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_vertex_weighting::QOpenGLExtension_EXT_vertex_weighting() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_vertex_weightingPrivate)) +{ +} + +bool QOpenGLExtension_EXT_vertex_weighting::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_vertex_weighting); + + d->VertexWeightPointerEXT = reinterpret_cast(context->getProcAddress("glVertexWeightPointerEXT")); + d->VertexWeightfvEXT = reinterpret_cast(context->getProcAddress("glVertexWeightfvEXT")); + d->VertexWeightfEXT = reinterpret_cast(context->getProcAddress("glVertexWeightfEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_EXT_x11_sync_object::QOpenGLExtension_EXT_x11_sync_object() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_x11_sync_objectPrivate)) +{ +} + +bool QOpenGLExtension_EXT_x11_sync_object::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_x11_sync_object); + + d->ImportSyncEXT = reinterpret_cast(context->getProcAddress("glImportSyncEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_GREMEDY_frame_terminator::QOpenGLExtension_GREMEDY_frame_terminator() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_GREMEDY_frame_terminatorPrivate)) +{ +} + +bool QOpenGLExtension_GREMEDY_frame_terminator::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_GREMEDY_frame_terminator); + + d->FrameTerminatorGREMEDY = reinterpret_cast(context->getProcAddress("glFrameTerminatorGREMEDY")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_GREMEDY_string_marker::QOpenGLExtension_GREMEDY_string_marker() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_GREMEDY_string_markerPrivate)) +{ +} + +bool QOpenGLExtension_GREMEDY_string_marker::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_GREMEDY_string_marker); + + d->StringMarkerGREMEDY = reinterpret_cast(context->getProcAddress("glStringMarkerGREMEDY")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_HP_image_transform::QOpenGLExtension_HP_image_transform() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_HP_image_transformPrivate)) +{ +} + +bool QOpenGLExtension_HP_image_transform::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_HP_image_transform); + + d->GetImageTransformParameterfvHP = reinterpret_cast(context->getProcAddress("glGetImageTransformParameterfvHP")); + d->GetImageTransformParameterivHP = reinterpret_cast(context->getProcAddress("glGetImageTransformParameterivHP")); + d->ImageTransformParameterfvHP = reinterpret_cast(context->getProcAddress("glImageTransformParameterfvHP")); + d->ImageTransformParameterivHP = reinterpret_cast(context->getProcAddress("glImageTransformParameterivHP")); + d->ImageTransformParameterfHP = reinterpret_cast(context->getProcAddress("glImageTransformParameterfHP")); + d->ImageTransformParameteriHP = reinterpret_cast(context->getProcAddress("glImageTransformParameteriHP")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_IBM_multimode_draw_arrays::QOpenGLExtension_IBM_multimode_draw_arrays() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_IBM_multimode_draw_arraysPrivate)) +{ +} + +bool QOpenGLExtension_IBM_multimode_draw_arrays::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_IBM_multimode_draw_arrays); + + d->MultiModeDrawElementsIBM = reinterpret_cast(context->getProcAddress("glMultiModeDrawElementsIBM")); + d->MultiModeDrawArraysIBM = reinterpret_cast(context->getProcAddress("glMultiModeDrawArraysIBM")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_IBM_vertex_array_lists::QOpenGLExtension_IBM_vertex_array_lists() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_IBM_vertex_array_listsPrivate)) +{ +} + +bool QOpenGLExtension_IBM_vertex_array_lists::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_IBM_vertex_array_lists); + + d->VertexPointerListIBM = reinterpret_cast(context->getProcAddress("glVertexPointerListIBM")); + d->TexCoordPointerListIBM = reinterpret_cast(context->getProcAddress("glTexCoordPointerListIBM")); + d->NormalPointerListIBM = reinterpret_cast(context->getProcAddress("glNormalPointerListIBM")); + d->IndexPointerListIBM = reinterpret_cast(context->getProcAddress("glIndexPointerListIBM")); + d->FogCoordPointerListIBM = reinterpret_cast(context->getProcAddress("glFogCoordPointerListIBM")); + d->EdgeFlagPointerListIBM = reinterpret_cast(context->getProcAddress("glEdgeFlagPointerListIBM")); + d->SecondaryColorPointerListIBM = reinterpret_cast(context->getProcAddress("glSecondaryColorPointerListIBM")); + d->ColorPointerListIBM = reinterpret_cast(context->getProcAddress("glColorPointerListIBM")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_INGR_blend_func_separate::QOpenGLExtension_INGR_blend_func_separate() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_INGR_blend_func_separatePrivate)) +{ +} + +bool QOpenGLExtension_INGR_blend_func_separate::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_INGR_blend_func_separate); + + d->BlendFuncSeparateINGR = reinterpret_cast(context->getProcAddress("glBlendFuncSeparateINGR")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_INTEL_parallel_arrays::QOpenGLExtension_INTEL_parallel_arrays() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_INTEL_parallel_arraysPrivate)) +{ +} + +bool QOpenGLExtension_INTEL_parallel_arrays::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_INTEL_parallel_arrays); + + d->TexCoordPointervINTEL = reinterpret_cast(context->getProcAddress("glTexCoordPointervINTEL")); + d->ColorPointervINTEL = reinterpret_cast(context->getProcAddress("glColorPointervINTEL")); + d->NormalPointervINTEL = reinterpret_cast(context->getProcAddress("glNormalPointervINTEL")); + d->VertexPointervINTEL = reinterpret_cast(context->getProcAddress("glVertexPointervINTEL")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_KHR_debug::QOpenGLExtension_KHR_debug() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_KHR_debugPrivate)) +{ +} + +bool QOpenGLExtension_KHR_debug::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_KHR_debug); + + d->GetObjectPtrLabel = reinterpret_cast(context->getProcAddress("glGetObjectPtrLabel")); + d->ObjectPtrLabel = reinterpret_cast(context->getProcAddress("glObjectPtrLabel")); + d->GetObjectLabel = reinterpret_cast(context->getProcAddress("glGetObjectLabel")); + d->ObjectLabel = reinterpret_cast(context->getProcAddress("glObjectLabel")); + d->PopDebugGroup = reinterpret_cast(context->getProcAddress("glPopDebugGroup")); + d->PushDebugGroup = reinterpret_cast(context->getProcAddress("glPushDebugGroup")); + d->GetDebugMessageLog = reinterpret_cast(context->getProcAddress("glGetDebugMessageLog")); + d->DebugMessageCallback = reinterpret_cast(context->getProcAddress("glDebugMessageCallback")); + d->DebugMessageInsert = reinterpret_cast(context->getProcAddress("glDebugMessageInsert")); + d->DebugMessageControl = reinterpret_cast(context->getProcAddress("glDebugMessageControl")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_MESA_resize_buffers::QOpenGLExtension_MESA_resize_buffers() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_MESA_resize_buffersPrivate)) +{ +} + +bool QOpenGLExtension_MESA_resize_buffers::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_MESA_resize_buffers); + + d->ResizeBuffersMESA = reinterpret_cast(context->getProcAddress("glResizeBuffersMESA")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_MESA_window_pos::QOpenGLExtension_MESA_window_pos() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_MESA_window_posPrivate)) +{ +} + +bool QOpenGLExtension_MESA_window_pos::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_MESA_window_pos); + + d->WindowPos4svMESA = reinterpret_cast(context->getProcAddress("glWindowPos4svMESA")); + d->WindowPos4sMESA = reinterpret_cast(context->getProcAddress("glWindowPos4sMESA")); + d->WindowPos4ivMESA = reinterpret_cast(context->getProcAddress("glWindowPos4ivMESA")); + d->WindowPos4iMESA = reinterpret_cast(context->getProcAddress("glWindowPos4iMESA")); + d->WindowPos4fvMESA = reinterpret_cast(context->getProcAddress("glWindowPos4fvMESA")); + d->WindowPos4fMESA = reinterpret_cast(context->getProcAddress("glWindowPos4fMESA")); + d->WindowPos4dvMESA = reinterpret_cast(context->getProcAddress("glWindowPos4dvMESA")); + d->WindowPos4dMESA = reinterpret_cast(context->getProcAddress("glWindowPos4dMESA")); + d->WindowPos3svMESA = reinterpret_cast(context->getProcAddress("glWindowPos3svMESA")); + d->WindowPos3sMESA = reinterpret_cast(context->getProcAddress("glWindowPos3sMESA")); + d->WindowPos3ivMESA = reinterpret_cast(context->getProcAddress("glWindowPos3ivMESA")); + d->WindowPos3iMESA = reinterpret_cast(context->getProcAddress("glWindowPos3iMESA")); + d->WindowPos3fvMESA = reinterpret_cast(context->getProcAddress("glWindowPos3fvMESA")); + d->WindowPos3fMESA = reinterpret_cast(context->getProcAddress("glWindowPos3fMESA")); + d->WindowPos3dvMESA = reinterpret_cast(context->getProcAddress("glWindowPos3dvMESA")); + d->WindowPos3dMESA = reinterpret_cast(context->getProcAddress("glWindowPos3dMESA")); + d->WindowPos2svMESA = reinterpret_cast(context->getProcAddress("glWindowPos2svMESA")); + d->WindowPos2sMESA = reinterpret_cast(context->getProcAddress("glWindowPos2sMESA")); + d->WindowPos2ivMESA = reinterpret_cast(context->getProcAddress("glWindowPos2ivMESA")); + d->WindowPos2iMESA = reinterpret_cast(context->getProcAddress("glWindowPos2iMESA")); + d->WindowPos2fvMESA = reinterpret_cast(context->getProcAddress("glWindowPos2fvMESA")); + d->WindowPos2fMESA = reinterpret_cast(context->getProcAddress("glWindowPos2fMESA")); + d->WindowPos2dvMESA = reinterpret_cast(context->getProcAddress("glWindowPos2dvMESA")); + d->WindowPos2dMESA = reinterpret_cast(context->getProcAddress("glWindowPos2dMESA")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_bindless_texture::QOpenGLExtension_NV_bindless_texture() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_bindless_texturePrivate)) +{ +} + +bool QOpenGLExtension_NV_bindless_texture::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_bindless_texture); + + d->IsImageHandleResidentNV = reinterpret_cast(context->getProcAddress("glIsImageHandleResidentNV")); + d->IsTextureHandleResidentNV = reinterpret_cast(context->getProcAddress("glIsTextureHandleResidentNV")); + d->ProgramUniformHandleui64vNV = reinterpret_cast(context->getProcAddress("glProgramUniformHandleui64vNV")); + d->ProgramUniformHandleui64NV = reinterpret_cast(context->getProcAddress("glProgramUniformHandleui64NV")); + d->UniformHandleui64vNV = reinterpret_cast(context->getProcAddress("glUniformHandleui64vNV")); + d->UniformHandleui64NV = reinterpret_cast(context->getProcAddress("glUniformHandleui64NV")); + d->MakeImageHandleNonResidentNV = reinterpret_cast(context->getProcAddress("glMakeImageHandleNonResidentNV")); + d->MakeImageHandleResidentNV = reinterpret_cast(context->getProcAddress("glMakeImageHandleResidentNV")); + d->GetImageHandleNV = reinterpret_cast(context->getProcAddress("glGetImageHandleNV")); + d->MakeTextureHandleNonResidentNV = reinterpret_cast(context->getProcAddress("glMakeTextureHandleNonResidentNV")); + d->MakeTextureHandleResidentNV = reinterpret_cast(context->getProcAddress("glMakeTextureHandleResidentNV")); + d->GetTextureSamplerHandleNV = reinterpret_cast(context->getProcAddress("glGetTextureSamplerHandleNV")); + d->GetTextureHandleNV = reinterpret_cast(context->getProcAddress("glGetTextureHandleNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_conditional_render::QOpenGLExtension_NV_conditional_render() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_conditional_renderPrivate)) +{ +} + +bool QOpenGLExtension_NV_conditional_render::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_conditional_render); + + d->EndConditionalRenderNV = reinterpret_cast(context->getProcAddress("glEndConditionalRenderNV")); + d->BeginConditionalRenderNV = reinterpret_cast(context->getProcAddress("glBeginConditionalRenderNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_copy_image::QOpenGLExtension_NV_copy_image() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_copy_imagePrivate)) +{ +} + +bool QOpenGLExtension_NV_copy_image::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_copy_image); + + d->CopyImageSubDataNV = reinterpret_cast(context->getProcAddress("glCopyImageSubDataNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_depth_buffer_float::QOpenGLExtension_NV_depth_buffer_float() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_depth_buffer_floatPrivate)) +{ +} + +bool QOpenGLExtension_NV_depth_buffer_float::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_depth_buffer_float); + + d->DepthBoundsdNV = reinterpret_cast(context->getProcAddress("glDepthBoundsdNV")); + d->ClearDepthdNV = reinterpret_cast(context->getProcAddress("glClearDepthdNV")); + d->DepthRangedNV = reinterpret_cast(context->getProcAddress("glDepthRangedNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_evaluators::QOpenGLExtension_NV_evaluators() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_evaluatorsPrivate)) +{ +} + +bool QOpenGLExtension_NV_evaluators::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_evaluators); + + d->EvalMapsNV = reinterpret_cast(context->getProcAddress("glEvalMapsNV")); + d->GetMapAttribParameterfvNV = reinterpret_cast(context->getProcAddress("glGetMapAttribParameterfvNV")); + d->GetMapAttribParameterivNV = reinterpret_cast(context->getProcAddress("glGetMapAttribParameterivNV")); + d->GetMapParameterfvNV = reinterpret_cast(context->getProcAddress("glGetMapParameterfvNV")); + d->GetMapParameterivNV = reinterpret_cast(context->getProcAddress("glGetMapParameterivNV")); + d->GetMapControlPointsNV = reinterpret_cast(context->getProcAddress("glGetMapControlPointsNV")); + d->MapParameterfvNV = reinterpret_cast(context->getProcAddress("glMapParameterfvNV")); + d->MapParameterivNV = reinterpret_cast(context->getProcAddress("glMapParameterivNV")); + d->MapControlPointsNV = reinterpret_cast(context->getProcAddress("glMapControlPointsNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_explicit_multisample::QOpenGLExtension_NV_explicit_multisample() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_explicit_multisamplePrivate)) +{ +} + +bool QOpenGLExtension_NV_explicit_multisample::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_explicit_multisample); + + d->TexRenderbufferNV = reinterpret_cast(context->getProcAddress("glTexRenderbufferNV")); + d->SampleMaskIndexedNV = reinterpret_cast(context->getProcAddress("glSampleMaskIndexedNV")); + d->GetMultisamplefvNV = reinterpret_cast(context->getProcAddress("glGetMultisamplefvNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_fence::QOpenGLExtension_NV_fence() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_fencePrivate)) +{ +} + +bool QOpenGLExtension_NV_fence::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_fence); + + d->SetFenceNV = reinterpret_cast(context->getProcAddress("glSetFenceNV")); + d->FinishFenceNV = reinterpret_cast(context->getProcAddress("glFinishFenceNV")); + d->GetFenceivNV = reinterpret_cast(context->getProcAddress("glGetFenceivNV")); + d->TestFenceNV = reinterpret_cast(context->getProcAddress("glTestFenceNV")); + d->IsFenceNV = reinterpret_cast(context->getProcAddress("glIsFenceNV")); + d->GenFencesNV = reinterpret_cast(context->getProcAddress("glGenFencesNV")); + d->DeleteFencesNV = reinterpret_cast(context->getProcAddress("glDeleteFencesNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_fragment_program::QOpenGLExtension_NV_fragment_program() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_fragment_programPrivate)) +{ +} + +bool QOpenGLExtension_NV_fragment_program::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_fragment_program); + + d->GetProgramNamedParameterdvNV = reinterpret_cast(context->getProcAddress("glGetProgramNamedParameterdvNV")); + d->GetProgramNamedParameterfvNV = reinterpret_cast(context->getProcAddress("glGetProgramNamedParameterfvNV")); + d->ProgramNamedParameter4dvNV = reinterpret_cast(context->getProcAddress("glProgramNamedParameter4dvNV")); + d->ProgramNamedParameter4fvNV = reinterpret_cast(context->getProcAddress("glProgramNamedParameter4fvNV")); + d->ProgramNamedParameter4dNV = reinterpret_cast(context->getProcAddress("glProgramNamedParameter4dNV")); + d->ProgramNamedParameter4fNV = reinterpret_cast(context->getProcAddress("glProgramNamedParameter4fNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_framebuffer_multisample_coverage::QOpenGLExtension_NV_framebuffer_multisample_coverage() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_framebuffer_multisample_coveragePrivate)) +{ +} + +bool QOpenGLExtension_NV_framebuffer_multisample_coverage::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_framebuffer_multisample_coverage); + + d->RenderbufferStorageMultisampleCoverageNV = reinterpret_cast(context->getProcAddress("glRenderbufferStorageMultisampleCoverageNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_geometry_program4::QOpenGLExtension_NV_geometry_program4() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_geometry_program4Private)) +{ +} + +bool QOpenGLExtension_NV_geometry_program4::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_geometry_program4); + + d->FramebufferTextureFaceEXT = reinterpret_cast(context->getProcAddress("glFramebufferTextureFaceEXT")); + d->FramebufferTextureLayerEXT = reinterpret_cast(context->getProcAddress("glFramebufferTextureLayerEXT")); + d->FramebufferTextureEXT = reinterpret_cast(context->getProcAddress("glFramebufferTextureEXT")); + d->ProgramVertexLimitNV = reinterpret_cast(context->getProcAddress("glProgramVertexLimitNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_gpu_program4::QOpenGLExtension_NV_gpu_program4() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_gpu_program4Private)) +{ +} + +bool QOpenGLExtension_NV_gpu_program4::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_gpu_program4); + + d->GetProgramEnvParameterIuivNV = reinterpret_cast(context->getProcAddress("glGetProgramEnvParameterIuivNV")); + d->GetProgramEnvParameterIivNV = reinterpret_cast(context->getProcAddress("glGetProgramEnvParameterIivNV")); + d->GetProgramLocalParameterIuivNV = reinterpret_cast(context->getProcAddress("glGetProgramLocalParameterIuivNV")); + d->GetProgramLocalParameterIivNV = reinterpret_cast(context->getProcAddress("glGetProgramLocalParameterIivNV")); + d->ProgramEnvParametersI4uivNV = reinterpret_cast(context->getProcAddress("glProgramEnvParametersI4uivNV")); + d->ProgramEnvParameterI4uivNV = reinterpret_cast(context->getProcAddress("glProgramEnvParameterI4uivNV")); + d->ProgramEnvParameterI4uiNV = reinterpret_cast(context->getProcAddress("glProgramEnvParameterI4uiNV")); + d->ProgramEnvParametersI4ivNV = reinterpret_cast(context->getProcAddress("glProgramEnvParametersI4ivNV")); + d->ProgramEnvParameterI4ivNV = reinterpret_cast(context->getProcAddress("glProgramEnvParameterI4ivNV")); + d->ProgramEnvParameterI4iNV = reinterpret_cast(context->getProcAddress("glProgramEnvParameterI4iNV")); + d->ProgramLocalParametersI4uivNV = reinterpret_cast(context->getProcAddress("glProgramLocalParametersI4uivNV")); + d->ProgramLocalParameterI4uivNV = reinterpret_cast(context->getProcAddress("glProgramLocalParameterI4uivNV")); + d->ProgramLocalParameterI4uiNV = reinterpret_cast(context->getProcAddress("glProgramLocalParameterI4uiNV")); + d->ProgramLocalParametersI4ivNV = reinterpret_cast(context->getProcAddress("glProgramLocalParametersI4ivNV")); + d->ProgramLocalParameterI4ivNV = reinterpret_cast(context->getProcAddress("glProgramLocalParameterI4ivNV")); + d->ProgramLocalParameterI4iNV = reinterpret_cast(context->getProcAddress("glProgramLocalParameterI4iNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_gpu_program5::QOpenGLExtension_NV_gpu_program5() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_gpu_program5Private)) +{ +} + +bool QOpenGLExtension_NV_gpu_program5::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_gpu_program5); + + d->GetProgramSubroutineParameteruivNV = reinterpret_cast(context->getProcAddress("glGetProgramSubroutineParameteruivNV")); + d->ProgramSubroutineParametersuivNV = reinterpret_cast(context->getProcAddress("glProgramSubroutineParametersuivNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_gpu_shader5::QOpenGLExtension_NV_gpu_shader5() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_gpu_shader5Private)) +{ +} + +bool QOpenGLExtension_NV_gpu_shader5::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_gpu_shader5); + + d->ProgramUniform4ui64vNV = reinterpret_cast(context->getProcAddress("glProgramUniform4ui64vNV")); + d->ProgramUniform3ui64vNV = reinterpret_cast(context->getProcAddress("glProgramUniform3ui64vNV")); + d->ProgramUniform2ui64vNV = reinterpret_cast(context->getProcAddress("glProgramUniform2ui64vNV")); + d->ProgramUniform1ui64vNV = reinterpret_cast(context->getProcAddress("glProgramUniform1ui64vNV")); + d->ProgramUniform4ui64NV = reinterpret_cast(context->getProcAddress("glProgramUniform4ui64NV")); + d->ProgramUniform3ui64NV = reinterpret_cast(context->getProcAddress("glProgramUniform3ui64NV")); + d->ProgramUniform2ui64NV = reinterpret_cast(context->getProcAddress("glProgramUniform2ui64NV")); + d->ProgramUniform1ui64NV = reinterpret_cast(context->getProcAddress("glProgramUniform1ui64NV")); + d->ProgramUniform4i64vNV = reinterpret_cast(context->getProcAddress("glProgramUniform4i64vNV")); + d->ProgramUniform3i64vNV = reinterpret_cast(context->getProcAddress("glProgramUniform3i64vNV")); + d->ProgramUniform2i64vNV = reinterpret_cast(context->getProcAddress("glProgramUniform2i64vNV")); + d->ProgramUniform1i64vNV = reinterpret_cast(context->getProcAddress("glProgramUniform1i64vNV")); + d->ProgramUniform4i64NV = reinterpret_cast(context->getProcAddress("glProgramUniform4i64NV")); + d->ProgramUniform3i64NV = reinterpret_cast(context->getProcAddress("glProgramUniform3i64NV")); + d->ProgramUniform2i64NV = reinterpret_cast(context->getProcAddress("glProgramUniform2i64NV")); + d->ProgramUniform1i64NV = reinterpret_cast(context->getProcAddress("glProgramUniform1i64NV")); + d->GetUniformi64vNV = reinterpret_cast(context->getProcAddress("glGetUniformi64vNV")); + d->Uniform4ui64vNV = reinterpret_cast(context->getProcAddress("glUniform4ui64vNV")); + d->Uniform3ui64vNV = reinterpret_cast(context->getProcAddress("glUniform3ui64vNV")); + d->Uniform2ui64vNV = reinterpret_cast(context->getProcAddress("glUniform2ui64vNV")); + d->Uniform1ui64vNV = reinterpret_cast(context->getProcAddress("glUniform1ui64vNV")); + d->Uniform4ui64NV = reinterpret_cast(context->getProcAddress("glUniform4ui64NV")); + d->Uniform3ui64NV = reinterpret_cast(context->getProcAddress("glUniform3ui64NV")); + d->Uniform2ui64NV = reinterpret_cast(context->getProcAddress("glUniform2ui64NV")); + d->Uniform1ui64NV = reinterpret_cast(context->getProcAddress("glUniform1ui64NV")); + d->Uniform4i64vNV = reinterpret_cast(context->getProcAddress("glUniform4i64vNV")); + d->Uniform3i64vNV = reinterpret_cast(context->getProcAddress("glUniform3i64vNV")); + d->Uniform2i64vNV = reinterpret_cast(context->getProcAddress("glUniform2i64vNV")); + d->Uniform1i64vNV = reinterpret_cast(context->getProcAddress("glUniform1i64vNV")); + d->Uniform4i64NV = reinterpret_cast(context->getProcAddress("glUniform4i64NV")); + d->Uniform3i64NV = reinterpret_cast(context->getProcAddress("glUniform3i64NV")); + d->Uniform2i64NV = reinterpret_cast(context->getProcAddress("glUniform2i64NV")); + d->Uniform1i64NV = reinterpret_cast(context->getProcAddress("glUniform1i64NV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_half_float::QOpenGLExtension_NV_half_float() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_half_floatPrivate)) +{ +} + +bool QOpenGLExtension_NV_half_float::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_half_float); + + d->VertexAttribs4hvNV = reinterpret_cast(context->getProcAddress("glVertexAttribs4hvNV")); + d->VertexAttribs3hvNV = reinterpret_cast(context->getProcAddress("glVertexAttribs3hvNV")); + d->VertexAttribs2hvNV = reinterpret_cast(context->getProcAddress("glVertexAttribs2hvNV")); + d->VertexAttribs1hvNV = reinterpret_cast(context->getProcAddress("glVertexAttribs1hvNV")); + d->VertexAttrib4hvNV = reinterpret_cast(context->getProcAddress("glVertexAttrib4hvNV")); + d->VertexAttrib4hNV = reinterpret_cast(context->getProcAddress("glVertexAttrib4hNV")); + d->VertexAttrib3hvNV = reinterpret_cast(context->getProcAddress("glVertexAttrib3hvNV")); + d->VertexAttrib3hNV = reinterpret_cast(context->getProcAddress("glVertexAttrib3hNV")); + d->VertexAttrib2hvNV = reinterpret_cast(context->getProcAddress("glVertexAttrib2hvNV")); + d->VertexAttrib2hNV = reinterpret_cast(context->getProcAddress("glVertexAttrib2hNV")); + d->VertexAttrib1hvNV = reinterpret_cast(context->getProcAddress("glVertexAttrib1hvNV")); + d->VertexAttrib1hNV = reinterpret_cast(context->getProcAddress("glVertexAttrib1hNV")); + d->VertexWeighthvNV = reinterpret_cast(context->getProcAddress("glVertexWeighthvNV")); + d->VertexWeighthNV = reinterpret_cast(context->getProcAddress("glVertexWeighthNV")); + d->SecondaryColor3hvNV = reinterpret_cast(context->getProcAddress("glSecondaryColor3hvNV")); + d->SecondaryColor3hNV = reinterpret_cast(context->getProcAddress("glSecondaryColor3hNV")); + d->FogCoordhvNV = reinterpret_cast(context->getProcAddress("glFogCoordhvNV")); + d->FogCoordhNV = reinterpret_cast(context->getProcAddress("glFogCoordhNV")); + d->MultiTexCoord4hvNV = reinterpret_cast(context->getProcAddress("glMultiTexCoord4hvNV")); + d->MultiTexCoord4hNV = reinterpret_cast(context->getProcAddress("glMultiTexCoord4hNV")); + d->MultiTexCoord3hvNV = reinterpret_cast(context->getProcAddress("glMultiTexCoord3hvNV")); + d->MultiTexCoord3hNV = reinterpret_cast(context->getProcAddress("glMultiTexCoord3hNV")); + d->MultiTexCoord2hvNV = reinterpret_cast(context->getProcAddress("glMultiTexCoord2hvNV")); + d->MultiTexCoord2hNV = reinterpret_cast(context->getProcAddress("glMultiTexCoord2hNV")); + d->MultiTexCoord1hvNV = reinterpret_cast(context->getProcAddress("glMultiTexCoord1hvNV")); + d->MultiTexCoord1hNV = reinterpret_cast(context->getProcAddress("glMultiTexCoord1hNV")); + d->TexCoord4hvNV = reinterpret_cast(context->getProcAddress("glTexCoord4hvNV")); + d->TexCoord4hNV = reinterpret_cast(context->getProcAddress("glTexCoord4hNV")); + d->TexCoord3hvNV = reinterpret_cast(context->getProcAddress("glTexCoord3hvNV")); + d->TexCoord3hNV = reinterpret_cast(context->getProcAddress("glTexCoord3hNV")); + d->TexCoord2hvNV = reinterpret_cast(context->getProcAddress("glTexCoord2hvNV")); + d->TexCoord2hNV = reinterpret_cast(context->getProcAddress("glTexCoord2hNV")); + d->TexCoord1hvNV = reinterpret_cast(context->getProcAddress("glTexCoord1hvNV")); + d->TexCoord1hNV = reinterpret_cast(context->getProcAddress("glTexCoord1hNV")); + d->Color4hvNV = reinterpret_cast(context->getProcAddress("glColor4hvNV")); + d->Color4hNV = reinterpret_cast(context->getProcAddress("glColor4hNV")); + d->Color3hvNV = reinterpret_cast(context->getProcAddress("glColor3hvNV")); + d->Color3hNV = reinterpret_cast(context->getProcAddress("glColor3hNV")); + d->Normal3hvNV = reinterpret_cast(context->getProcAddress("glNormal3hvNV")); + d->Normal3hNV = reinterpret_cast(context->getProcAddress("glNormal3hNV")); + d->Vertex4hvNV = reinterpret_cast(context->getProcAddress("glVertex4hvNV")); + d->Vertex4hNV = reinterpret_cast(context->getProcAddress("glVertex4hNV")); + d->Vertex3hvNV = reinterpret_cast(context->getProcAddress("glVertex3hvNV")); + d->Vertex3hNV = reinterpret_cast(context->getProcAddress("glVertex3hNV")); + d->Vertex2hvNV = reinterpret_cast(context->getProcAddress("glVertex2hvNV")); + d->Vertex2hNV = reinterpret_cast(context->getProcAddress("glVertex2hNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_occlusion_query::QOpenGLExtension_NV_occlusion_query() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_occlusion_queryPrivate)) +{ +} + +bool QOpenGLExtension_NV_occlusion_query::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_occlusion_query); + + d->GetOcclusionQueryuivNV = reinterpret_cast(context->getProcAddress("glGetOcclusionQueryuivNV")); + d->GetOcclusionQueryivNV = reinterpret_cast(context->getProcAddress("glGetOcclusionQueryivNV")); + d->EndOcclusionQueryNV = reinterpret_cast(context->getProcAddress("glEndOcclusionQueryNV")); + d->BeginOcclusionQueryNV = reinterpret_cast(context->getProcAddress("glBeginOcclusionQueryNV")); + d->IsOcclusionQueryNV = reinterpret_cast(context->getProcAddress("glIsOcclusionQueryNV")); + d->DeleteOcclusionQueriesNV = reinterpret_cast(context->getProcAddress("glDeleteOcclusionQueriesNV")); + d->GenOcclusionQueriesNV = reinterpret_cast(context->getProcAddress("glGenOcclusionQueriesNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_parameter_buffer_object::QOpenGLExtension_NV_parameter_buffer_object() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_parameter_buffer_objectPrivate)) +{ +} + +bool QOpenGLExtension_NV_parameter_buffer_object::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_parameter_buffer_object); + + d->ProgramBufferParametersIuivNV = reinterpret_cast(context->getProcAddress("glProgramBufferParametersIuivNV")); + d->ProgramBufferParametersIivNV = reinterpret_cast(context->getProcAddress("glProgramBufferParametersIivNV")); + d->ProgramBufferParametersfvNV = reinterpret_cast(context->getProcAddress("glProgramBufferParametersfvNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_path_rendering::QOpenGLExtension_NV_path_rendering() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_path_renderingPrivate)) +{ +} + +bool QOpenGLExtension_NV_path_rendering::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_path_rendering); + + d->PointAlongPathNV = reinterpret_cast(context->getProcAddress("glPointAlongPathNV")); + d->GetPathLengthNV = reinterpret_cast(context->getProcAddress("glGetPathLengthNV")); + d->IsPointInStrokePathNV = reinterpret_cast(context->getProcAddress("glIsPointInStrokePathNV")); + d->IsPointInFillPathNV = reinterpret_cast(context->getProcAddress("glIsPointInFillPathNV")); + d->GetPathTexGenfvNV = reinterpret_cast(context->getProcAddress("glGetPathTexGenfvNV")); + d->GetPathTexGenivNV = reinterpret_cast(context->getProcAddress("glGetPathTexGenivNV")); + d->GetPathColorGenfvNV = reinterpret_cast(context->getProcAddress("glGetPathColorGenfvNV")); + d->GetPathColorGenivNV = reinterpret_cast(context->getProcAddress("glGetPathColorGenivNV")); + d->GetPathSpacingNV = reinterpret_cast(context->getProcAddress("glGetPathSpacingNV")); + d->GetPathMetricRangeNV = reinterpret_cast(context->getProcAddress("glGetPathMetricRangeNV")); + d->GetPathMetricsNV = reinterpret_cast(context->getProcAddress("glGetPathMetricsNV")); + d->GetPathDashArrayNV = reinterpret_cast(context->getProcAddress("glGetPathDashArrayNV")); + d->GetPathCoordsNV = reinterpret_cast(context->getProcAddress("glGetPathCoordsNV")); + d->GetPathCommandsNV = reinterpret_cast(context->getProcAddress("glGetPathCommandsNV")); + d->GetPathParameterfvNV = reinterpret_cast(context->getProcAddress("glGetPathParameterfvNV")); + d->GetPathParameterivNV = reinterpret_cast(context->getProcAddress("glGetPathParameterivNV")); + d->CoverStrokePathInstancedNV = reinterpret_cast(context->getProcAddress("glCoverStrokePathInstancedNV")); + d->CoverFillPathInstancedNV = reinterpret_cast(context->getProcAddress("glCoverFillPathInstancedNV")); + d->CoverStrokePathNV = reinterpret_cast(context->getProcAddress("glCoverStrokePathNV")); + d->CoverFillPathNV = reinterpret_cast(context->getProcAddress("glCoverFillPathNV")); + d->PathFogGenNV = reinterpret_cast(context->getProcAddress("glPathFogGenNV")); + d->PathTexGenNV = reinterpret_cast(context->getProcAddress("glPathTexGenNV")); + d->PathColorGenNV = reinterpret_cast(context->getProcAddress("glPathColorGenNV")); + d->PathCoverDepthFuncNV = reinterpret_cast(context->getProcAddress("glPathCoverDepthFuncNV")); + d->StencilStrokePathInstancedNV = reinterpret_cast(context->getProcAddress("glStencilStrokePathInstancedNV")); + d->StencilFillPathInstancedNV = reinterpret_cast(context->getProcAddress("glStencilFillPathInstancedNV")); + d->StencilStrokePathNV = reinterpret_cast(context->getProcAddress("glStencilStrokePathNV")); + d->StencilFillPathNV = reinterpret_cast(context->getProcAddress("glStencilFillPathNV")); + d->PathStencilDepthOffsetNV = reinterpret_cast(context->getProcAddress("glPathStencilDepthOffsetNV")); + d->PathStencilFuncNV = reinterpret_cast(context->getProcAddress("glPathStencilFuncNV")); + d->PathDashArrayNV = reinterpret_cast(context->getProcAddress("glPathDashArrayNV")); + d->PathParameterfNV = reinterpret_cast(context->getProcAddress("glPathParameterfNV")); + d->PathParameterfvNV = reinterpret_cast(context->getProcAddress("glPathParameterfvNV")); + d->PathParameteriNV = reinterpret_cast(context->getProcAddress("glPathParameteriNV")); + d->PathParameterivNV = reinterpret_cast(context->getProcAddress("glPathParameterivNV")); + d->TransformPathNV = reinterpret_cast(context->getProcAddress("glTransformPathNV")); + d->InterpolatePathsNV = reinterpret_cast(context->getProcAddress("glInterpolatePathsNV")); + d->CopyPathNV = reinterpret_cast(context->getProcAddress("glCopyPathNV")); + d->WeightPathsNV = reinterpret_cast(context->getProcAddress("glWeightPathsNV")); + d->PathGlyphRangeNV = reinterpret_cast(context->getProcAddress("glPathGlyphRangeNV")); + d->PathGlyphsNV = reinterpret_cast(context->getProcAddress("glPathGlyphsNV")); + d->PathStringNV = reinterpret_cast(context->getProcAddress("glPathStringNV")); + d->PathSubCoordsNV = reinterpret_cast(context->getProcAddress("glPathSubCoordsNV")); + d->PathSubCommandsNV = reinterpret_cast(context->getProcAddress("glPathSubCommandsNV")); + d->PathCoordsNV = reinterpret_cast(context->getProcAddress("glPathCoordsNV")); + d->PathCommandsNV = reinterpret_cast(context->getProcAddress("glPathCommandsNV")); + d->IsPathNV = reinterpret_cast(context->getProcAddress("glIsPathNV")); + d->DeletePathsNV = reinterpret_cast(context->getProcAddress("glDeletePathsNV")); + d->GenPathsNV = reinterpret_cast(context->getProcAddress("glGenPathsNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_pixel_data_range::QOpenGLExtension_NV_pixel_data_range() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_pixel_data_rangePrivate)) +{ +} + +bool QOpenGLExtension_NV_pixel_data_range::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_pixel_data_range); + + d->FlushPixelDataRangeNV = reinterpret_cast(context->getProcAddress("glFlushPixelDataRangeNV")); + d->PixelDataRangeNV = reinterpret_cast(context->getProcAddress("glPixelDataRangeNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_point_sprite::QOpenGLExtension_NV_point_sprite() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_point_spritePrivate)) +{ +} + +bool QOpenGLExtension_NV_point_sprite::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_point_sprite); + + d->PointParameterivNV = reinterpret_cast(context->getProcAddress("glPointParameterivNV")); + d->PointParameteriNV = reinterpret_cast(context->getProcAddress("glPointParameteriNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_present_video::QOpenGLExtension_NV_present_video() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_present_videoPrivate)) +{ +} + +bool QOpenGLExtension_NV_present_video::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_present_video); + + d->GetVideoui64vNV = reinterpret_cast(context->getProcAddress("glGetVideoui64vNV")); + d->GetVideoi64vNV = reinterpret_cast(context->getProcAddress("glGetVideoi64vNV")); + d->GetVideouivNV = reinterpret_cast(context->getProcAddress("glGetVideouivNV")); + d->GetVideoivNV = reinterpret_cast(context->getProcAddress("glGetVideoivNV")); + d->PresentFrameDualFillNV = reinterpret_cast(context->getProcAddress("glPresentFrameDualFillNV")); + d->PresentFrameKeyedNV = reinterpret_cast(context->getProcAddress("glPresentFrameKeyedNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_primitive_restart::QOpenGLExtension_NV_primitive_restart() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_primitive_restartPrivate)) +{ +} + +bool QOpenGLExtension_NV_primitive_restart::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_primitive_restart); + + d->PrimitiveRestartIndexNV = reinterpret_cast(context->getProcAddress("glPrimitiveRestartIndexNV")); + d->PrimitiveRestartNV = reinterpret_cast(context->getProcAddress("glPrimitiveRestartNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_register_combiners::QOpenGLExtension_NV_register_combiners() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_register_combinersPrivate)) +{ +} + +bool QOpenGLExtension_NV_register_combiners::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_register_combiners); + + d->GetFinalCombinerInputParameterivNV = reinterpret_cast(context->getProcAddress("glGetFinalCombinerInputParameterivNV")); + d->GetFinalCombinerInputParameterfvNV = reinterpret_cast(context->getProcAddress("glGetFinalCombinerInputParameterfvNV")); + d->GetCombinerOutputParameterivNV = reinterpret_cast(context->getProcAddress("glGetCombinerOutputParameterivNV")); + d->GetCombinerOutputParameterfvNV = reinterpret_cast(context->getProcAddress("glGetCombinerOutputParameterfvNV")); + d->GetCombinerInputParameterivNV = reinterpret_cast(context->getProcAddress("glGetCombinerInputParameterivNV")); + d->GetCombinerInputParameterfvNV = reinterpret_cast(context->getProcAddress("glGetCombinerInputParameterfvNV")); + d->FinalCombinerInputNV = reinterpret_cast(context->getProcAddress("glFinalCombinerInputNV")); + d->CombinerOutputNV = reinterpret_cast(context->getProcAddress("glCombinerOutputNV")); + d->CombinerInputNV = reinterpret_cast(context->getProcAddress("glCombinerInputNV")); + d->CombinerParameteriNV = reinterpret_cast(context->getProcAddress("glCombinerParameteriNV")); + d->CombinerParameterivNV = reinterpret_cast(context->getProcAddress("glCombinerParameterivNV")); + d->CombinerParameterfNV = reinterpret_cast(context->getProcAddress("glCombinerParameterfNV")); + d->CombinerParameterfvNV = reinterpret_cast(context->getProcAddress("glCombinerParameterfvNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_register_combiners2::QOpenGLExtension_NV_register_combiners2() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_register_combiners2Private)) +{ +} + +bool QOpenGLExtension_NV_register_combiners2::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_register_combiners2); + + d->GetCombinerStageParameterfvNV = reinterpret_cast(context->getProcAddress("glGetCombinerStageParameterfvNV")); + d->CombinerStageParameterfvNV = reinterpret_cast(context->getProcAddress("glCombinerStageParameterfvNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_shader_buffer_load::QOpenGLExtension_NV_shader_buffer_load() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_shader_buffer_loadPrivate)) +{ +} + +bool QOpenGLExtension_NV_shader_buffer_load::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_shader_buffer_load); + + d->ProgramUniformui64vNV = reinterpret_cast(context->getProcAddress("glProgramUniformui64vNV")); + d->ProgramUniformui64NV = reinterpret_cast(context->getProcAddress("glProgramUniformui64NV")); + d->GetUniformui64vNV = reinterpret_cast(context->getProcAddress("glGetUniformui64vNV")); + d->Uniformui64vNV = reinterpret_cast(context->getProcAddress("glUniformui64vNV")); + d->Uniformui64NV = reinterpret_cast(context->getProcAddress("glUniformui64NV")); + d->GetIntegerui64vNV = reinterpret_cast(context->getProcAddress("glGetIntegerui64vNV")); + d->GetNamedBufferParameterui64vNV = reinterpret_cast(context->getProcAddress("glGetNamedBufferParameterui64vNV")); + d->GetBufferParameterui64vNV = reinterpret_cast(context->getProcAddress("glGetBufferParameterui64vNV")); + d->IsNamedBufferResidentNV = reinterpret_cast(context->getProcAddress("glIsNamedBufferResidentNV")); + d->MakeNamedBufferNonResidentNV = reinterpret_cast(context->getProcAddress("glMakeNamedBufferNonResidentNV")); + d->MakeNamedBufferResidentNV = reinterpret_cast(context->getProcAddress("glMakeNamedBufferResidentNV")); + d->IsBufferResidentNV = reinterpret_cast(context->getProcAddress("glIsBufferResidentNV")); + d->MakeBufferNonResidentNV = reinterpret_cast(context->getProcAddress("glMakeBufferNonResidentNV")); + d->MakeBufferResidentNV = reinterpret_cast(context->getProcAddress("glMakeBufferResidentNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_texture_barrier::QOpenGLExtension_NV_texture_barrier() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_texture_barrierPrivate)) +{ +} + +bool QOpenGLExtension_NV_texture_barrier::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_texture_barrier); + + d->TextureBarrierNV = reinterpret_cast(context->getProcAddress("glTextureBarrierNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_texture_multisample::QOpenGLExtension_NV_texture_multisample() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_texture_multisamplePrivate)) +{ +} + +bool QOpenGLExtension_NV_texture_multisample::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_texture_multisample); + + d->TextureImage3DMultisampleCoverageNV = reinterpret_cast(context->getProcAddress("glTextureImage3DMultisampleCoverageNV")); + d->TextureImage2DMultisampleCoverageNV = reinterpret_cast(context->getProcAddress("glTextureImage2DMultisampleCoverageNV")); + d->TextureImage3DMultisampleNV = reinterpret_cast(context->getProcAddress("glTextureImage3DMultisampleNV")); + d->TextureImage2DMultisampleNV = reinterpret_cast(context->getProcAddress("glTextureImage2DMultisampleNV")); + d->TexImage3DMultisampleCoverageNV = reinterpret_cast(context->getProcAddress("glTexImage3DMultisampleCoverageNV")); + d->TexImage2DMultisampleCoverageNV = reinterpret_cast(context->getProcAddress("glTexImage2DMultisampleCoverageNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_transform_feedback::QOpenGLExtension_NV_transform_feedback() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_transform_feedbackPrivate)) +{ +} + +bool QOpenGLExtension_NV_transform_feedback::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_transform_feedback); + + d->TransformFeedbackStreamAttribsNV = reinterpret_cast(context->getProcAddress("glTransformFeedbackStreamAttribsNV")); + d->GetTransformFeedbackVaryingNV = reinterpret_cast(context->getProcAddress("glGetTransformFeedbackVaryingNV")); + d->GetActiveVaryingNV = reinterpret_cast(context->getProcAddress("glGetActiveVaryingNV")); + d->GetVaryingLocationNV = reinterpret_cast(context->getProcAddress("glGetVaryingLocationNV")); + d->ActiveVaryingNV = reinterpret_cast(context->getProcAddress("glActiveVaryingNV")); + d->TransformFeedbackVaryingsNV = reinterpret_cast(context->getProcAddress("glTransformFeedbackVaryingsNV")); + d->BindBufferBaseNV = reinterpret_cast(context->getProcAddress("glBindBufferBaseNV")); + d->BindBufferOffsetNV = reinterpret_cast(context->getProcAddress("glBindBufferOffsetNV")); + d->BindBufferRangeNV = reinterpret_cast(context->getProcAddress("glBindBufferRangeNV")); + d->TransformFeedbackAttribsNV = reinterpret_cast(context->getProcAddress("glTransformFeedbackAttribsNV")); + d->EndTransformFeedbackNV = reinterpret_cast(context->getProcAddress("glEndTransformFeedbackNV")); + d->BeginTransformFeedbackNV = reinterpret_cast(context->getProcAddress("glBeginTransformFeedbackNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_transform_feedback2::QOpenGLExtension_NV_transform_feedback2() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_transform_feedback2Private)) +{ +} + +bool QOpenGLExtension_NV_transform_feedback2::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_transform_feedback2); + + d->DrawTransformFeedbackNV = reinterpret_cast(context->getProcAddress("glDrawTransformFeedbackNV")); + d->ResumeTransformFeedbackNV = reinterpret_cast(context->getProcAddress("glResumeTransformFeedbackNV")); + d->PauseTransformFeedbackNV = reinterpret_cast(context->getProcAddress("glPauseTransformFeedbackNV")); + d->IsTransformFeedbackNV = reinterpret_cast(context->getProcAddress("glIsTransformFeedbackNV")); + d->GenTransformFeedbacksNV = reinterpret_cast(context->getProcAddress("glGenTransformFeedbacksNV")); + d->DeleteTransformFeedbacksNV = reinterpret_cast(context->getProcAddress("glDeleteTransformFeedbacksNV")); + d->BindTransformFeedbackNV = reinterpret_cast(context->getProcAddress("glBindTransformFeedbackNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_vdpau_interop::QOpenGLExtension_NV_vdpau_interop() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_vdpau_interopPrivate)) +{ +} + +bool QOpenGLExtension_NV_vdpau_interop::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_vdpau_interop); + + d->VDPAUUnmapSurfacesNV = reinterpret_cast(context->getProcAddress("glVDPAUUnmapSurfacesNV")); + d->VDPAUMapSurfacesNV = reinterpret_cast(context->getProcAddress("glVDPAUMapSurfacesNV")); + d->VDPAUSurfaceAccessNV = reinterpret_cast(context->getProcAddress("glVDPAUSurfaceAccessNV")); + d->VDPAUGetSurfaceivNV = reinterpret_cast(context->getProcAddress("glVDPAUGetSurfaceivNV")); + d->VDPAUUnregisterSurfaceNV = reinterpret_cast(context->getProcAddress("glVDPAUUnregisterSurfaceNV")); + d->VDPAUIsSurfaceNV = reinterpret_cast(context->getProcAddress("glVDPAUIsSurfaceNV")); + d->VDPAURegisterOutputSurfaceNV = reinterpret_cast(context->getProcAddress("glVDPAURegisterOutputSurfaceNV")); + d->VDPAURegisterVideoSurfaceNV = reinterpret_cast(context->getProcAddress("glVDPAURegisterVideoSurfaceNV")); + d->VDPAUFiniNV = reinterpret_cast(context->getProcAddress("glVDPAUFiniNV")); + d->VDPAUInitNV = reinterpret_cast(context->getProcAddress("glVDPAUInitNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_vertex_array_range::QOpenGLExtension_NV_vertex_array_range() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_vertex_array_rangePrivate)) +{ +} + +bool QOpenGLExtension_NV_vertex_array_range::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_vertex_array_range); + + d->VertexArrayRangeNV = reinterpret_cast(context->getProcAddress("glVertexArrayRangeNV")); + d->FlushVertexArrayRangeNV = reinterpret_cast(context->getProcAddress("glFlushVertexArrayRangeNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_vertex_attrib_integer_64bit::QOpenGLExtension_NV_vertex_attrib_integer_64bit() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_vertex_attrib_integer_64bitPrivate)) +{ +} + +bool QOpenGLExtension_NV_vertex_attrib_integer_64bit::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_vertex_attrib_integer_64bit); + + d->VertexAttribLFormatNV = reinterpret_cast(context->getProcAddress("glVertexAttribLFormatNV")); + d->GetVertexAttribLui64vNV = reinterpret_cast(context->getProcAddress("glGetVertexAttribLui64vNV")); + d->GetVertexAttribLi64vNV = reinterpret_cast(context->getProcAddress("glGetVertexAttribLi64vNV")); + d->VertexAttribL4ui64vNV = reinterpret_cast(context->getProcAddress("glVertexAttribL4ui64vNV")); + d->VertexAttribL3ui64vNV = reinterpret_cast(context->getProcAddress("glVertexAttribL3ui64vNV")); + d->VertexAttribL2ui64vNV = reinterpret_cast(context->getProcAddress("glVertexAttribL2ui64vNV")); + d->VertexAttribL1ui64vNV = reinterpret_cast(context->getProcAddress("glVertexAttribL1ui64vNV")); + d->VertexAttribL4ui64NV = reinterpret_cast(context->getProcAddress("glVertexAttribL4ui64NV")); + d->VertexAttribL3ui64NV = reinterpret_cast(context->getProcAddress("glVertexAttribL3ui64NV")); + d->VertexAttribL2ui64NV = reinterpret_cast(context->getProcAddress("glVertexAttribL2ui64NV")); + d->VertexAttribL1ui64NV = reinterpret_cast(context->getProcAddress("glVertexAttribL1ui64NV")); + d->VertexAttribL4i64vNV = reinterpret_cast(context->getProcAddress("glVertexAttribL4i64vNV")); + d->VertexAttribL3i64vNV = reinterpret_cast(context->getProcAddress("glVertexAttribL3i64vNV")); + d->VertexAttribL2i64vNV = reinterpret_cast(context->getProcAddress("glVertexAttribL2i64vNV")); + d->VertexAttribL1i64vNV = reinterpret_cast(context->getProcAddress("glVertexAttribL1i64vNV")); + d->VertexAttribL4i64NV = reinterpret_cast(context->getProcAddress("glVertexAttribL4i64NV")); + d->VertexAttribL3i64NV = reinterpret_cast(context->getProcAddress("glVertexAttribL3i64NV")); + d->VertexAttribL2i64NV = reinterpret_cast(context->getProcAddress("glVertexAttribL2i64NV")); + d->VertexAttribL1i64NV = reinterpret_cast(context->getProcAddress("glVertexAttribL1i64NV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_vertex_buffer_unified_memory::QOpenGLExtension_NV_vertex_buffer_unified_memory() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_vertex_buffer_unified_memoryPrivate)) +{ +} + +bool QOpenGLExtension_NV_vertex_buffer_unified_memory::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_vertex_buffer_unified_memory); + + d->GetIntegerui64i_vNV = reinterpret_cast(context->getProcAddress("glGetIntegerui64i_vNV")); + d->VertexAttribIFormatNV = reinterpret_cast(context->getProcAddress("glVertexAttribIFormatNV")); + d->VertexAttribFormatNV = reinterpret_cast(context->getProcAddress("glVertexAttribFormatNV")); + d->FogCoordFormatNV = reinterpret_cast(context->getProcAddress("glFogCoordFormatNV")); + d->SecondaryColorFormatNV = reinterpret_cast(context->getProcAddress("glSecondaryColorFormatNV")); + d->EdgeFlagFormatNV = reinterpret_cast(context->getProcAddress("glEdgeFlagFormatNV")); + d->TexCoordFormatNV = reinterpret_cast(context->getProcAddress("glTexCoordFormatNV")); + d->IndexFormatNV = reinterpret_cast(context->getProcAddress("glIndexFormatNV")); + d->ColorFormatNV = reinterpret_cast(context->getProcAddress("glColorFormatNV")); + d->NormalFormatNV = reinterpret_cast(context->getProcAddress("glNormalFormatNV")); + d->VertexFormatNV = reinterpret_cast(context->getProcAddress("glVertexFormatNV")); + d->BufferAddressRangeNV = reinterpret_cast(context->getProcAddress("glBufferAddressRangeNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_vertex_program::QOpenGLExtension_NV_vertex_program() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_vertex_programPrivate)) +{ +} + +bool QOpenGLExtension_NV_vertex_program::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_vertex_program); + + d->VertexAttribs4ubvNV = reinterpret_cast(context->getProcAddress("glVertexAttribs4ubvNV")); + d->VertexAttribs4svNV = reinterpret_cast(context->getProcAddress("glVertexAttribs4svNV")); + d->VertexAttribs4fvNV = reinterpret_cast(context->getProcAddress("glVertexAttribs4fvNV")); + d->VertexAttribs4dvNV = reinterpret_cast(context->getProcAddress("glVertexAttribs4dvNV")); + d->VertexAttribs3svNV = reinterpret_cast(context->getProcAddress("glVertexAttribs3svNV")); + d->VertexAttribs3fvNV = reinterpret_cast(context->getProcAddress("glVertexAttribs3fvNV")); + d->VertexAttribs3dvNV = reinterpret_cast(context->getProcAddress("glVertexAttribs3dvNV")); + d->VertexAttribs2svNV = reinterpret_cast(context->getProcAddress("glVertexAttribs2svNV")); + d->VertexAttribs2fvNV = reinterpret_cast(context->getProcAddress("glVertexAttribs2fvNV")); + d->VertexAttribs2dvNV = reinterpret_cast(context->getProcAddress("glVertexAttribs2dvNV")); + d->VertexAttribs1svNV = reinterpret_cast(context->getProcAddress("glVertexAttribs1svNV")); + d->VertexAttribs1fvNV = reinterpret_cast(context->getProcAddress("glVertexAttribs1fvNV")); + d->VertexAttribs1dvNV = reinterpret_cast(context->getProcAddress("glVertexAttribs1dvNV")); + d->VertexAttrib4ubvNV = reinterpret_cast(context->getProcAddress("glVertexAttrib4ubvNV")); + d->VertexAttrib4ubNV = reinterpret_cast(context->getProcAddress("glVertexAttrib4ubNV")); + d->VertexAttrib4svNV = reinterpret_cast(context->getProcAddress("glVertexAttrib4svNV")); + d->VertexAttrib4sNV = reinterpret_cast(context->getProcAddress("glVertexAttrib4sNV")); + d->VertexAttrib4fvNV = reinterpret_cast(context->getProcAddress("glVertexAttrib4fvNV")); + d->VertexAttrib4fNV = reinterpret_cast(context->getProcAddress("glVertexAttrib4fNV")); + d->VertexAttrib4dvNV = reinterpret_cast(context->getProcAddress("glVertexAttrib4dvNV")); + d->VertexAttrib4dNV = reinterpret_cast(context->getProcAddress("glVertexAttrib4dNV")); + d->VertexAttrib3svNV = reinterpret_cast(context->getProcAddress("glVertexAttrib3svNV")); + d->VertexAttrib3sNV = reinterpret_cast(context->getProcAddress("glVertexAttrib3sNV")); + d->VertexAttrib3fvNV = reinterpret_cast(context->getProcAddress("glVertexAttrib3fvNV")); + d->VertexAttrib3fNV = reinterpret_cast(context->getProcAddress("glVertexAttrib3fNV")); + d->VertexAttrib3dvNV = reinterpret_cast(context->getProcAddress("glVertexAttrib3dvNV")); + d->VertexAttrib3dNV = reinterpret_cast(context->getProcAddress("glVertexAttrib3dNV")); + d->VertexAttrib2svNV = reinterpret_cast(context->getProcAddress("glVertexAttrib2svNV")); + d->VertexAttrib2sNV = reinterpret_cast(context->getProcAddress("glVertexAttrib2sNV")); + d->VertexAttrib2fvNV = reinterpret_cast(context->getProcAddress("glVertexAttrib2fvNV")); + d->VertexAttrib2fNV = reinterpret_cast(context->getProcAddress("glVertexAttrib2fNV")); + d->VertexAttrib2dvNV = reinterpret_cast(context->getProcAddress("glVertexAttrib2dvNV")); + d->VertexAttrib2dNV = reinterpret_cast(context->getProcAddress("glVertexAttrib2dNV")); + d->VertexAttrib1svNV = reinterpret_cast(context->getProcAddress("glVertexAttrib1svNV")); + d->VertexAttrib1sNV = reinterpret_cast(context->getProcAddress("glVertexAttrib1sNV")); + d->VertexAttrib1fvNV = reinterpret_cast(context->getProcAddress("glVertexAttrib1fvNV")); + d->VertexAttrib1fNV = reinterpret_cast(context->getProcAddress("glVertexAttrib1fNV")); + d->VertexAttrib1dvNV = reinterpret_cast(context->getProcAddress("glVertexAttrib1dvNV")); + d->VertexAttrib1dNV = reinterpret_cast(context->getProcAddress("glVertexAttrib1dNV")); + d->VertexAttribPointerNV = reinterpret_cast(context->getProcAddress("glVertexAttribPointerNV")); + d->TrackMatrixNV = reinterpret_cast(context->getProcAddress("glTrackMatrixNV")); + d->RequestResidentProgramsNV = reinterpret_cast(context->getProcAddress("glRequestResidentProgramsNV")); + d->ProgramParameters4fvNV = reinterpret_cast(context->getProcAddress("glProgramParameters4fvNV")); + d->ProgramParameters4dvNV = reinterpret_cast(context->getProcAddress("glProgramParameters4dvNV")); + d->ProgramParameter4fvNV = reinterpret_cast(context->getProcAddress("glProgramParameter4fvNV")); + d->ProgramParameter4fNV = reinterpret_cast(context->getProcAddress("glProgramParameter4fNV")); + d->ProgramParameter4dvNV = reinterpret_cast(context->getProcAddress("glProgramParameter4dvNV")); + d->ProgramParameter4dNV = reinterpret_cast(context->getProcAddress("glProgramParameter4dNV")); + d->LoadProgramNV = reinterpret_cast(context->getProcAddress("glLoadProgramNV")); + d->IsProgramNV = reinterpret_cast(context->getProcAddress("glIsProgramNV")); + d->GetVertexAttribPointervNV = reinterpret_cast(context->getProcAddress("glGetVertexAttribPointervNV")); + d->GetVertexAttribivNV = reinterpret_cast(context->getProcAddress("glGetVertexAttribivNV")); + d->GetVertexAttribfvNV = reinterpret_cast(context->getProcAddress("glGetVertexAttribfvNV")); + d->GetVertexAttribdvNV = reinterpret_cast(context->getProcAddress("glGetVertexAttribdvNV")); + d->GetTrackMatrixivNV = reinterpret_cast(context->getProcAddress("glGetTrackMatrixivNV")); + d->GetProgramStringNV = reinterpret_cast(context->getProcAddress("glGetProgramStringNV")); + d->GetProgramivNV = reinterpret_cast(context->getProcAddress("glGetProgramivNV")); + d->GetProgramParameterfvNV = reinterpret_cast(context->getProcAddress("glGetProgramParameterfvNV")); + d->GetProgramParameterdvNV = reinterpret_cast(context->getProcAddress("glGetProgramParameterdvNV")); + d->GenProgramsNV = reinterpret_cast(context->getProcAddress("glGenProgramsNV")); + d->ExecuteProgramNV = reinterpret_cast(context->getProcAddress("glExecuteProgramNV")); + d->DeleteProgramsNV = reinterpret_cast(context->getProcAddress("glDeleteProgramsNV")); + d->BindProgramNV = reinterpret_cast(context->getProcAddress("glBindProgramNV")); + d->AreProgramsResidentNV = reinterpret_cast(context->getProcAddress("glAreProgramsResidentNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_vertex_program4::QOpenGLExtension_NV_vertex_program4() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_vertex_program4Private)) +{ +} + +bool QOpenGLExtension_NV_vertex_program4::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_vertex_program4); + + d->GetVertexAttribIuivEXT = reinterpret_cast(context->getProcAddress("glGetVertexAttribIuivEXT")); + d->GetVertexAttribIivEXT = reinterpret_cast(context->getProcAddress("glGetVertexAttribIivEXT")); + d->VertexAttribIPointerEXT = reinterpret_cast(context->getProcAddress("glVertexAttribIPointerEXT")); + d->VertexAttribI4usvEXT = reinterpret_cast(context->getProcAddress("glVertexAttribI4usvEXT")); + d->VertexAttribI4ubvEXT = reinterpret_cast(context->getProcAddress("glVertexAttribI4ubvEXT")); + d->VertexAttribI4svEXT = reinterpret_cast(context->getProcAddress("glVertexAttribI4svEXT")); + d->VertexAttribI4bvEXT = reinterpret_cast(context->getProcAddress("glVertexAttribI4bvEXT")); + d->VertexAttribI4uivEXT = reinterpret_cast(context->getProcAddress("glVertexAttribI4uivEXT")); + d->VertexAttribI3uivEXT = reinterpret_cast(context->getProcAddress("glVertexAttribI3uivEXT")); + d->VertexAttribI2uivEXT = reinterpret_cast(context->getProcAddress("glVertexAttribI2uivEXT")); + d->VertexAttribI1uivEXT = reinterpret_cast(context->getProcAddress("glVertexAttribI1uivEXT")); + d->VertexAttribI4ivEXT = reinterpret_cast(context->getProcAddress("glVertexAttribI4ivEXT")); + d->VertexAttribI3ivEXT = reinterpret_cast(context->getProcAddress("glVertexAttribI3ivEXT")); + d->VertexAttribI2ivEXT = reinterpret_cast(context->getProcAddress("glVertexAttribI2ivEXT")); + d->VertexAttribI1ivEXT = reinterpret_cast(context->getProcAddress("glVertexAttribI1ivEXT")); + d->VertexAttribI4uiEXT = reinterpret_cast(context->getProcAddress("glVertexAttribI4uiEXT")); + d->VertexAttribI3uiEXT = reinterpret_cast(context->getProcAddress("glVertexAttribI3uiEXT")); + d->VertexAttribI2uiEXT = reinterpret_cast(context->getProcAddress("glVertexAttribI2uiEXT")); + d->VertexAttribI1uiEXT = reinterpret_cast(context->getProcAddress("glVertexAttribI1uiEXT")); + d->VertexAttribI4iEXT = reinterpret_cast(context->getProcAddress("glVertexAttribI4iEXT")); + d->VertexAttribI3iEXT = reinterpret_cast(context->getProcAddress("glVertexAttribI3iEXT")); + d->VertexAttribI2iEXT = reinterpret_cast(context->getProcAddress("glVertexAttribI2iEXT")); + d->VertexAttribI1iEXT = reinterpret_cast(context->getProcAddress("glVertexAttribI1iEXT")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_NV_video_capture::QOpenGLExtension_NV_video_capture() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_video_capturePrivate)) +{ +} + +bool QOpenGLExtension_NV_video_capture::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_video_capture); + + d->VideoCaptureStreamParameterdvNV = reinterpret_cast(context->getProcAddress("glVideoCaptureStreamParameterdvNV")); + d->VideoCaptureStreamParameterfvNV = reinterpret_cast(context->getProcAddress("glVideoCaptureStreamParameterfvNV")); + d->VideoCaptureStreamParameterivNV = reinterpret_cast(context->getProcAddress("glVideoCaptureStreamParameterivNV")); + d->VideoCaptureNV = reinterpret_cast(context->getProcAddress("glVideoCaptureNV")); + d->GetVideoCaptureStreamdvNV = reinterpret_cast(context->getProcAddress("glGetVideoCaptureStreamdvNV")); + d->GetVideoCaptureStreamfvNV = reinterpret_cast(context->getProcAddress("glGetVideoCaptureStreamfvNV")); + d->GetVideoCaptureStreamivNV = reinterpret_cast(context->getProcAddress("glGetVideoCaptureStreamivNV")); + d->GetVideoCaptureivNV = reinterpret_cast(context->getProcAddress("glGetVideoCaptureivNV")); + d->EndVideoCaptureNV = reinterpret_cast(context->getProcAddress("glEndVideoCaptureNV")); + d->BindVideoCaptureStreamTextureNV = reinterpret_cast(context->getProcAddress("glBindVideoCaptureStreamTextureNV")); + d->BindVideoCaptureStreamBufferNV = reinterpret_cast(context->getProcAddress("glBindVideoCaptureStreamBufferNV")); + d->BeginVideoCaptureNV = reinterpret_cast(context->getProcAddress("glBeginVideoCaptureNV")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_PGI_misc_hints::QOpenGLExtension_PGI_misc_hints() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_PGI_misc_hintsPrivate)) +{ +} + +bool QOpenGLExtension_PGI_misc_hints::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_PGI_misc_hints); + + d->HintPGI = reinterpret_cast(context->getProcAddress("glHintPGI")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SGIS_detail_texture::QOpenGLExtension_SGIS_detail_texture() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SGIS_detail_texturePrivate)) +{ +} + +bool QOpenGLExtension_SGIS_detail_texture::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SGIS_detail_texture); + + d->GetDetailTexFuncSGIS = reinterpret_cast(context->getProcAddress("glGetDetailTexFuncSGIS")); + d->DetailTexFuncSGIS = reinterpret_cast(context->getProcAddress("glDetailTexFuncSGIS")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SGIS_fog_function::QOpenGLExtension_SGIS_fog_function() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SGIS_fog_functionPrivate)) +{ +} + +bool QOpenGLExtension_SGIS_fog_function::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SGIS_fog_function); + + d->GetFogFuncSGIS = reinterpret_cast(context->getProcAddress("glGetFogFuncSGIS")); + d->FogFuncSGIS = reinterpret_cast(context->getProcAddress("glFogFuncSGIS")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SGIS_multisample::QOpenGLExtension_SGIS_multisample() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SGIS_multisamplePrivate)) +{ +} + +bool QOpenGLExtension_SGIS_multisample::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SGIS_multisample); + + d->SamplePatternSGIS = reinterpret_cast(context->getProcAddress("glSamplePatternSGIS")); + d->SampleMaskSGIS = reinterpret_cast(context->getProcAddress("glSampleMaskSGIS")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SGIS_pixel_texture::QOpenGLExtension_SGIS_pixel_texture() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SGIS_pixel_texturePrivate)) +{ +} + +bool QOpenGLExtension_SGIS_pixel_texture::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SGIS_pixel_texture); + + d->GetPixelTexGenParameterfvSGIS = reinterpret_cast(context->getProcAddress("glGetPixelTexGenParameterfvSGIS")); + d->GetPixelTexGenParameterivSGIS = reinterpret_cast(context->getProcAddress("glGetPixelTexGenParameterivSGIS")); + d->PixelTexGenParameterfvSGIS = reinterpret_cast(context->getProcAddress("glPixelTexGenParameterfvSGIS")); + d->PixelTexGenParameterfSGIS = reinterpret_cast(context->getProcAddress("glPixelTexGenParameterfSGIS")); + d->PixelTexGenParameterivSGIS = reinterpret_cast(context->getProcAddress("glPixelTexGenParameterivSGIS")); + d->PixelTexGenParameteriSGIS = reinterpret_cast(context->getProcAddress("glPixelTexGenParameteriSGIS")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SGIS_point_parameters::QOpenGLExtension_SGIS_point_parameters() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SGIS_point_parametersPrivate)) +{ +} + +bool QOpenGLExtension_SGIS_point_parameters::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SGIS_point_parameters); + + d->PointParameterfvSGIS = reinterpret_cast(context->getProcAddress("glPointParameterfvSGIS")); + d->PointParameterfSGIS = reinterpret_cast(context->getProcAddress("glPointParameterfSGIS")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SGIS_sharpen_texture::QOpenGLExtension_SGIS_sharpen_texture() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SGIS_sharpen_texturePrivate)) +{ +} + +bool QOpenGLExtension_SGIS_sharpen_texture::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SGIS_sharpen_texture); + + d->GetSharpenTexFuncSGIS = reinterpret_cast(context->getProcAddress("glGetSharpenTexFuncSGIS")); + d->SharpenTexFuncSGIS = reinterpret_cast(context->getProcAddress("glSharpenTexFuncSGIS")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SGIS_texture4D::QOpenGLExtension_SGIS_texture4D() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SGIS_texture4DPrivate)) +{ +} + +bool QOpenGLExtension_SGIS_texture4D::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SGIS_texture4D); + + d->TexSubImage4DSGIS = reinterpret_cast(context->getProcAddress("glTexSubImage4DSGIS")); + d->TexImage4DSGIS = reinterpret_cast(context->getProcAddress("glTexImage4DSGIS")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SGIS_texture_color_mask::QOpenGLExtension_SGIS_texture_color_mask() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SGIS_texture_color_maskPrivate)) +{ +} + +bool QOpenGLExtension_SGIS_texture_color_mask::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SGIS_texture_color_mask); + + d->TextureColorMaskSGIS = reinterpret_cast(context->getProcAddress("glTextureColorMaskSGIS")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SGIS_texture_filter4::QOpenGLExtension_SGIS_texture_filter4() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SGIS_texture_filter4Private)) +{ +} + +bool QOpenGLExtension_SGIS_texture_filter4::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SGIS_texture_filter4); + + d->TexFilterFuncSGIS = reinterpret_cast(context->getProcAddress("glTexFilterFuncSGIS")); + d->GetTexFilterFuncSGIS = reinterpret_cast(context->getProcAddress("glGetTexFilterFuncSGIS")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SGIX_async::QOpenGLExtension_SGIX_async() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SGIX_asyncPrivate)) +{ +} + +bool QOpenGLExtension_SGIX_async::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SGIX_async); + + d->IsAsyncMarkerSGIX = reinterpret_cast(context->getProcAddress("glIsAsyncMarkerSGIX")); + d->DeleteAsyncMarkersSGIX = reinterpret_cast(context->getProcAddress("glDeleteAsyncMarkersSGIX")); + d->GenAsyncMarkersSGIX = reinterpret_cast(context->getProcAddress("glGenAsyncMarkersSGIX")); + d->PollAsyncSGIX = reinterpret_cast(context->getProcAddress("glPollAsyncSGIX")); + d->FinishAsyncSGIX = reinterpret_cast(context->getProcAddress("glFinishAsyncSGIX")); + d->AsyncMarkerSGIX = reinterpret_cast(context->getProcAddress("glAsyncMarkerSGIX")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SGIX_flush_raster::QOpenGLExtension_SGIX_flush_raster() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SGIX_flush_rasterPrivate)) +{ +} + +bool QOpenGLExtension_SGIX_flush_raster::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SGIX_flush_raster); + + d->FlushRasterSGIX = reinterpret_cast(context->getProcAddress("glFlushRasterSGIX")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SGIX_fragment_lighting::QOpenGLExtension_SGIX_fragment_lighting() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SGIX_fragment_lightingPrivate)) +{ +} + +bool QOpenGLExtension_SGIX_fragment_lighting::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SGIX_fragment_lighting); + + d->LightEnviSGIX = reinterpret_cast(context->getProcAddress("glLightEnviSGIX")); + d->GetFragmentMaterialivSGIX = reinterpret_cast(context->getProcAddress("glGetFragmentMaterialivSGIX")); + d->GetFragmentMaterialfvSGIX = reinterpret_cast(context->getProcAddress("glGetFragmentMaterialfvSGIX")); + d->GetFragmentLightivSGIX = reinterpret_cast(context->getProcAddress("glGetFragmentLightivSGIX")); + d->GetFragmentLightfvSGIX = reinterpret_cast(context->getProcAddress("glGetFragmentLightfvSGIX")); + d->FragmentMaterialivSGIX = reinterpret_cast(context->getProcAddress("glFragmentMaterialivSGIX")); + d->FragmentMaterialiSGIX = reinterpret_cast(context->getProcAddress("glFragmentMaterialiSGIX")); + d->FragmentMaterialfvSGIX = reinterpret_cast(context->getProcAddress("glFragmentMaterialfvSGIX")); + d->FragmentMaterialfSGIX = reinterpret_cast(context->getProcAddress("glFragmentMaterialfSGIX")); + d->FragmentLightModelivSGIX = reinterpret_cast(context->getProcAddress("glFragmentLightModelivSGIX")); + d->FragmentLightModeliSGIX = reinterpret_cast(context->getProcAddress("glFragmentLightModeliSGIX")); + d->FragmentLightModelfvSGIX = reinterpret_cast(context->getProcAddress("glFragmentLightModelfvSGIX")); + d->FragmentLightModelfSGIX = reinterpret_cast(context->getProcAddress("glFragmentLightModelfSGIX")); + d->FragmentLightivSGIX = reinterpret_cast(context->getProcAddress("glFragmentLightivSGIX")); + d->FragmentLightiSGIX = reinterpret_cast(context->getProcAddress("glFragmentLightiSGIX")); + d->FragmentLightfvSGIX = reinterpret_cast(context->getProcAddress("glFragmentLightfvSGIX")); + d->FragmentLightfSGIX = reinterpret_cast(context->getProcAddress("glFragmentLightfSGIX")); + d->FragmentColorMaterialSGIX = reinterpret_cast(context->getProcAddress("glFragmentColorMaterialSGIX")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SGIX_framezoom::QOpenGLExtension_SGIX_framezoom() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SGIX_framezoomPrivate)) +{ +} + +bool QOpenGLExtension_SGIX_framezoom::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SGIX_framezoom); + + d->FrameZoomSGIX = reinterpret_cast(context->getProcAddress("glFrameZoomSGIX")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SGIX_igloo_interface::QOpenGLExtension_SGIX_igloo_interface() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SGIX_igloo_interfacePrivate)) +{ +} + +bool QOpenGLExtension_SGIX_igloo_interface::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SGIX_igloo_interface); + + d->IglooInterfaceSGIX = reinterpret_cast(context->getProcAddress("glIglooInterfaceSGIX")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SGIX_instruments::QOpenGLExtension_SGIX_instruments() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SGIX_instrumentsPrivate)) +{ +} + +bool QOpenGLExtension_SGIX_instruments::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SGIX_instruments); + + d->StopInstrumentsSGIX = reinterpret_cast(context->getProcAddress("glStopInstrumentsSGIX")); + d->StartInstrumentsSGIX = reinterpret_cast(context->getProcAddress("glStartInstrumentsSGIX")); + d->ReadInstrumentsSGIX = reinterpret_cast(context->getProcAddress("glReadInstrumentsSGIX")); + d->PollInstrumentsSGIX = reinterpret_cast(context->getProcAddress("glPollInstrumentsSGIX")); + d->InstrumentsBufferSGIX = reinterpret_cast(context->getProcAddress("glInstrumentsBufferSGIX")); + d->GetInstrumentsSGIX = reinterpret_cast(context->getProcAddress("glGetInstrumentsSGIX")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SGIX_list_priority::QOpenGLExtension_SGIX_list_priority() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SGIX_list_priorityPrivate)) +{ +} + +bool QOpenGLExtension_SGIX_list_priority::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SGIX_list_priority); + + d->ListParameterivSGIX = reinterpret_cast(context->getProcAddress("glListParameterivSGIX")); + d->ListParameteriSGIX = reinterpret_cast(context->getProcAddress("glListParameteriSGIX")); + d->ListParameterfvSGIX = reinterpret_cast(context->getProcAddress("glListParameterfvSGIX")); + d->ListParameterfSGIX = reinterpret_cast(context->getProcAddress("glListParameterfSGIX")); + d->GetListParameterivSGIX = reinterpret_cast(context->getProcAddress("glGetListParameterivSGIX")); + d->GetListParameterfvSGIX = reinterpret_cast(context->getProcAddress("glGetListParameterfvSGIX")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SGIX_pixel_texture::QOpenGLExtension_SGIX_pixel_texture() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SGIX_pixel_texturePrivate)) +{ +} + +bool QOpenGLExtension_SGIX_pixel_texture::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SGIX_pixel_texture); + + d->PixelTexGenSGIX = reinterpret_cast(context->getProcAddress("glPixelTexGenSGIX")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SGIX_polynomial_ffd::QOpenGLExtension_SGIX_polynomial_ffd() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SGIX_polynomial_ffdPrivate)) +{ +} + +bool QOpenGLExtension_SGIX_polynomial_ffd::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SGIX_polynomial_ffd); + + d->LoadIdentityDeformationMapSGIX = reinterpret_cast(context->getProcAddress("glLoadIdentityDeformationMapSGIX")); + d->DeformSGIX = reinterpret_cast(context->getProcAddress("glDeformSGIX")); + d->DeformationMap3fSGIX = reinterpret_cast(context->getProcAddress("glDeformationMap3fSGIX")); + d->DeformationMap3dSGIX = reinterpret_cast(context->getProcAddress("glDeformationMap3dSGIX")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SGIX_reference_plane::QOpenGLExtension_SGIX_reference_plane() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SGIX_reference_planePrivate)) +{ +} + +bool QOpenGLExtension_SGIX_reference_plane::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SGIX_reference_plane); + + d->ReferencePlaneSGIX = reinterpret_cast(context->getProcAddress("glReferencePlaneSGIX")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SGIX_sprite::QOpenGLExtension_SGIX_sprite() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SGIX_spritePrivate)) +{ +} + +bool QOpenGLExtension_SGIX_sprite::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SGIX_sprite); + + d->SpriteParameterivSGIX = reinterpret_cast(context->getProcAddress("glSpriteParameterivSGIX")); + d->SpriteParameteriSGIX = reinterpret_cast(context->getProcAddress("glSpriteParameteriSGIX")); + d->SpriteParameterfvSGIX = reinterpret_cast(context->getProcAddress("glSpriteParameterfvSGIX")); + d->SpriteParameterfSGIX = reinterpret_cast(context->getProcAddress("glSpriteParameterfSGIX")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SGIX_tag_sample_buffer::QOpenGLExtension_SGIX_tag_sample_buffer() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SGIX_tag_sample_bufferPrivate)) +{ +} + +bool QOpenGLExtension_SGIX_tag_sample_buffer::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SGIX_tag_sample_buffer); + + d->TagSampleBufferSGIX = reinterpret_cast(context->getProcAddress("glTagSampleBufferSGIX")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SGI_color_table::QOpenGLExtension_SGI_color_table() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SGI_color_tablePrivate)) +{ +} + +bool QOpenGLExtension_SGI_color_table::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SGI_color_table); + + d->GetColorTableParameterivSGI = reinterpret_cast(context->getProcAddress("glGetColorTableParameterivSGI")); + d->GetColorTableParameterfvSGI = reinterpret_cast(context->getProcAddress("glGetColorTableParameterfvSGI")); + d->GetColorTableSGI = reinterpret_cast(context->getProcAddress("glGetColorTableSGI")); + d->CopyColorTableSGI = reinterpret_cast(context->getProcAddress("glCopyColorTableSGI")); + d->ColorTableParameterivSGI = reinterpret_cast(context->getProcAddress("glColorTableParameterivSGI")); + d->ColorTableParameterfvSGI = reinterpret_cast(context->getProcAddress("glColorTableParameterfvSGI")); + d->ColorTableSGI = reinterpret_cast(context->getProcAddress("glColorTableSGI")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SUNX_constant_data::QOpenGLExtension_SUNX_constant_data() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SUNX_constant_dataPrivate)) +{ +} + +bool QOpenGLExtension_SUNX_constant_data::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SUNX_constant_data); + + d->FinishTextureSUNX = reinterpret_cast(context->getProcAddress("glFinishTextureSUNX")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SUN_global_alpha::QOpenGLExtension_SUN_global_alpha() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SUN_global_alphaPrivate)) +{ +} + +bool QOpenGLExtension_SUN_global_alpha::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SUN_global_alpha); + + d->GlobalAlphaFactoruiSUN = reinterpret_cast(context->getProcAddress("glGlobalAlphaFactoruiSUN")); + d->GlobalAlphaFactorusSUN = reinterpret_cast(context->getProcAddress("glGlobalAlphaFactorusSUN")); + d->GlobalAlphaFactorubSUN = reinterpret_cast(context->getProcAddress("glGlobalAlphaFactorubSUN")); + d->GlobalAlphaFactordSUN = reinterpret_cast(context->getProcAddress("glGlobalAlphaFactordSUN")); + d->GlobalAlphaFactorfSUN = reinterpret_cast(context->getProcAddress("glGlobalAlphaFactorfSUN")); + d->GlobalAlphaFactoriSUN = reinterpret_cast(context->getProcAddress("glGlobalAlphaFactoriSUN")); + d->GlobalAlphaFactorsSUN = reinterpret_cast(context->getProcAddress("glGlobalAlphaFactorsSUN")); + d->GlobalAlphaFactorbSUN = reinterpret_cast(context->getProcAddress("glGlobalAlphaFactorbSUN")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SUN_mesh_array::QOpenGLExtension_SUN_mesh_array() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SUN_mesh_arrayPrivate)) +{ +} + +bool QOpenGLExtension_SUN_mesh_array::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SUN_mesh_array); + + d->DrawMeshArraysSUN = reinterpret_cast(context->getProcAddress("glDrawMeshArraysSUN")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SUN_triangle_list::QOpenGLExtension_SUN_triangle_list() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SUN_triangle_listPrivate)) +{ +} + +bool QOpenGLExtension_SUN_triangle_list::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SUN_triangle_list); + + d->ReplacementCodePointerSUN = reinterpret_cast(context->getProcAddress("glReplacementCodePointerSUN")); + d->ReplacementCodeubvSUN = reinterpret_cast(context->getProcAddress("glReplacementCodeubvSUN")); + d->ReplacementCodeusvSUN = reinterpret_cast(context->getProcAddress("glReplacementCodeusvSUN")); + d->ReplacementCodeuivSUN = reinterpret_cast(context->getProcAddress("glReplacementCodeuivSUN")); + d->ReplacementCodeubSUN = reinterpret_cast(context->getProcAddress("glReplacementCodeubSUN")); + d->ReplacementCodeusSUN = reinterpret_cast(context->getProcAddress("glReplacementCodeusSUN")); + d->ReplacementCodeuiSUN = reinterpret_cast(context->getProcAddress("glReplacementCodeuiSUN")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + +QOpenGLExtension_SUN_vertex::QOpenGLExtension_SUN_vertex() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_SUN_vertexPrivate)) +{ +} + +bool QOpenGLExtension_SUN_vertex::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_SUN_vertex); + + d->ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = reinterpret_cast(context->getProcAddress("glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN")); + d->ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = reinterpret_cast(context->getProcAddress("glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN")); + d->ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = reinterpret_cast(context->getProcAddress("glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN")); + d->ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = reinterpret_cast(context->getProcAddress("glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN")); + d->ReplacementCodeuiTexCoord2fVertex3fvSUN = reinterpret_cast(context->getProcAddress("glReplacementCodeuiTexCoord2fVertex3fvSUN")); + d->ReplacementCodeuiTexCoord2fVertex3fSUN = reinterpret_cast(context->getProcAddress("glReplacementCodeuiTexCoord2fVertex3fSUN")); + d->ReplacementCodeuiColor4fNormal3fVertex3fvSUN = reinterpret_cast(context->getProcAddress("glReplacementCodeuiColor4fNormal3fVertex3fvSUN")); + d->ReplacementCodeuiColor4fNormal3fVertex3fSUN = reinterpret_cast(context->getProcAddress("glReplacementCodeuiColor4fNormal3fVertex3fSUN")); + d->ReplacementCodeuiNormal3fVertex3fvSUN = reinterpret_cast(context->getProcAddress("glReplacementCodeuiNormal3fVertex3fvSUN")); + d->ReplacementCodeuiNormal3fVertex3fSUN = reinterpret_cast(context->getProcAddress("glReplacementCodeuiNormal3fVertex3fSUN")); + d->ReplacementCodeuiColor3fVertex3fvSUN = reinterpret_cast(context->getProcAddress("glReplacementCodeuiColor3fVertex3fvSUN")); + d->ReplacementCodeuiColor3fVertex3fSUN = reinterpret_cast(context->getProcAddress("glReplacementCodeuiColor3fVertex3fSUN")); + d->ReplacementCodeuiColor4ubVertex3fvSUN = reinterpret_cast(context->getProcAddress("glReplacementCodeuiColor4ubVertex3fvSUN")); + d->ReplacementCodeuiColor4ubVertex3fSUN = reinterpret_cast(context->getProcAddress("glReplacementCodeuiColor4ubVertex3fSUN")); + d->ReplacementCodeuiVertex3fvSUN = reinterpret_cast(context->getProcAddress("glReplacementCodeuiVertex3fvSUN")); + d->ReplacementCodeuiVertex3fSUN = reinterpret_cast(context->getProcAddress("glReplacementCodeuiVertex3fSUN")); + d->TexCoord4fColor4fNormal3fVertex4fvSUN = reinterpret_cast(context->getProcAddress("glTexCoord4fColor4fNormal3fVertex4fvSUN")); + d->TexCoord4fColor4fNormal3fVertex4fSUN = reinterpret_cast(context->getProcAddress("glTexCoord4fColor4fNormal3fVertex4fSUN")); + d->TexCoord2fColor4fNormal3fVertex3fvSUN = reinterpret_cast(context->getProcAddress("glTexCoord2fColor4fNormal3fVertex3fvSUN")); + d->TexCoord2fColor4fNormal3fVertex3fSUN = reinterpret_cast(context->getProcAddress("glTexCoord2fColor4fNormal3fVertex3fSUN")); + d->TexCoord2fNormal3fVertex3fvSUN = reinterpret_cast(context->getProcAddress("glTexCoord2fNormal3fVertex3fvSUN")); + d->TexCoord2fNormal3fVertex3fSUN = reinterpret_cast(context->getProcAddress("glTexCoord2fNormal3fVertex3fSUN")); + d->TexCoord2fColor3fVertex3fvSUN = reinterpret_cast(context->getProcAddress("glTexCoord2fColor3fVertex3fvSUN")); + d->TexCoord2fColor3fVertex3fSUN = reinterpret_cast(context->getProcAddress("glTexCoord2fColor3fVertex3fSUN")); + d->TexCoord2fColor4ubVertex3fvSUN = reinterpret_cast(context->getProcAddress("glTexCoord2fColor4ubVertex3fvSUN")); + d->TexCoord2fColor4ubVertex3fSUN = reinterpret_cast(context->getProcAddress("glTexCoord2fColor4ubVertex3fSUN")); + d->TexCoord4fVertex4fvSUN = reinterpret_cast(context->getProcAddress("glTexCoord4fVertex4fvSUN")); + d->TexCoord4fVertex4fSUN = reinterpret_cast(context->getProcAddress("glTexCoord4fVertex4fSUN")); + d->TexCoord2fVertex3fvSUN = reinterpret_cast(context->getProcAddress("glTexCoord2fVertex3fvSUN")); + d->TexCoord2fVertex3fSUN = reinterpret_cast(context->getProcAddress("glTexCoord2fVertex3fSUN")); + d->Color4fNormal3fVertex3fvSUN = reinterpret_cast(context->getProcAddress("glColor4fNormal3fVertex3fvSUN")); + d->Color4fNormal3fVertex3fSUN = reinterpret_cast(context->getProcAddress("glColor4fNormal3fVertex3fSUN")); + d->Normal3fVertex3fvSUN = reinterpret_cast(context->getProcAddress("glNormal3fVertex3fvSUN")); + d->Normal3fVertex3fSUN = reinterpret_cast(context->getProcAddress("glNormal3fVertex3fSUN")); + d->Color3fVertex3fvSUN = reinterpret_cast(context->getProcAddress("glColor3fVertex3fvSUN")); + d->Color3fVertex3fSUN = reinterpret_cast(context->getProcAddress("glColor3fVertex3fSUN")); + d->Color4ubVertex3fvSUN = reinterpret_cast(context->getProcAddress("glColor4ubVertex3fvSUN")); + d->Color4ubVertex3fSUN = reinterpret_cast(context->getProcAddress("glColor4ubVertex3fSUN")); + d->Color4ubVertex2fvSUN = reinterpret_cast(context->getProcAddress("glColor4ubVertex2fvSUN")); + d->Color4ubVertex2fSUN = reinterpret_cast(context->getProcAddress("glColor4ubVertex2fSUN")); + QAbstractOpenGLExtension::initializeOpenGLFunctions(); + return true; +} + + +#else + +QOpenGLExtension_OES_EGL_image::QOpenGLExtension_OES_EGL_image() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_OES_EGL_imagePrivate)) +{ +} + +bool QOpenGLExtension_OES_EGL_image::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_OES_EGL_image); + + d->EGLImageTargetTexture2DOES = (void (QOPENGLF_APIENTRYP)(GLenum target, GLeglImageOES image))context->getProcAddress("glEGLImageTargetTexture2DOES"); + d->EGLImageTargetRenderbufferStorageOES = (void (QOPENGLF_APIENTRYP)(GLenum target, GLeglImageOES image))context->getProcAddress("glEGLImageTargetRenderbufferStorageOESs"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_OES_get_program_binary::QOpenGLExtension_OES_get_program_binary() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_OES_get_program_binaryPrivate)) +{ +} + +bool QOpenGLExtension_OES_get_program_binary::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_OES_get_program_binary); + + d->GetProgramBinaryOES = (void (QOPENGLF_APIENTRYP)(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary))context->getProcAddress("glGetProgramBinaryOES"); + d->ProgramBinaryOES = (void (QOPENGLF_APIENTRYP)(GLuint program, GLenum binaryFormat, const GLvoid *binary, GLint length))context->getProcAddress("glProgramBinaryOES"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_OES_mapbuffer::QOpenGLExtension_OES_mapbuffer() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_OES_mapbufferPrivate)) +{ +} + +bool QOpenGLExtension_OES_mapbuffer::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_OES_mapbuffer); + + d->MapBufferOES = (void* (QOPENGLF_APIENTRYP)(GLenum target, GLenum access))context->getProcAddress("glMapBufferOES"); + d->UnmapBufferOES = (GLboolean (QOPENGLF_APIENTRYP)(GLenum target))context->getProcAddress("glUnmapBufferOES"); + d->GetBufferPointervOES = (void (QOPENGLF_APIENTRYP)(GLenum target, GLenum pname, GLvoid** params))context->getProcAddress("glGetBufferPointervOES"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_OES_texture_3D::QOpenGLExtension_OES_texture_3D() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_OES_texture_3DPrivate)) +{ +} + +bool QOpenGLExtension_OES_texture_3D::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_OES_texture_3D); + + d->TexImage3DOES = (void (QOPENGLF_APIENTRYP)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels))context->getProcAddress("glTexImage3DOES"); + d->TexSubImage3DOES = (void (QOPENGLF_APIENTRYP)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels))context->getProcAddress("glTexSubImage3DOES"); + d->CopyTexSubImage3DOES = (void (QOPENGLF_APIENTRYP)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height))context->getProcAddress("glCopyTexSubImage3DOES"); + d->CompressedTexImage3DOES = (void (QOPENGLF_APIENTRYP)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data))context->getProcAddress("glCompressedTexImage3DOES"); + d->CompressedTexSubImage3DOES = (void (QOPENGLF_APIENTRYP)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data))context->getProcAddress("glCompressedTexSubImage3DOES"); + d->FramebufferTexture3DOES = (void (QOPENGLF_APIENTRYP)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset))context->getProcAddress("glFramebufferTexture3DOES"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_OES_vertex_array_object::QOpenGLExtension_OES_vertex_array_object() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_OES_vertex_array_objectPrivate)) +{ +} + +bool QOpenGLExtension_OES_vertex_array_object::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_OES_vertex_array_object); + + d->BindVertexArrayOES = (void (QOPENGLF_APIENTRYP)(GLuint array))context->getProcAddress("glBindVertexArrayOES"); + d->DeleteVertexArraysOES = (void (QOPENGLF_APIENTRYP)(GLsizei n, const GLuint *arrays))context->getProcAddress("glDeleteVertexArraysOES"); + d->GenVertexArraysOES = (void (QOPENGLF_APIENTRYP)(GLsizei n, GLuint *arrays))context->getProcAddress("glGenVertexArraysOES"); + d->IsVertexArrayOES = (GLboolean (QOPENGLF_APIENTRYP)(GLuint array))context->getProcAddress("glIsVertexArrayOES"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_AMD_performance_monitor::QOpenGLExtension_AMD_performance_monitor() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_AMD_performance_monitorPrivate)) +{ +} + +bool QOpenGLExtension_AMD_performance_monitor::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_AMD_performance_monitor); + + d->GetPerfMonitorGroupsAMD = (void (QOPENGLF_APIENTRYP)(GLint *numGroups, GLsizei groupsSize, GLuint *groups))context->getProcAddress("glGetPerfMonitorGroupsAMD"); + d->GetPerfMonitorCountersAMD = (void (QOPENGLF_APIENTRYP)(GLuint group, GLint *numCounters, GLint *maxActiveCounters, GLsizei counterSize, GLuint *counters))context->getProcAddress("glGetPerfMonitorCountersAMD"); + d->GetPerfMonitorGroupStringAMD = (void (QOPENGLF_APIENTRYP)(GLuint group, GLsizei bufSize, GLsizei *length, GLchar *groupString))context->getProcAddress("glGetPerfMonitorGroupStringAMD"); + d->GetPerfMonitorCounterStringAMD = (void (QOPENGLF_APIENTRYP)(GLuint group, GLuint counter, GLsizei bufSize, GLsizei *length, GLchar *counterString))context->getProcAddress("glGetPerfMonitorCounterStringAMD"); + d->GetPerfMonitorCounterInfoAMD = (void (QOPENGLF_APIENTRYP)(GLuint group, GLuint counter, GLenum pname, GLvoid *data))context->getProcAddress("glGetPerfMonitorCounterInfoAMD"); + d->GenPerfMonitorsAMD = (void (QOPENGLF_APIENTRYP)(GLsizei n, GLuint *monitors))context->getProcAddress("glGenPerfMonitorsAMD"); + d->DeletePerfMonitorsAMD = (void (QOPENGLF_APIENTRYP)(GLsizei n, GLuint *monitors))context->getProcAddress("glDeletePerfMonitorsAMD"); + d->SelectPerfMonitorCountersAMD = (void (QOPENGLF_APIENTRYP)(GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint *countersList))context->getProcAddress("glSelectPerfMonitorCountersAMD"); + d->BeginPerfMonitorAMD = (void (QOPENGLF_APIENTRYP)(GLuint monitor))context->getProcAddress("glBeginPerfMonitorAMD"); + d->EndPerfMonitorAMD = (void (QOPENGLF_APIENTRYP )(GLuint monitor))context->getProcAddress("glEndPerfMonitorAMD"); + d->GetPerfMonitorCounterDataAMD = (void (QOPENGLF_APIENTRYP)(GLuint monitor, GLenum pname, GLsizei dataSize, GLuint *data, GLint *bytesWritten))context->getProcAddress("glGetPerfMonitorCounterDataAMD"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_ANGLE_framebuffer_blit::QOpenGLExtension_ANGLE_framebuffer_blit() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ANGLE_framebuffer_blitPrivate)) +{ +} + +bool QOpenGLExtension_ANGLE_framebuffer_blit::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ANGLE_framebuffer_blit); + + d->BlitFramebufferANGLE = (void (QOPENGLF_APIENTRYP)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter))context->getProcAddress("glBlitFramebufferANGLE"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_ANGLE_framebuffer_multisample::QOpenGLExtension_ANGLE_framebuffer_multisample() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ANGLE_framebuffer_multisamplePrivate)) +{ +} + +bool QOpenGLExtension_ANGLE_framebuffer_multisample::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ANGLE_framebuffer_multisample); + + d->RenderbufferStorageMultisampleANGLE = (void (QOPENGLF_APIENTRYP)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height))context->getProcAddress("glRenderbufferStorageMultisampleANGLE"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_ANGLE_instanced_arrays::QOpenGLExtension_ANGLE_instanced_arrays() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ANGLE_instanced_arraysPrivate)) +{ +} + +bool QOpenGLExtension_ANGLE_instanced_arrays::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ANGLE_instanced_arrays); + + d->DrawArraysInstancedANGLE = (void (QOPENGLF_APIENTRYP)(GLenum mode, GLint first, GLsizei count, GLsizei primcount))context->getProcAddress("glDrawArraysInstancedANGLE"); + d->DrawElementsInstancedANGLE = (void (QOPENGLF_APIENTRYP)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount))context->getProcAddress("glDrawElementsInstancedANGLE"); + d->VertexAttribDivisorANGLE = (void (QOPENGLF_APIENTRYP)(GLuint index, GLuint divisor))context->getProcAddress("glVertexAttribDivisorANGLE"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_ANGLE_translated_shader_source::QOpenGLExtension_ANGLE_translated_shader_source() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_ANGLE_translated_shader_sourcePrivate)) +{ +} + +bool QOpenGLExtension_ANGLE_translated_shader_source::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_ANGLE_translated_shader_source); + + d->GetTranslatedShaderSourceANGLE = (void (QOPENGLF_APIENTRYP)(GLuint shader, GLsizei bufsize, GLsizei *length, GLchar *source))context->getProcAddress("glGetTranslatedShaderSourceANGLE"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_APPLE_framebuffer_multisample::QOpenGLExtension_APPLE_framebuffer_multisample() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_APPLE_framebuffer_multisamplePrivate)) +{ +} + +bool QOpenGLExtension_APPLE_framebuffer_multisample::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_APPLE_framebuffer_multisample); + + d->RenderbufferStorageMultisampleAPPLE = (void (QOPENGLF_APIENTRYP)(GLenum, GLsizei, GLenum, GLsizei, GLsizei))context->getProcAddress("glRenderbufferStorageMultisampleAPPLE"); + d->ResolveMultisampleFramebufferAPPLE = (void (QOPENGLF_APIENTRYP)(void))context->getProcAddress("glResolveMultisampleFramebufferAPPLE"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_EXT_debug_label::QOpenGLExtension_EXT_debug_label() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_debug_labelPrivate)) +{ +} + +bool QOpenGLExtension_EXT_debug_label::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_debug_label); + + d->LabelObjectEXT = (void (QOPENGLF_APIENTRYP)(GLenum type, GLuint object, GLsizei length, const GLchar *label))context->getProcAddress("glLabelObjectEXT"); + d->GetObjectLabelEXT = (void (QOPENGLF_APIENTRYP)(GLenum type, GLuint object, GLsizei bufSize, GLsizei *length, GLchar *label))context->getProcAddress("glGetObjectLabelEXT"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_EXT_debug_marker::QOpenGLExtension_EXT_debug_marker() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_debug_markerPrivate)) +{ +} + +bool QOpenGLExtension_EXT_debug_marker::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_debug_marker); + + d->InsertEventMarkerEXT = (void (QOPENGLF_APIENTRYP)(GLsizei length, const GLchar *marker))context->getProcAddress("glInsertEventMarkerEXT"); + d->PushGroupMarkerEXT = (void (QOPENGLF_APIENTRYP)(GLsizei length, const GLchar *marker))context->getProcAddress("glPushGroupMarkerEXT"); + d->PopGroupMarkerEXT = (void (QOPENGLF_APIENTRYP)(void))context->getProcAddress("glPopGroupMarkerEXT"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_EXT_discard_framebuffer::QOpenGLExtension_EXT_discard_framebuffer() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_discard_framebufferPrivate)) +{ +} + +bool QOpenGLExtension_EXT_discard_framebuffer::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_discard_framebuffer); + + d->DiscardFramebufferEXT = (void (QOPENGLF_APIENTRYP)(GLenum target, GLsizei numAttachments, const GLenum *attachments))context->getProcAddress("glDiscardFramebufferEXT"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_EXT_multisampled_render_to_texture::QOpenGLExtension_EXT_multisampled_render_to_texture() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_multisampled_render_to_texturePrivate)) +{ +} + +bool QOpenGLExtension_EXT_multisampled_render_to_texture::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_multisampled_render_to_texture); + + d->RenderbufferStorageMultisampleEXT = (void (QOPENGLF_APIENTRYP)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height))context->getProcAddress("glRenderbufferStorageMultisampleEXT"); + d->FramebufferTexture2DMultisampleEXT = (void (QOPENGLF_APIENTRYP)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples))context->getProcAddress("glFramebufferTexture2DMultisampleEXT"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_EXT_multi_draw_arrays::QOpenGLExtension_EXT_multi_draw_arrays() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_multi_draw_arraysPrivate)) +{ +} + +bool QOpenGLExtension_EXT_multi_draw_arrays::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_multi_draw_arrays); + + d->MultiDrawArraysEXT = (void (QOPENGLF_APIENTRYP)(GLenum mode, GLint *first, GLsizei *count, GLsizei primcount))context->getProcAddress("glMultiDrawArraysEXT"); + d->MultiDrawElementsEXT = (void (QOPENGLF_APIENTRYP)(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount))context->getProcAddress("glMultiDrawElementsEXT"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_EXT_occlusion_query_boolean::QOpenGLExtension_EXT_occlusion_query_boolean() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_occlusion_query_booleanPrivate)) +{ +} + +bool QOpenGLExtension_EXT_occlusion_query_boolean::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_occlusion_query_boolean); + + d->GenQueriesEXT = (void (QOPENGLF_APIENTRYP)(GLsizei n, GLuint *ids))context->getProcAddress("glGenQueriesEXT"); + d->DeleteQueriesEXT = (void (QOPENGLF_APIENTRYP)(GLsizei n, const GLuint *ids))context->getProcAddress("glDeleteQueriesEXT"); + d->IsQueryEXT = (GLboolean (QOPENGLF_APIENTRYP)(GLuint id))context->getProcAddress("glIsQueryEXT"); + d->BeginQueryEXT = (void (QOPENGLF_APIENTRYP)(GLenum target, GLuint id))context->getProcAddress("glBeginQueryEXT"); + d->EndQueryEXT = (void (QOPENGLF_APIENTRYP)(GLenum target))context->getProcAddress("glEndQueryEXT"); + d->GetQueryivEXT = (void (QOPENGLF_APIENTRYP)(GLenum target, GLenum pname, GLint *params))context->getProcAddress("glGetQueryivEXT"); + d->GetQueryObjectuivEXT = (void (QOPENGLF_APIENTRYP)(GLuint id, GLenum pname, GLuint *params))context->getProcAddress("glGetQueryObjectuivEXT"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_EXT_robustness::QOpenGLExtension_EXT_robustness() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_robustnessPrivate)) +{ +} + +bool QOpenGLExtension_EXT_robustness::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_robustness); + + d->GetGraphicsResetStatusEXT = (GLenum (QOPENGLF_APIENTRYP)(void))context->getProcAddress("glGetGraphicsResetStatusEXT"); + d->ReadnPixelsEXT = (void (QOPENGLF_APIENTRYP)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data))context->getProcAddress("glReadnPixelsEXT"); + d->GetnUniformfvEXT = (void (QOPENGLF_APIENTRYP)(GLuint program, GLint location, GLsizei bufSize, float *params))context->getProcAddress("glGetnUniformfvEXT"); + d->GetnUniformivEXT = (void (QOPENGLF_APIENTRYP)(GLuint program, GLint location, GLsizei bufSize, GLint *params))context->getProcAddress("glGetnUniformivEXT"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_EXT_separate_shader_objects::QOpenGLExtension_EXT_separate_shader_objects() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_separate_shader_objectsPrivate)) +{ +} + +bool QOpenGLExtension_EXT_separate_shader_objects::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_separate_shader_objects); + + d->UseProgramStagesEXT = (void (QOPENGLF_APIENTRYP)(GLuint pipeline, GLbitfield stages, GLuint program))context->getProcAddress("glUseProgramStagesEXT"); + d->ActiveShaderProgramEXT = (void (QOPENGLF_APIENTRYP)(GLuint pipeline, GLuint program))context->getProcAddress("glActiveShaderProgramEXT"); + d->CreateShaderProgramvEXT = (GLuint (QOPENGLF_APIENTRYP)(GLenum type, GLsizei count, const GLchar **strings))context->getProcAddress("glCreateShaderProgramvEXT"); + d->BindProgramPipelineEXT = (void (QOPENGLF_APIENTRYP)(GLuint pipeline))context->getProcAddress("glBindProgramPipelineEXT"); + d->DeleteProgramPipelinesEXT = (void (QOPENGLF_APIENTRYP)(GLsizei n, const GLuint *pipelines))context->getProcAddress("glDeleteProgramPipelinesEXT"); + d->GenProgramPipelinesEXT = (void (QOPENGLF_APIENTRYP)(GLsizei n, GLuint *pipelines))context->getProcAddress("glGenProgramPipelinesEXT"); + d->IsProgramPipelineEXT = (GLboolean (QOPENGLF_APIENTRYP)(GLuint pipeline))context->getProcAddress("glIsProgramPipelineEXT"); + d->ProgramParameteriEXT = (void (QOPENGLF_APIENTRYP)(GLuint program, GLenum pname, GLint value))context->getProcAddress("glProgramParameteriEXT"); + d->GetProgramPipelineivEXT = (void (QOPENGLF_APIENTRYP)(GLuint pipeline, GLenum pname, GLint *params))context->getProcAddress("glGetProgramPipelineivEXT"); + d->ProgramUniform1iEXT = (void (QOPENGLF_APIENTRYP)(GLuint program, GLint location, GLint x))context->getProcAddress("glProgramUniform1iEXT"); + d->ProgramUniform2iEXT = (void (QOPENGLF_APIENTRYP)(GLuint program, GLint location, GLint x, GLint y))context->getProcAddress("glProgramUniform2iEXT"); + d->ProgramUniform3iEXT = (void (QOPENGLF_APIENTRYP)(GLuint program, GLint location, GLint x, GLint y, GLint z))context->getProcAddress("glProgramUniform3iEXT"); + d->ProgramUniform4iEXT = (void (QOPENGLF_APIENTRYP)(GLuint program, GLint location, GLint x, GLint y, GLint z, GLint w))context->getProcAddress("glProgramUniform4iEXT"); + d->ProgramUniform1fEXT = (void (QOPENGLF_APIENTRYP)(GLuint program, GLint location, GLfloat x))context->getProcAddress("glProgramUniform1fEXT"); + d->ProgramUniform2fEXT = (void (QOPENGLF_APIENTRYP)(GLuint program, GLint location, GLfloat x, GLfloat y))context->getProcAddress("glProgramUniform2fEXT"); + d->ProgramUniform3fEXT = (void (QOPENGLF_APIENTRYP)(GLuint program, GLint location, GLfloat x, GLfloat y, GLfloat z))context->getProcAddress("glProgramUniform3fEXT"); + d->ProgramUniform4fEXT = (void (QOPENGLF_APIENTRYP)(GLuint program, GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w))context->getProcAddress("glProgramUniform4fEXT"); + d->ProgramUniform1ivEXT = (void (QOPENGLF_APIENTRYP)(GLuint program, GLint location, GLsizei count, const GLint *value))context->getProcAddress("glProgramUniform1ivEXT"); + d->ProgramUniform2ivEXT = (void (QOPENGLF_APIENTRYP)(GLuint program, GLint location, GLsizei count, const GLint *value))context->getProcAddress("glProgramUniform2ivEXT"); + d->ProgramUniform3ivEXT = (void (QOPENGLF_APIENTRYP)(GLuint program, GLint location, GLsizei count, const GLint *value))context->getProcAddress("glProgramUniform3ivEXT"); + d->ProgramUniform4ivEXT = (void (QOPENGLF_APIENTRYP)(GLuint program, GLint location, GLsizei count, const GLint *value))context->getProcAddress("glProgramUniform4ivEXT"); + d->ProgramUniform1fvEXT = (void (QOPENGLF_APIENTRYP)(GLuint program, GLint location, GLsizei count, const GLfloat *value))context->getProcAddress("glProgramUniform1fvEXT"); + d->ProgramUniform2fvEXT = (void (QOPENGLF_APIENTRYP)(GLuint program, GLint location, GLsizei count, const GLfloat *value))context->getProcAddress("glProgramUniform2fvEXT"); + d->ProgramUniform3fvEXT = (void (QOPENGLF_APIENTRYP)(GLuint program, GLint location, GLsizei count, const GLfloat *value))context->getProcAddress("glProgramUniform3fvEXT"); + d->ProgramUniform4fvEXT = (void (QOPENGLF_APIENTRYP)(GLuint program, GLint location, GLsizei count, const GLfloat *value))context->getProcAddress("glProgramUniform4fvEXT"); + d->ProgramUniformMatrix2fvEXT = (void (QOPENGLF_APIENTRYP)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value))context->getProcAddress("glProgramUniformMatrix2fvEXT"); + d->ProgramUniformMatrix3fvEXT = (void (QOPENGLF_APIENTRYP)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value))context->getProcAddress("glProgramUniformMatrix3fvEXT"); + d->ProgramUniformMatrix4fvEXT = (void (QOPENGLF_APIENTRYP)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value))context->getProcAddress("glProgramUniformMatrix4fvEXT"); + d->ValidateProgramPipelineEXT = (void (QOPENGLF_APIENTRYP)(GLuint pipeline))context->getProcAddress("glValidateProgramPipelineEXT"); + d->GetProgramPipelineInfoLogEXT = (void (QOPENGLF_APIENTRYP)(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog))context->getProcAddress("glGetProgramPipelineInfoLogEXT"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_EXT_texture_storage::QOpenGLExtension_EXT_texture_storage() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_EXT_texture_storagePrivate)) +{ +} + +bool QOpenGLExtension_EXT_texture_storage::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_EXT_texture_storage); + + d->TexStorage1DEXT = (void (QOPENGLF_APIENTRYP)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width))context->getProcAddress("glTexStorage1DEXT"); + d->TexStorage2DEXT = (void (QOPENGLF_APIENTRYP)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height))context->getProcAddress("glTexStorage2DEXT"); + d->TexStorage3DEXT = (void (QOPENGLF_APIENTRYP)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth))context->getProcAddress("glTexStorage3DEXT"); + d->TextureStorage1DEXT = (void (QOPENGLF_APIENTRYP)(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width))context->getProcAddress("glTextureStorage1DEXT"); + d->TextureStorage2DEXT = (void (QOPENGLF_APIENTRYP)(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height))context->getProcAddress("glTextureStorage2DEXT"); + d->TextureStorage3DEXT = (void (QOPENGLF_APIENTRYP)(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth))context->getProcAddress("glTextureStorage3DEXT"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_IMG_multisampled_render_to_texture::QOpenGLExtension_IMG_multisampled_render_to_texture() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_IMG_multisampled_render_to_texturePrivate)) +{ +} + +bool QOpenGLExtension_IMG_multisampled_render_to_texture::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_IMG_multisampled_render_to_texture); + + d->RenderbufferStorageMultisampleIMG = (void (QOPENGLF_APIENTRYP)(GLenum, GLsizei, GLenum, GLsizei, GLsizei))context->getProcAddress("glRenderbufferStorageMultisampleIMG"); + d->FramebufferTexture2DMultisampleIMG = (void (QOPENGLF_APIENTRYP)(GLenum, GLenum, GLenum, GLuint, GLint, GLsizei))context->getProcAddress("glFramebufferTexture2DMultisampleIMG"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_NV_coverage_sample::QOpenGLExtension_NV_coverage_sample() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_coverage_samplePrivate)) +{ +} + +bool QOpenGLExtension_NV_coverage_sample::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_coverage_sample); + + d->CoverageMaskNV = (void (QOPENGLF_APIENTRYP)(GLboolean mask))context->getProcAddress("glCoverageMaskNV"); + d->CoverageOperationNV = (void (QOPENGLF_APIENTRYP)(GLenum operation))context->getProcAddress("glCoverageOperationNV"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_NV_draw_buffers::QOpenGLExtension_NV_draw_buffers() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_draw_buffersPrivate)) +{ +} + +bool QOpenGLExtension_NV_draw_buffers::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_draw_buffers); + + d->DrawBuffersNV = (void (QOPENGLF_APIENTRYP)(GLsizei n, const GLenum *bufs))context->getProcAddress("glDrawBuffersNV"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_NV_fence::QOpenGLExtension_NV_fence() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_fencePrivate)) +{ +} + +bool QOpenGLExtension_NV_fence::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_fence); + + d->DeleteFencesNV = (void (QOPENGLF_APIENTRYP)(GLsizei n, const GLuint *fences))context->getProcAddress("glDeleteFencesNV"); + d->GenFencesNV = (void (QOPENGLF_APIENTRYP)(GLsizei n, GLuint *fences))context->getProcAddress("glGenFencesNV"); + d->IsFenceNV = (GLboolean (QOPENGLF_APIENTRYP)(GLuint fence))context->getProcAddress("glIsFenceNV"); + d->TestFenceNV = (GLboolean (QOPENGLF_APIENTRYP)(GLuint fence))context->getProcAddress("glTestFenceNV"); + d->GetFenceivNV = (void (QOPENGLF_APIENTRYP)(GLuint fence, GLenum pname, GLint *params))context->getProcAddress("glGetFenceivNV"); + d->FinishFenceNV = (void (QOPENGLF_APIENTRYP)(GLuint fence))context->getProcAddress("glFinishFenceNV"); + d->SetFenceNV = (void (QOPENGLF_APIENTRYP)(GLuint fence, GLenum condition))context->getProcAddress("glSetFenceNV"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_NV_read_buffer::QOpenGLExtension_NV_read_buffer() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_NV_read_bufferPrivate)) +{ +} + +bool QOpenGLExtension_NV_read_buffer::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_NV_read_buffer); + + d->ReadBufferNV = (void (QOPENGLF_APIENTRYP)(GLenum mode))context->getProcAddress("glReadBufferNV"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_QCOM_alpha_test::QOpenGLExtension_QCOM_alpha_test() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_QCOM_alpha_testPrivate)) +{ +} + +bool QOpenGLExtension_QCOM_alpha_test::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_QCOM_alpha_test); + + d->AlphaFuncQCOM = (void (QOPENGLF_APIENTRYP )(GLenum func, GLclampf ref))context->getProcAddress("glAlphaFuncQCOM"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_QCOM_driver_control::QOpenGLExtension_QCOM_driver_control() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_QCOM_driver_controlPrivate)) +{ +} + +bool QOpenGLExtension_QCOM_driver_control::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_QCOM_driver_control); + + d->GetDriverControlsQCOM = (void (QOPENGLF_APIENTRYP)(GLint *num, GLsizei size, GLuint *driverControls))context->getProcAddress("glGetDriverControlsQCOM"); + d->GetDriverControlStringQCOM = (void (QOPENGLF_APIENTRYP)(GLuint driverControl, GLsizei bufSize, GLsizei *length, GLchar *driverControlString))context->getProcAddress("glGetDriverControlStringQCOM"); + d->EnableDriverControlQCOM = (void (QOPENGLF_APIENTRYP)(GLuint driverControl))context->getProcAddress("glEnableDriverControlQCOM"); + d->DisableDriverControlQCOM = (void (QOPENGLF_APIENTRYP)(GLuint driverControl))context->getProcAddress("glDisableDriverControlQCOM"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_QCOM_extended_get::QOpenGLExtension_QCOM_extended_get() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_QCOM_extended_getPrivate)) +{ +} + +bool QOpenGLExtension_QCOM_extended_get::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_QCOM_extended_get); + + d->ExtGetTexturesQCOM = (void (QOPENGLF_APIENTRYP)(GLuint *textures, GLint maxTextures, GLint *numTextures))context->getProcAddress("glExtGetTexturesQCOM"); + d->ExtGetBuffersQCOM = (void (QOPENGLF_APIENTRYP)(GLuint *buffers, GLint maxBuffers, GLint *numBuffers))context->getProcAddress("glExtGetBuffersQCOM"); + d->ExtGetRenderbuffersQCOM = (void (QOPENGLF_APIENTRYP)(GLuint *renderbuffers, GLint maxRenderbuffers, GLint *numRenderbuffers))context->getProcAddress("glExtGetRenderbuffersQCOM"); + d->ExtGetFramebuffersQCOM = (void (QOPENGLF_APIENTRYP)(GLuint *framebuffers, GLint maxFramebuffers, GLint *numFramebuffers))context->getProcAddress("glExtGetFramebuffersQCOM"); + d->ExtGetTexLevelParameterivQCOM = (void (QOPENGLF_APIENTRYP)(GLuint texture, GLenum face, GLint level, GLenum pname, GLint *params))context->getProcAddress("glExtGetTexLevelParameterivQCOM"); + d->ExtTexObjectStateOverrideiQCOM = (void (QOPENGLF_APIENTRYP)(GLenum target, GLenum pname, GLint param))context->getProcAddress("glExtTexObjectStateOverrideiQCOM"); + d->ExtGetTexSubImageQCOM = (void (QOPENGLF_APIENTRYP)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid *texels))context->getProcAddress("glExtGetTexSubImageQCOM"); + d->ExtGetBufferPointervQCOM = (void (QOPENGLF_APIENTRYP)(GLenum target, GLvoid **params))context->getProcAddress("glExtGetBufferPointervQCOM"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_QCOM_extended_get2::QOpenGLExtension_QCOM_extended_get2() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_QCOM_extended_get2Private)) +{ +} + +bool QOpenGLExtension_QCOM_extended_get2::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_QCOM_extended_get2); + + d->ExtGetShadersQCOM = (void (QOPENGLF_APIENTRYP)(GLuint *shaders, GLint maxShaders, GLint *numShaders))context->getProcAddress("glExtGetShadersQCOM"); + d->ExtGetProgramsQCOM = (void (QOPENGLF_APIENTRYP)(GLuint *programs, GLint maxPrograms, GLint *numPrograms))context->getProcAddress("glExtGetProgramsQCOM"); + d->ExtIsProgramBinaryQCOM = (GLboolean (QOPENGLF_APIENTRYP)(GLuint program))context->getProcAddress("glExtIsProgramBinaryQCOM"); + d->ExtGetProgramBinarySourceQCOM = (void (QOPENGLF_APIENTRYP)(GLuint program, GLenum shadertype, GLchar *source, GLint *length))context->getProcAddress("glExtGetProgramBinarySourceQCOM"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +QOpenGLExtension_QCOM_tiled_rendering::QOpenGLExtension_QCOM_tiled_rendering() + : QAbstractOpenGLExtension(*(new QOpenGLExtension_QCOM_tiled_renderingPrivate)) +{ +} + +bool QOpenGLExtension_QCOM_tiled_rendering::initializeOpenGLFunctions() +{ + if (isInitialized()) + return true; + + QOpenGLContext *context = QOpenGLContext::currentContext(); + if (!context) { + qWarning("A current OpenGL context is required to resolve OpenGL extension functions"); + return false; + } + + // Resolve the functions + Q_D(QOpenGLExtension_QCOM_tiled_rendering); + + d->StartTilingQCOM = (void (QOPENGLF_APIENTRYP)(GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask))context->getProcAddress("glStartTilingQCOM"); + d->EndTilingQCOM = (void (QOPENGLF_APIENTRYP)(GLbitfield preserveMask))context->getProcAddress("glEndTilingQCOM"); + return QAbstractOpenGLExtension::initializeOpenGLFunctions(); +} + +#endif + +QT_END_NAMESPACE + -- cgit v1.2.3