/*
 * Interface wrapper code.
 *
 * Generated by SIP 6.6.2
 *
 * Copyright (c) 2022 Riverbank Computing Limited <info@riverbankcomputing.com>
 * 
 * This file is part of PyQt5.
 * 
 * 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 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.
 * 
 * If you do not wish to use this file under the terms of the GPL version 3.0
 * then you may purchase a commercial license.  For more information contact
 * info@riverbankcomputing.com.
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

#include "sipAPIQtGui.h"

#line 29 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtGui/qopengltexture.sip"
#include <qopengltexture.h>
#line 29 "/build/pyqt5/src/PyQt5-5.15.7/build/QtGui/sipQtGuiQOpenGLTexture.cpp"

#line 26 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtGui/qimage.sip"
#include <qimage.h>
#line 33 "/build/pyqt5/src/PyQt5-5.15.7/build/QtGui/sipQtGuiQOpenGLTexture.cpp"
#line 131 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtGui/qpygui_qpair.sip"
#include <qpair.h>
#line 36 "/build/pyqt5/src/PyQt5-5.15.7/build/QtGui/sipQtGuiQOpenGLTexture.cpp"
#line 26 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtGui/qcolor.sip"
#include <qcolor.h>
#line 39 "/build/pyqt5/src/PyQt5-5.15.7/build/QtGui/sipQtGuiQOpenGLTexture.cpp"
#line 30 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtGui/qpygui_qpair.sip"
#include <QOpenGLTexture>
#line 42 "/build/pyqt5/src/PyQt5-5.15.7/build/QtGui/sipQtGuiQOpenGLTexture.cpp"
#line 250 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtCore/qpycore_qpair.sip"
#include <qpair.h>
#line 45 "/build/pyqt5/src/PyQt5-5.15.7/build/QtGui/sipQtGuiQOpenGLTexture.cpp"
#line 29 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtGui/qopenglpixeltransferoptions.sip"
#include <qopenglpixeltransferoptions.h>
#line 48 "/build/pyqt5/src/PyQt5-5.15.7/build/QtGui/sipQtGuiQOpenGLTexture.cpp"


PyDoc_STRVAR(doc_QOpenGLTexture_create, "create(self) -> bool");

extern "C" {static PyObject *meth_QOpenGLTexture_create(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_create(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            bool sipRes;

            sipRes = sipCpp->create();

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_create, doc_QOpenGLTexture_create);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_destroy, "destroy(self)");

extern "C" {static PyObject *meth_QOpenGLTexture_destroy(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_destroy(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            sipCpp->destroy();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_destroy, doc_QOpenGLTexture_destroy);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_isCreated, "isCreated(self) -> bool");

extern "C" {static PyObject *meth_QOpenGLTexture_isCreated(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_isCreated(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            bool sipRes;

            sipRes = sipCpp->isCreated();

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_isCreated, doc_QOpenGLTexture_isCreated);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_textureId, "textureId(self) -> int");

extern "C" {static PyObject *meth_QOpenGLTexture_textureId(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_textureId(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
             ::GLuint sipRes;

            sipRes = sipCpp->textureId();

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_textureId, doc_QOpenGLTexture_textureId);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_bind, "bind(self)\n"
"bind(self, int, reset: QOpenGLTexture.TextureUnitReset = QOpenGLTexture.DontResetTextureUnit)");

extern "C" {static PyObject *meth_QOpenGLTexture_bind(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_bind(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QOpenGLTexture *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, SIP_NULLPTR, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            sipCpp->bind();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
         ::uint a0;
         ::QOpenGLTexture::TextureUnitReset a1 = QOpenGLTexture::DontResetTextureUnit;
         ::QOpenGLTexture *sipCpp;

        static const char *sipKwdList[] = {
            SIP_NULLPTR,
            sipName_reset,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Bu|E", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0, sipType_QOpenGLTexture_TextureUnitReset, &a1))
        {
            sipCpp->bind(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_bind, doc_QOpenGLTexture_bind);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_release, "release(self)\n"
"release(self, int, reset: QOpenGLTexture.TextureUnitReset = QOpenGLTexture.DontResetTextureUnit)");

extern "C" {static PyObject *meth_QOpenGLTexture_release(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_release(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QOpenGLTexture *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, SIP_NULLPTR, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            sipCpp->release();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
         ::uint a0;
         ::QOpenGLTexture::TextureUnitReset a1 = QOpenGLTexture::DontResetTextureUnit;
         ::QOpenGLTexture *sipCpp;

        static const char *sipKwdList[] = {
            SIP_NULLPTR,
            sipName_reset,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Bu|E", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0, sipType_QOpenGLTexture_TextureUnitReset, &a1))
        {
            sipCpp->release(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_release, doc_QOpenGLTexture_release);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_isBound, "isBound(self) -> bool\n"
"isBound(self, int) -> bool");

extern "C" {static PyObject *meth_QOpenGLTexture_isBound(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_isBound(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            bool sipRes;

            sipRes = sipCpp->isBound();

            return PyBool_FromLong(sipRes);
        }
    }

    {
         ::uint a0;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0))
        {
            bool sipRes;

            sipRes = sipCpp->isBound(a0);

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_isBound, doc_QOpenGLTexture_isBound);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_boundTextureId, "boundTextureId(QOpenGLTexture.BindingTarget) -> int\n"
"boundTextureId(int, QOpenGLTexture.BindingTarget) -> int");

extern "C" {static PyObject *meth_QOpenGLTexture_boundTextureId(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_boundTextureId(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QOpenGLTexture::BindingTarget a0;

        if (sipParseArgs(&sipParseErr, sipArgs, "E", sipType_QOpenGLTexture_BindingTarget, &a0))
        {
             ::GLuint sipRes;

            sipRes =  ::QOpenGLTexture::boundTextureId(a0);

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    {
         ::uint a0;
         ::QOpenGLTexture::BindingTarget a1;

        if (sipParseArgs(&sipParseErr, sipArgs, "uE", &a0, sipType_QOpenGLTexture_BindingTarget, &a1))
        {
             ::GLuint sipRes;

            sipRes =  ::QOpenGLTexture::boundTextureId(a0,a1);

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_boundTextureId, doc_QOpenGLTexture_boundTextureId);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setFormat, "setFormat(self, QOpenGLTexture.TextureFormat)");

extern "C" {static PyObject *meth_QOpenGLTexture_setFormat(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setFormat(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QOpenGLTexture::TextureFormat a0;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QOpenGLTexture, &sipCpp, sipType_QOpenGLTexture_TextureFormat, &a0))
        {
            sipCpp->setFormat(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setFormat, doc_QOpenGLTexture_setFormat);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_format, "format(self) -> QOpenGLTexture.TextureFormat");

extern "C" {static PyObject *meth_QOpenGLTexture_format(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_format(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
             ::QOpenGLTexture::TextureFormat sipRes;

            sipRes = sipCpp->format();

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QOpenGLTexture_TextureFormat);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_format, doc_QOpenGLTexture_format);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setSize, "setSize(self, int, height: int = 1, depth: int = 1)");

extern "C" {static PyObject *meth_QOpenGLTexture_setSize(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setSize(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        int a0;
        int a1 = 1;
        int a2 = 1;
         ::QOpenGLTexture *sipCpp;

        static const char *sipKwdList[] = {
            SIP_NULLPTR,
            sipName_height,
            sipName_depth,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Bi|ii", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->setSize(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setSize, doc_QOpenGLTexture_setSize);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_width, "width(self) -> int");

extern "C" {static PyObject *meth_QOpenGLTexture_width(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_width(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            int sipRes;

            sipRes = sipCpp->width();

            return PyLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_width, doc_QOpenGLTexture_width);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_height, "height(self) -> int");

extern "C" {static PyObject *meth_QOpenGLTexture_height(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_height(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            int sipRes;

            sipRes = sipCpp->height();

            return PyLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_height, doc_QOpenGLTexture_height);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_depth, "depth(self) -> int");

extern "C" {static PyObject *meth_QOpenGLTexture_depth(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_depth(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            int sipRes;

            sipRes = sipCpp->depth();

            return PyLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_depth, doc_QOpenGLTexture_depth);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setMipLevels, "setMipLevels(self, int)");

extern "C" {static PyObject *meth_QOpenGLTexture_setMipLevels(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setMipLevels(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        int a0;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0))
        {
            sipCpp->setMipLevels(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setMipLevels, doc_QOpenGLTexture_setMipLevels);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_mipLevels, "mipLevels(self) -> int");

extern "C" {static PyObject *meth_QOpenGLTexture_mipLevels(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_mipLevels(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            int sipRes;

            sipRes = sipCpp->mipLevels();

            return PyLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_mipLevels, doc_QOpenGLTexture_mipLevels);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_maximumMipLevels, "maximumMipLevels(self) -> int");

extern "C" {static PyObject *meth_QOpenGLTexture_maximumMipLevels(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_maximumMipLevels(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            int sipRes;

            sipRes = sipCpp->maximumMipLevels();

            return PyLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_maximumMipLevels, doc_QOpenGLTexture_maximumMipLevels);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setLayers, "setLayers(self, int)");

extern "C" {static PyObject *meth_QOpenGLTexture_setLayers(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setLayers(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        int a0;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0))
        {
            sipCpp->setLayers(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setLayers, doc_QOpenGLTexture_setLayers);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_layers, "layers(self) -> int");

extern "C" {static PyObject *meth_QOpenGLTexture_layers(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_layers(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            int sipRes;

            sipRes = sipCpp->layers();

            return PyLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_layers, doc_QOpenGLTexture_layers);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_faces, "faces(self) -> int");

extern "C" {static PyObject *meth_QOpenGLTexture_faces(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_faces(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            int sipRes;

            sipRes = sipCpp->faces();

            return PyLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_faces, doc_QOpenGLTexture_faces);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_allocateStorage, "allocateStorage(self)\n"
"allocateStorage(self, QOpenGLTexture.PixelFormat, QOpenGLTexture.PixelType)");

extern "C" {static PyObject *meth_QOpenGLTexture_allocateStorage(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_allocateStorage(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            sipCpp->allocateStorage();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
         ::QOpenGLTexture::PixelFormat a0;
         ::QOpenGLTexture::PixelType a1;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BEE", &sipSelf, sipType_QOpenGLTexture, &sipCpp, sipType_QOpenGLTexture_PixelFormat, &a0, sipType_QOpenGLTexture_PixelType, &a1))
        {
            sipCpp->allocateStorage(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_allocateStorage, doc_QOpenGLTexture_allocateStorage);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_isStorageAllocated, "isStorageAllocated(self) -> bool");

extern "C" {static PyObject *meth_QOpenGLTexture_isStorageAllocated(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_isStorageAllocated(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            bool sipRes;

            sipRes = sipCpp->isStorageAllocated();

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_isStorageAllocated, doc_QOpenGLTexture_isStorageAllocated);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_createTextureView, "createTextureView(self, QOpenGLTexture.Target, QOpenGLTexture.TextureFormat, int, int, int, int) -> QOpenGLTexture");

extern "C" {static PyObject *meth_QOpenGLTexture_createTextureView(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_createTextureView(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QOpenGLTexture::Target a0;
         ::QOpenGLTexture::TextureFormat a1;
        int a2;
        int a3;
        int a4;
        int a5;
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BEEiiii", &sipSelf, sipType_QOpenGLTexture, &sipCpp, sipType_QOpenGLTexture_Target, &a0, sipType_QOpenGLTexture_TextureFormat, &a1, &a2, &a3, &a4, &a5))
        {
             ::QOpenGLTexture*sipRes;

            sipRes = sipCpp->createTextureView(a0,a1,a2,a3,a4,a5);

            return sipConvertFromNewType(sipRes,sipType_QOpenGLTexture,SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_createTextureView, doc_QOpenGLTexture_createTextureView);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_isTextureView, "isTextureView(self) -> bool");

extern "C" {static PyObject *meth_QOpenGLTexture_isTextureView(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_isTextureView(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            bool sipRes;

            sipRes = sipCpp->isTextureView();

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_isTextureView, doc_QOpenGLTexture_isTextureView);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setData, "setData(self, int, int, QOpenGLTexture.CubeMapFace, QOpenGLTexture.PixelFormat, QOpenGLTexture.PixelType, PyQt5.sip.voidptr, options: QOpenGLPixelTransferOptions = None)\n"
"setData(self, int, int, QOpenGLTexture.PixelFormat, QOpenGLTexture.PixelType, PyQt5.sip.voidptr, options: QOpenGLPixelTransferOptions = None)\n"
"setData(self, int, QOpenGLTexture.PixelFormat, QOpenGLTexture.PixelType, PyQt5.sip.voidptr, options: QOpenGLPixelTransferOptions = None)\n"
"setData(self, QOpenGLTexture.PixelFormat, QOpenGLTexture.PixelType, PyQt5.sip.voidptr, options: QOpenGLPixelTransferOptions = None)\n"
"setData(self, QImage, genMipMaps: QOpenGLTexture.MipMapGeneration = QOpenGLTexture.GenerateMipMaps)\n"
"setData(self, int, int, int, QOpenGLTexture.CubeMapFace, QOpenGLTexture.PixelFormat, QOpenGLTexture.PixelType, PyQt5.sip.voidptr, options: QOpenGLPixelTransferOptions = None)\n"
"setData(self, int, int, int, int, int, int, QOpenGLTexture.PixelFormat, QOpenGLTexture.PixelType, PyQt5.sip.voidptr, options: QOpenGLPixelTransferOptions = None)\n"
"setData(self, int, int, int, int, int, int, int, QOpenGLTexture.PixelFormat, QOpenGLTexture.PixelType, PyQt5.sip.voidptr, options: QOpenGLPixelTransferOptions = None)\n"
"setData(self, int, int, int, int, int, int, int, int, QOpenGLTexture.PixelFormat, QOpenGLTexture.PixelType, PyQt5.sip.voidptr, options: QOpenGLPixelTransferOptions = None)\n"
"setData(self, int, int, int, int, int, int, int, int, QOpenGLTexture.CubeMapFace, QOpenGLTexture.PixelFormat, QOpenGLTexture.PixelType, PyQt5.sip.voidptr, options: QOpenGLPixelTransferOptions = None)\n"
"setData(self, int, int, int, int, int, int, int, int, QOpenGLTexture.CubeMapFace, int, QOpenGLTexture.PixelFormat, QOpenGLTexture.PixelType, PyQt5.sip.voidptr, options: QOpenGLPixelTransferOptions = None)");

extern "C" {static PyObject *meth_QOpenGLTexture_setData(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setData(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        int a0;
        int a1;
         ::QOpenGLTexture::CubeMapFace a2;
         ::QOpenGLTexture::PixelFormat a3;
         ::QOpenGLTexture::PixelType a4;
        const void* a5;
        const  ::QOpenGLPixelTransferOptions* const a6 = 0;
         ::QOpenGLTexture *sipCpp;

        static const char *sipKwdList[] = {
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            sipName_options,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BiiEEEv|J8", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0, &a1, sipType_QOpenGLTexture_CubeMapFace, &a2, sipType_QOpenGLTexture_PixelFormat, &a3, sipType_QOpenGLTexture_PixelType, &a4, &a5, sipType_QOpenGLPixelTransferOptions, &a6))
        {
            sipCpp->setData(a0,a1,a2,a3,a4,a5,a6);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        int a1;
         ::QOpenGLTexture::PixelFormat a2;
         ::QOpenGLTexture::PixelType a3;
        const void* a4;
        const  ::QOpenGLPixelTransferOptions* const a5 = 0;
         ::QOpenGLTexture *sipCpp;

        static const char *sipKwdList[] = {
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            sipName_options,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BiiEEv|J8", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0, &a1, sipType_QOpenGLTexture_PixelFormat, &a2, sipType_QOpenGLTexture_PixelType, &a3, &a4, sipType_QOpenGLPixelTransferOptions, &a5))
        {
            sipCpp->setData(a0,a1,a2,a3,a4,a5);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
         ::QOpenGLTexture::PixelFormat a1;
         ::QOpenGLTexture::PixelType a2;
        const void* a3;
        const  ::QOpenGLPixelTransferOptions* const a4 = 0;
         ::QOpenGLTexture *sipCpp;

        static const char *sipKwdList[] = {
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            sipName_options,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BiEEv|J8", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0, sipType_QOpenGLTexture_PixelFormat, &a1, sipType_QOpenGLTexture_PixelType, &a2, &a3, sipType_QOpenGLPixelTransferOptions, &a4))
        {
            sipCpp->setData(a0,a1,a2,a3,a4);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
         ::QOpenGLTexture::PixelFormat a0;
         ::QOpenGLTexture::PixelType a1;
        const void* a2;
        const  ::QOpenGLPixelTransferOptions* const a3 = 0;
         ::QOpenGLTexture *sipCpp;

        static const char *sipKwdList[] = {
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            sipName_options,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BEEv|J8", &sipSelf, sipType_QOpenGLTexture, &sipCpp, sipType_QOpenGLTexture_PixelFormat, &a0, sipType_QOpenGLTexture_PixelType, &a1, &a2, sipType_QOpenGLPixelTransferOptions, &a3))
        {
            sipCpp->setData(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const  ::QImage* a0;
         ::QOpenGLTexture::MipMapGeneration a1 = QOpenGLTexture::GenerateMipMaps;
         ::QOpenGLTexture *sipCpp;

        static const char *sipKwdList[] = {
            SIP_NULLPTR,
            sipName_genMipMaps,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ9|E", &sipSelf, sipType_QOpenGLTexture, &sipCpp, sipType_QImage, &a0, sipType_QOpenGLTexture_MipMapGeneration, &a1))
        {
            sipCpp->setData(*a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        int a1;
        int a2;
         ::QOpenGLTexture::CubeMapFace a3;
         ::QOpenGLTexture::PixelFormat a4;
         ::QOpenGLTexture::PixelType a5;
        const void* a6;
        const  ::QOpenGLPixelTransferOptions* const a7 = 0;
         ::QOpenGLTexture *sipCpp;

        static const char *sipKwdList[] = {
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            sipName_options,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BiiiEEEv|J8", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0, &a1, &a2, sipType_QOpenGLTexture_CubeMapFace, &a3, sipType_QOpenGLTexture_PixelFormat, &a4, sipType_QOpenGLTexture_PixelType, &a5, &a6, sipType_QOpenGLPixelTransferOptions, &a7))
        {
            sipCpp->setData(a0,a1,a2,a3,a4,a5,a6,a7);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        int a1;
        int a2;
        int a3;
        int a4;
        int a5;
         ::QOpenGLTexture::PixelFormat a6;
         ::QOpenGLTexture::PixelType a7;
        const void* a8;
        const  ::QOpenGLPixelTransferOptions* const a9 = 0;
         ::QOpenGLTexture *sipCpp;

        static const char *sipKwdList[] = {
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            sipName_options,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BiiiiiiEEv|J8", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5, sipType_QOpenGLTexture_PixelFormat, &a6, sipType_QOpenGLTexture_PixelType, &a7, &a8, sipType_QOpenGLPixelTransferOptions, &a9))
        {
            sipCpp->setData(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        int a1;
        int a2;
        int a3;
        int a4;
        int a5;
        int a6;
         ::QOpenGLTexture::PixelFormat a7;
         ::QOpenGLTexture::PixelType a8;
        const void* a9;
        const  ::QOpenGLPixelTransferOptions* const a10 = 0;
         ::QOpenGLTexture *sipCpp;

        static const char *sipKwdList[] = {
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            sipName_options,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BiiiiiiiEEv|J8", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5, &a6, sipType_QOpenGLTexture_PixelFormat, &a7, sipType_QOpenGLTexture_PixelType, &a8, &a9, sipType_QOpenGLPixelTransferOptions, &a10))
        {
            sipCpp->setData(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        int a1;
        int a2;
        int a3;
        int a4;
        int a5;
        int a6;
        int a7;
         ::QOpenGLTexture::PixelFormat a8;
         ::QOpenGLTexture::PixelType a9;
        const void* a10;
        const  ::QOpenGLPixelTransferOptions* const a11 = 0;
         ::QOpenGLTexture *sipCpp;

        static const char *sipKwdList[] = {
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            sipName_options,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BiiiiiiiiEEv|J8", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7, sipType_QOpenGLTexture_PixelFormat, &a8, sipType_QOpenGLTexture_PixelType, &a9, &a10, sipType_QOpenGLPixelTransferOptions, &a11))
        {
            sipCpp->setData(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        int a1;
        int a2;
        int a3;
        int a4;
        int a5;
        int a6;
        int a7;
         ::QOpenGLTexture::CubeMapFace a8;
         ::QOpenGLTexture::PixelFormat a9;
         ::QOpenGLTexture::PixelType a10;
        const void* a11;
        const  ::QOpenGLPixelTransferOptions* const a12 = 0;
         ::QOpenGLTexture *sipCpp;

        static const char *sipKwdList[] = {
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            sipName_options,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BiiiiiiiiEEEv|J8", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7, sipType_QOpenGLTexture_CubeMapFace, &a8, sipType_QOpenGLTexture_PixelFormat, &a9, sipType_QOpenGLTexture_PixelType, &a10, &a11, sipType_QOpenGLPixelTransferOptions, &a12))
        {
            sipCpp->setData(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        int a1;
        int a2;
        int a3;
        int a4;
        int a5;
        int a6;
        int a7;
         ::QOpenGLTexture::CubeMapFace a8;
        int a9;
         ::QOpenGLTexture::PixelFormat a10;
         ::QOpenGLTexture::PixelType a11;
        const void* a12;
        const  ::QOpenGLPixelTransferOptions* const a13 = 0;
         ::QOpenGLTexture *sipCpp;

        static const char *sipKwdList[] = {
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            sipName_options,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BiiiiiiiiEiEEv|J8", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7, sipType_QOpenGLTexture_CubeMapFace, &a8, &a9, sipType_QOpenGLTexture_PixelFormat, &a10, sipType_QOpenGLTexture_PixelType, &a11, &a12, sipType_QOpenGLPixelTransferOptions, &a13))
        {
            sipCpp->setData(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setData, doc_QOpenGLTexture_setData);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setCompressedData, "setCompressedData(self, int, int, QOpenGLTexture.CubeMapFace, int, PyQt5.sip.voidptr, options: QOpenGLPixelTransferOptions = None)\n"
"setCompressedData(self, int, int, int, PyQt5.sip.voidptr, options: QOpenGLPixelTransferOptions = None)\n"
"setCompressedData(self, int, int, PyQt5.sip.voidptr, options: QOpenGLPixelTransferOptions = None)\n"
"setCompressedData(self, int, PyQt5.sip.voidptr, options: QOpenGLPixelTransferOptions = None)\n"
"setCompressedData(self, int, int, int, QOpenGLTexture.CubeMapFace, int, PyQt5.sip.voidptr, options: QOpenGLPixelTransferOptions = None)");

extern "C" {static PyObject *meth_QOpenGLTexture_setCompressedData(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setCompressedData(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        int a0;
        int a1;
         ::QOpenGLTexture::CubeMapFace a2;
        int a3;
        const void* a4;
        const  ::QOpenGLPixelTransferOptions* const a5 = 0;
         ::QOpenGLTexture *sipCpp;

        static const char *sipKwdList[] = {
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            sipName_options,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BiiEiv|J8", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0, &a1, sipType_QOpenGLTexture_CubeMapFace, &a2, &a3, &a4, sipType_QOpenGLPixelTransferOptions, &a5))
        {
            sipCpp->setCompressedData(a0,a1,a2,a3,a4,a5);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        int a1;
        int a2;
        const void* a3;
        const  ::QOpenGLPixelTransferOptions* const a4 = 0;
         ::QOpenGLTexture *sipCpp;

        static const char *sipKwdList[] = {
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            sipName_options,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Biiiv|J8", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0, &a1, &a2, &a3, sipType_QOpenGLPixelTransferOptions, &a4))
        {
            sipCpp->setCompressedData(a0,a1,a2,a3,a4);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        int a1;
        const void* a2;
        const  ::QOpenGLPixelTransferOptions* const a3 = 0;
         ::QOpenGLTexture *sipCpp;

        static const char *sipKwdList[] = {
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            sipName_options,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Biiv|J8", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0, &a1, &a2, sipType_QOpenGLPixelTransferOptions, &a3))
        {
            sipCpp->setCompressedData(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const void* a1;
        const  ::QOpenGLPixelTransferOptions* const a2 = 0;
         ::QOpenGLTexture *sipCpp;

        static const char *sipKwdList[] = {
            SIP_NULLPTR,
            SIP_NULLPTR,
            sipName_options,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Biv|J8", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0, &a1, sipType_QOpenGLPixelTransferOptions, &a2))
        {
            sipCpp->setCompressedData(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        int a1;
        int a2;
         ::QOpenGLTexture::CubeMapFace a3;
        int a4;
        const void* a5;
        const  ::QOpenGLPixelTransferOptions* const a6 = 0;
         ::QOpenGLTexture *sipCpp;

        static const char *sipKwdList[] = {
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            SIP_NULLPTR,
            sipName_options,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BiiiEiv|J8", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0, &a1, &a2, sipType_QOpenGLTexture_CubeMapFace, &a3, &a4, &a5, sipType_QOpenGLPixelTransferOptions, &a6))
        {
            sipCpp->setCompressedData(a0,a1,a2,a3,a4,a5,a6);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setCompressedData, doc_QOpenGLTexture_setCompressedData);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_hasFeature, "hasFeature(QOpenGLTexture.Feature) -> bool");

extern "C" {static PyObject *meth_QOpenGLTexture_hasFeature(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_hasFeature(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QOpenGLTexture::Feature a0;

        if (sipParseArgs(&sipParseErr, sipArgs, "E", sipType_QOpenGLTexture_Feature, &a0))
        {
            bool sipRes;

            sipRes =  ::QOpenGLTexture::hasFeature(a0);

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_hasFeature, doc_QOpenGLTexture_hasFeature);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setMipBaseLevel, "setMipBaseLevel(self, int)");

extern "C" {static PyObject *meth_QOpenGLTexture_setMipBaseLevel(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setMipBaseLevel(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        int a0;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0))
        {
            sipCpp->setMipBaseLevel(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setMipBaseLevel, doc_QOpenGLTexture_setMipBaseLevel);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_mipBaseLevel, "mipBaseLevel(self) -> int");

extern "C" {static PyObject *meth_QOpenGLTexture_mipBaseLevel(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_mipBaseLevel(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            int sipRes;

            sipRes = sipCpp->mipBaseLevel();

            return PyLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_mipBaseLevel, doc_QOpenGLTexture_mipBaseLevel);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setMipMaxLevel, "setMipMaxLevel(self, int)");

extern "C" {static PyObject *meth_QOpenGLTexture_setMipMaxLevel(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setMipMaxLevel(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        int a0;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0))
        {
            sipCpp->setMipMaxLevel(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setMipMaxLevel, doc_QOpenGLTexture_setMipMaxLevel);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_mipMaxLevel, "mipMaxLevel(self) -> int");

extern "C" {static PyObject *meth_QOpenGLTexture_mipMaxLevel(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_mipMaxLevel(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            int sipRes;

            sipRes = sipCpp->mipMaxLevel();

            return PyLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_mipMaxLevel, doc_QOpenGLTexture_mipMaxLevel);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setMipLevelRange, "setMipLevelRange(self, int, int)");

extern "C" {static PyObject *meth_QOpenGLTexture_setMipLevelRange(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setMipLevelRange(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        int a0;
        int a1;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bii", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0, &a1))
        {
            sipCpp->setMipLevelRange(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setMipLevelRange, doc_QOpenGLTexture_setMipLevelRange);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_mipLevelRange, "mipLevelRange(self) -> Tuple[int, int]");

extern "C" {static PyObject *meth_QOpenGLTexture_mipLevelRange(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_mipLevelRange(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
             ::QPair<int,int>*sipRes;

            sipRes = new  ::QPair<int,int>(sipCpp->mipLevelRange());

            return sipConvertFromNewType(sipRes,sipType_QPair_1800_1800,SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_mipLevelRange, doc_QOpenGLTexture_mipLevelRange);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setAutoMipMapGenerationEnabled, "setAutoMipMapGenerationEnabled(self, bool)");

extern "C" {static PyObject *meth_QOpenGLTexture_setAutoMipMapGenerationEnabled(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setAutoMipMapGenerationEnabled(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        bool a0;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bb", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0))
        {
            sipCpp->setAutoMipMapGenerationEnabled(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setAutoMipMapGenerationEnabled, doc_QOpenGLTexture_setAutoMipMapGenerationEnabled);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_isAutoMipMapGenerationEnabled, "isAutoMipMapGenerationEnabled(self) -> bool");

extern "C" {static PyObject *meth_QOpenGLTexture_isAutoMipMapGenerationEnabled(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_isAutoMipMapGenerationEnabled(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            bool sipRes;

            sipRes = sipCpp->isAutoMipMapGenerationEnabled();

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_isAutoMipMapGenerationEnabled, doc_QOpenGLTexture_isAutoMipMapGenerationEnabled);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_generateMipMaps, "generateMipMaps(self)\n"
"generateMipMaps(self, int, resetBaseLevel: bool = True)");

extern "C" {static PyObject *meth_QOpenGLTexture_generateMipMaps(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_generateMipMaps(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QOpenGLTexture *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, SIP_NULLPTR, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            sipCpp->generateMipMaps();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        bool a1 = 1;
         ::QOpenGLTexture *sipCpp;

        static const char *sipKwdList[] = {
            SIP_NULLPTR,
            sipName_resetBaseLevel,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Bi|b", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0, &a1))
        {
            sipCpp->generateMipMaps(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_generateMipMaps, doc_QOpenGLTexture_generateMipMaps);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setSwizzleMask, "setSwizzleMask(self, QOpenGLTexture.SwizzleComponent, QOpenGLTexture.SwizzleValue)\n"
"setSwizzleMask(self, QOpenGLTexture.SwizzleValue, QOpenGLTexture.SwizzleValue, QOpenGLTexture.SwizzleValue, QOpenGLTexture.SwizzleValue)");

extern "C" {static PyObject *meth_QOpenGLTexture_setSwizzleMask(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setSwizzleMask(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QOpenGLTexture::SwizzleComponent a0;
         ::QOpenGLTexture::SwizzleValue a1;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BEE", &sipSelf, sipType_QOpenGLTexture, &sipCpp, sipType_QOpenGLTexture_SwizzleComponent, &a0, sipType_QOpenGLTexture_SwizzleValue, &a1))
        {
            sipCpp->setSwizzleMask(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
         ::QOpenGLTexture::SwizzleValue a0;
         ::QOpenGLTexture::SwizzleValue a1;
         ::QOpenGLTexture::SwizzleValue a2;
         ::QOpenGLTexture::SwizzleValue a3;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BEEEE", &sipSelf, sipType_QOpenGLTexture, &sipCpp, sipType_QOpenGLTexture_SwizzleValue, &a0, sipType_QOpenGLTexture_SwizzleValue, &a1, sipType_QOpenGLTexture_SwizzleValue, &a2, sipType_QOpenGLTexture_SwizzleValue, &a3))
        {
            sipCpp->setSwizzleMask(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setSwizzleMask, doc_QOpenGLTexture_setSwizzleMask);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_swizzleMask, "swizzleMask(self, QOpenGLTexture.SwizzleComponent) -> QOpenGLTexture.SwizzleValue");

extern "C" {static PyObject *meth_QOpenGLTexture_swizzleMask(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_swizzleMask(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QOpenGLTexture::SwizzleComponent a0;
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QOpenGLTexture, &sipCpp, sipType_QOpenGLTexture_SwizzleComponent, &a0))
        {
             ::QOpenGLTexture::SwizzleValue sipRes;

            sipRes = sipCpp->swizzleMask(a0);

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QOpenGLTexture_SwizzleValue);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_swizzleMask, doc_QOpenGLTexture_swizzleMask);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setDepthStencilMode, "setDepthStencilMode(self, QOpenGLTexture.DepthStencilMode)");

extern "C" {static PyObject *meth_QOpenGLTexture_setDepthStencilMode(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setDepthStencilMode(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QOpenGLTexture::DepthStencilMode a0;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QOpenGLTexture, &sipCpp, sipType_QOpenGLTexture_DepthStencilMode, &a0))
        {
            sipCpp->setDepthStencilMode(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setDepthStencilMode, doc_QOpenGLTexture_setDepthStencilMode);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_depthStencilMode, "depthStencilMode(self) -> QOpenGLTexture.DepthStencilMode");

extern "C" {static PyObject *meth_QOpenGLTexture_depthStencilMode(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_depthStencilMode(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
             ::QOpenGLTexture::DepthStencilMode sipRes;

            sipRes = sipCpp->depthStencilMode();

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QOpenGLTexture_DepthStencilMode);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_depthStencilMode, doc_QOpenGLTexture_depthStencilMode);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setMinificationFilter, "setMinificationFilter(self, QOpenGLTexture.Filter)");

extern "C" {static PyObject *meth_QOpenGLTexture_setMinificationFilter(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setMinificationFilter(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QOpenGLTexture::Filter a0;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QOpenGLTexture, &sipCpp, sipType_QOpenGLTexture_Filter, &a0))
        {
            sipCpp->setMinificationFilter(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setMinificationFilter, doc_QOpenGLTexture_setMinificationFilter);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_minificationFilter, "minificationFilter(self) -> QOpenGLTexture.Filter");

extern "C" {static PyObject *meth_QOpenGLTexture_minificationFilter(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_minificationFilter(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
             ::QOpenGLTexture::Filter sipRes;

            sipRes = sipCpp->minificationFilter();

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QOpenGLTexture_Filter);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_minificationFilter, doc_QOpenGLTexture_minificationFilter);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setMagnificationFilter, "setMagnificationFilter(self, QOpenGLTexture.Filter)");

extern "C" {static PyObject *meth_QOpenGLTexture_setMagnificationFilter(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setMagnificationFilter(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QOpenGLTexture::Filter a0;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QOpenGLTexture, &sipCpp, sipType_QOpenGLTexture_Filter, &a0))
        {
            sipCpp->setMagnificationFilter(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setMagnificationFilter, doc_QOpenGLTexture_setMagnificationFilter);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_magnificationFilter, "magnificationFilter(self) -> QOpenGLTexture.Filter");

extern "C" {static PyObject *meth_QOpenGLTexture_magnificationFilter(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_magnificationFilter(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
             ::QOpenGLTexture::Filter sipRes;

            sipRes = sipCpp->magnificationFilter();

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QOpenGLTexture_Filter);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_magnificationFilter, doc_QOpenGLTexture_magnificationFilter);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setMinMagFilters, "setMinMagFilters(self, QOpenGLTexture.Filter, QOpenGLTexture.Filter)");

extern "C" {static PyObject *meth_QOpenGLTexture_setMinMagFilters(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setMinMagFilters(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QOpenGLTexture::Filter a0;
         ::QOpenGLTexture::Filter a1;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BEE", &sipSelf, sipType_QOpenGLTexture, &sipCpp, sipType_QOpenGLTexture_Filter, &a0, sipType_QOpenGLTexture_Filter, &a1))
        {
            sipCpp->setMinMagFilters(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setMinMagFilters, doc_QOpenGLTexture_setMinMagFilters);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_minMagFilters, "minMagFilters(self) -> Tuple[QOpenGLTexture.Filter, QOpenGLTexture.Filter]");

extern "C" {static PyObject *meth_QOpenGLTexture_minMagFilters(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_minMagFilters(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
             ::QPair< ::QOpenGLTexture::Filter, ::QOpenGLTexture::Filter>*sipRes;

            sipRes = new  ::QPair< ::QOpenGLTexture::Filter, ::QOpenGLTexture::Filter>(sipCpp->minMagFilters());

            return sipConvertFromNewType(sipRes,sipType_QPair_0100QOpenGLTexture_Filter_0100QOpenGLTexture_Filter,SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_minMagFilters, doc_QOpenGLTexture_minMagFilters);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setMaximumAnisotropy, "setMaximumAnisotropy(self, float)");

extern "C" {static PyObject *meth_QOpenGLTexture_setMaximumAnisotropy(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setMaximumAnisotropy(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        float a0;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bf", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0))
        {
            sipCpp->setMaximumAnisotropy(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setMaximumAnisotropy, doc_QOpenGLTexture_setMaximumAnisotropy);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_maximumAnisotropy, "maximumAnisotropy(self) -> float");

extern "C" {static PyObject *meth_QOpenGLTexture_maximumAnisotropy(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_maximumAnisotropy(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            float sipRes;

            sipRes = sipCpp->maximumAnisotropy();

            return PyFloat_FromDouble((double)sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_maximumAnisotropy, doc_QOpenGLTexture_maximumAnisotropy);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setWrapMode, "setWrapMode(self, QOpenGLTexture.WrapMode)\n"
"setWrapMode(self, QOpenGLTexture.CoordinateDirection, QOpenGLTexture.WrapMode)");

extern "C" {static PyObject *meth_QOpenGLTexture_setWrapMode(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setWrapMode(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QOpenGLTexture::WrapMode a0;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QOpenGLTexture, &sipCpp, sipType_QOpenGLTexture_WrapMode, &a0))
        {
            sipCpp->setWrapMode(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
         ::QOpenGLTexture::CoordinateDirection a0;
         ::QOpenGLTexture::WrapMode a1;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BEE", &sipSelf, sipType_QOpenGLTexture, &sipCpp, sipType_QOpenGLTexture_CoordinateDirection, &a0, sipType_QOpenGLTexture_WrapMode, &a1))
        {
            sipCpp->setWrapMode(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setWrapMode, doc_QOpenGLTexture_setWrapMode);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_wrapMode, "wrapMode(self, QOpenGLTexture.CoordinateDirection) -> QOpenGLTexture.WrapMode");

extern "C" {static PyObject *meth_QOpenGLTexture_wrapMode(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_wrapMode(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QOpenGLTexture::CoordinateDirection a0;
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QOpenGLTexture, &sipCpp, sipType_QOpenGLTexture_CoordinateDirection, &a0))
        {
             ::QOpenGLTexture::WrapMode sipRes;

            sipRes = sipCpp->wrapMode(a0);

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QOpenGLTexture_WrapMode);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_wrapMode, doc_QOpenGLTexture_wrapMode);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setBorderColor, "setBorderColor(self, Union[QColor, Qt.GlobalColor, QGradient])");

extern "C" {static PyObject *meth_QOpenGLTexture_setBorderColor(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setBorderColor(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QColor* a0;
        int a0State = 0;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QOpenGLTexture, &sipCpp, sipType_QColor, &a0, &a0State))
        {
            sipCpp->setBorderColor(*a0);
            sipReleaseType(a0, sipType_QColor, a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setBorderColor, doc_QOpenGLTexture_setBorderColor);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_borderColor, "borderColor(self) -> QColor");

extern "C" {static PyObject *meth_QOpenGLTexture_borderColor(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_borderColor(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
             ::QColor*sipRes;

            sipRes = new  ::QColor(sipCpp->borderColor());

            return sipConvertFromNewType(sipRes,sipType_QColor,SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_borderColor, doc_QOpenGLTexture_borderColor);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setMinimumLevelOfDetail, "setMinimumLevelOfDetail(self, float)");

extern "C" {static PyObject *meth_QOpenGLTexture_setMinimumLevelOfDetail(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setMinimumLevelOfDetail(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        float a0;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bf", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0))
        {
            sipCpp->setMinimumLevelOfDetail(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setMinimumLevelOfDetail, doc_QOpenGLTexture_setMinimumLevelOfDetail);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_minimumLevelOfDetail, "minimumLevelOfDetail(self) -> float");

extern "C" {static PyObject *meth_QOpenGLTexture_minimumLevelOfDetail(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_minimumLevelOfDetail(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            float sipRes;

            sipRes = sipCpp->minimumLevelOfDetail();

            return PyFloat_FromDouble((double)sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_minimumLevelOfDetail, doc_QOpenGLTexture_minimumLevelOfDetail);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setMaximumLevelOfDetail, "setMaximumLevelOfDetail(self, float)");

extern "C" {static PyObject *meth_QOpenGLTexture_setMaximumLevelOfDetail(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setMaximumLevelOfDetail(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        float a0;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bf", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0))
        {
            sipCpp->setMaximumLevelOfDetail(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setMaximumLevelOfDetail, doc_QOpenGLTexture_setMaximumLevelOfDetail);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_maximumLevelOfDetail, "maximumLevelOfDetail(self) -> float");

extern "C" {static PyObject *meth_QOpenGLTexture_maximumLevelOfDetail(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_maximumLevelOfDetail(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            float sipRes;

            sipRes = sipCpp->maximumLevelOfDetail();

            return PyFloat_FromDouble((double)sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_maximumLevelOfDetail, doc_QOpenGLTexture_maximumLevelOfDetail);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setLevelOfDetailRange, "setLevelOfDetailRange(self, float, float)");

extern "C" {static PyObject *meth_QOpenGLTexture_setLevelOfDetailRange(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setLevelOfDetailRange(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        float a0;
        float a1;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bff", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0, &a1))
        {
            sipCpp->setLevelOfDetailRange(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setLevelOfDetailRange, doc_QOpenGLTexture_setLevelOfDetailRange);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_levelOfDetailRange, "levelOfDetailRange(self) -> Tuple[float, float]");

extern "C" {static PyObject *meth_QOpenGLTexture_levelOfDetailRange(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_levelOfDetailRange(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
             ::QPair<float,float>*sipRes;

            sipRes = new  ::QPair<float,float>(sipCpp->levelOfDetailRange());

            return sipConvertFromNewType(sipRes,sipType_QPair_2200_2200,SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_levelOfDetailRange, doc_QOpenGLTexture_levelOfDetailRange);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setLevelofDetailBias, "setLevelofDetailBias(self, float)");

extern "C" {static PyObject *meth_QOpenGLTexture_setLevelofDetailBias(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setLevelofDetailBias(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        float a0;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bf", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0))
        {
            sipCpp->setLevelofDetailBias(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setLevelofDetailBias, doc_QOpenGLTexture_setLevelofDetailBias);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_levelofDetailBias, "levelofDetailBias(self) -> float");

extern "C" {static PyObject *meth_QOpenGLTexture_levelofDetailBias(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_levelofDetailBias(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            float sipRes;

            sipRes = sipCpp->levelofDetailBias();

            return PyFloat_FromDouble((double)sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_levelofDetailBias, doc_QOpenGLTexture_levelofDetailBias);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_target, "target(self) -> QOpenGLTexture.Target");

extern "C" {static PyObject *meth_QOpenGLTexture_target(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_target(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
             ::QOpenGLTexture::Target sipRes;

            sipRes = sipCpp->target();

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QOpenGLTexture_Target);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_target, doc_QOpenGLTexture_target);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setSamples, "setSamples(self, int)");

extern "C" {static PyObject *meth_QOpenGLTexture_setSamples(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setSamples(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        int a0;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0))
        {
            sipCpp->setSamples(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setSamples, doc_QOpenGLTexture_setSamples);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_samples, "samples(self) -> int");

extern "C" {static PyObject *meth_QOpenGLTexture_samples(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_samples(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            int sipRes;

            sipRes = sipCpp->samples();

            return PyLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_samples, doc_QOpenGLTexture_samples);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setFixedSamplePositions, "setFixedSamplePositions(self, bool)");

extern "C" {static PyObject *meth_QOpenGLTexture_setFixedSamplePositions(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setFixedSamplePositions(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        bool a0;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bb", &sipSelf, sipType_QOpenGLTexture, &sipCpp, &a0))
        {
            sipCpp->setFixedSamplePositions(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setFixedSamplePositions, doc_QOpenGLTexture_setFixedSamplePositions);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_isFixedSamplePositions, "isFixedSamplePositions(self) -> bool");

extern "C" {static PyObject *meth_QOpenGLTexture_isFixedSamplePositions(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_isFixedSamplePositions(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
            bool sipRes;

            sipRes = sipCpp->isFixedSamplePositions();

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_isFixedSamplePositions, doc_QOpenGLTexture_isFixedSamplePositions);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setComparisonFunction, "setComparisonFunction(self, QOpenGLTexture.ComparisonFunction)");

extern "C" {static PyObject *meth_QOpenGLTexture_setComparisonFunction(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setComparisonFunction(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QOpenGLTexture::ComparisonFunction a0;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QOpenGLTexture, &sipCpp, sipType_QOpenGLTexture_ComparisonFunction, &a0))
        {
            sipCpp->setComparisonFunction(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setComparisonFunction, doc_QOpenGLTexture_setComparisonFunction);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_comparisonFunction, "comparisonFunction(self) -> QOpenGLTexture.ComparisonFunction");

extern "C" {static PyObject *meth_QOpenGLTexture_comparisonFunction(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_comparisonFunction(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
             ::QOpenGLTexture::ComparisonFunction sipRes;

            sipRes = sipCpp->comparisonFunction();

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QOpenGLTexture_ComparisonFunction);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_comparisonFunction, doc_QOpenGLTexture_comparisonFunction);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_setComparisonMode, "setComparisonMode(self, QOpenGLTexture.ComparisonMode)");

extern "C" {static PyObject *meth_QOpenGLTexture_setComparisonMode(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_setComparisonMode(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
         ::QOpenGLTexture::ComparisonMode a0;
         ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QOpenGLTexture, &sipCpp, sipType_QOpenGLTexture_ComparisonMode, &a0))
        {
            sipCpp->setComparisonMode(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_setComparisonMode, doc_QOpenGLTexture_setComparisonMode);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QOpenGLTexture_comparisonMode, "comparisonMode(self) -> QOpenGLTexture.ComparisonMode");

extern "C" {static PyObject *meth_QOpenGLTexture_comparisonMode(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLTexture_comparisonMode(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QOpenGLTexture *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLTexture, &sipCpp))
        {
             ::QOpenGLTexture::ComparisonMode sipRes;

            sipRes = sipCpp->comparisonMode();

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QOpenGLTexture_ComparisonMode);
        }
    }

    sipNoMethod(sipParseErr, sipName_QOpenGLTexture, sipName_comparisonMode, doc_QOpenGLTexture_comparisonMode);

    return SIP_NULLPTR;
}


/* Call the instance's destructor. */
extern "C" {static void release_QOpenGLTexture(void *, int);}
static void release_QOpenGLTexture(void *sipCppV, int)
{
    delete reinterpret_cast< ::QOpenGLTexture *>(sipCppV);
}


extern "C" {static void dealloc_QOpenGLTexture(sipSimpleWrapper *);}
static void dealloc_QOpenGLTexture(sipSimpleWrapper *sipSelf)
{
    if (sipIsOwnedByPython(sipSelf))
    {
        release_QOpenGLTexture(sipGetAddress(sipSelf), 0);
    }
}


extern "C" {static void *init_type_QOpenGLTexture(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QOpenGLTexture(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
     ::QOpenGLTexture *sipCpp = SIP_NULLPTR;

    {
         ::QOpenGLTexture::Target a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, sipUnused, "E", sipType_QOpenGLTexture_Target, &a0))
        {
            sipCpp = new  ::QOpenGLTexture(a0);

            return sipCpp;
        }
    }

    {
        const  ::QImage* a0;
         ::QOpenGLTexture::MipMapGeneration a1 = QOpenGLTexture::GenerateMipMaps;

        static const char *sipKwdList[] = {
            SIP_NULLPTR,
            sipName_genMipMaps,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J9|E", sipType_QImage, &a0, sipType_QOpenGLTexture_MipMapGeneration, &a1))
        {
            sipCpp = new  ::QOpenGLTexture(*a0,a1);

            return sipCpp;
        }
    }

    return SIP_NULLPTR;
}


static PyMethodDef methods_QOpenGLTexture[] = {
    {sipName_allocateStorage, meth_QOpenGLTexture_allocateStorage, METH_VARARGS, doc_QOpenGLTexture_allocateStorage},
    {sipName_bind, SIP_MLMETH_CAST(meth_QOpenGLTexture_bind), METH_VARARGS|METH_KEYWORDS, doc_QOpenGLTexture_bind},
    {sipName_borderColor, meth_QOpenGLTexture_borderColor, METH_VARARGS, doc_QOpenGLTexture_borderColor},
    {sipName_boundTextureId, meth_QOpenGLTexture_boundTextureId, METH_VARARGS, doc_QOpenGLTexture_boundTextureId},
    {sipName_comparisonFunction, meth_QOpenGLTexture_comparisonFunction, METH_VARARGS, doc_QOpenGLTexture_comparisonFunction},
    {sipName_comparisonMode, meth_QOpenGLTexture_comparisonMode, METH_VARARGS, doc_QOpenGLTexture_comparisonMode},
    {sipName_create, meth_QOpenGLTexture_create, METH_VARARGS, doc_QOpenGLTexture_create},
    {sipName_createTextureView, meth_QOpenGLTexture_createTextureView, METH_VARARGS, doc_QOpenGLTexture_createTextureView},
    {sipName_depth, meth_QOpenGLTexture_depth, METH_VARARGS, doc_QOpenGLTexture_depth},
    {sipName_depthStencilMode, meth_QOpenGLTexture_depthStencilMode, METH_VARARGS, doc_QOpenGLTexture_depthStencilMode},
    {sipName_destroy, meth_QOpenGLTexture_destroy, METH_VARARGS, doc_QOpenGLTexture_destroy},
    {sipName_faces, meth_QOpenGLTexture_faces, METH_VARARGS, doc_QOpenGLTexture_faces},
    {sipName_format, meth_QOpenGLTexture_format, METH_VARARGS, doc_QOpenGLTexture_format},
    {sipName_generateMipMaps, SIP_MLMETH_CAST(meth_QOpenGLTexture_generateMipMaps), METH_VARARGS|METH_KEYWORDS, doc_QOpenGLTexture_generateMipMaps},
    {sipName_hasFeature, meth_QOpenGLTexture_hasFeature, METH_VARARGS, doc_QOpenGLTexture_hasFeature},
    {sipName_height, meth_QOpenGLTexture_height, METH_VARARGS, doc_QOpenGLTexture_height},
    {sipName_isAutoMipMapGenerationEnabled, meth_QOpenGLTexture_isAutoMipMapGenerationEnabled, METH_VARARGS, doc_QOpenGLTexture_isAutoMipMapGenerationEnabled},
    {sipName_isBound, meth_QOpenGLTexture_isBound, METH_VARARGS, doc_QOpenGLTexture_isBound},
    {sipName_isCreated, meth_QOpenGLTexture_isCreated, METH_VARARGS, doc_QOpenGLTexture_isCreated},
    {sipName_isFixedSamplePositions, meth_QOpenGLTexture_isFixedSamplePositions, METH_VARARGS, doc_QOpenGLTexture_isFixedSamplePositions},
    {sipName_isStorageAllocated, meth_QOpenGLTexture_isStorageAllocated, METH_VARARGS, doc_QOpenGLTexture_isStorageAllocated},
    {sipName_isTextureView, meth_QOpenGLTexture_isTextureView, METH_VARARGS, doc_QOpenGLTexture_isTextureView},
    {sipName_layers, meth_QOpenGLTexture_layers, METH_VARARGS, doc_QOpenGLTexture_layers},
    {sipName_levelOfDetailRange, meth_QOpenGLTexture_levelOfDetailRange, METH_VARARGS, doc_QOpenGLTexture_levelOfDetailRange},
    {sipName_levelofDetailBias, meth_QOpenGLTexture_levelofDetailBias, METH_VARARGS, doc_QOpenGLTexture_levelofDetailBias},
    {sipName_magnificationFilter, meth_QOpenGLTexture_magnificationFilter, METH_VARARGS, doc_QOpenGLTexture_magnificationFilter},
    {sipName_maximumAnisotropy, meth_QOpenGLTexture_maximumAnisotropy, METH_VARARGS, doc_QOpenGLTexture_maximumAnisotropy},
    {sipName_maximumLevelOfDetail, meth_QOpenGLTexture_maximumLevelOfDetail, METH_VARARGS, doc_QOpenGLTexture_maximumLevelOfDetail},
    {sipName_maximumMipLevels, meth_QOpenGLTexture_maximumMipLevels, METH_VARARGS, doc_QOpenGLTexture_maximumMipLevels},
    {sipName_minMagFilters, meth_QOpenGLTexture_minMagFilters, METH_VARARGS, doc_QOpenGLTexture_minMagFilters},
    {sipName_minificationFilter, meth_QOpenGLTexture_minificationFilter, METH_VARARGS, doc_QOpenGLTexture_minificationFilter},
    {sipName_minimumLevelOfDetail, meth_QOpenGLTexture_minimumLevelOfDetail, METH_VARARGS, doc_QOpenGLTexture_minimumLevelOfDetail},
    {sipName_mipBaseLevel, meth_QOpenGLTexture_mipBaseLevel, METH_VARARGS, doc_QOpenGLTexture_mipBaseLevel},
    {sipName_mipLevelRange, meth_QOpenGLTexture_mipLevelRange, METH_VARARGS, doc_QOpenGLTexture_mipLevelRange},
    {sipName_mipLevels, meth_QOpenGLTexture_mipLevels, METH_VARARGS, doc_QOpenGLTexture_mipLevels},
    {sipName_mipMaxLevel, meth_QOpenGLTexture_mipMaxLevel, METH_VARARGS, doc_QOpenGLTexture_mipMaxLevel},
    {sipName_release, SIP_MLMETH_CAST(meth_QOpenGLTexture_release), METH_VARARGS|METH_KEYWORDS, doc_QOpenGLTexture_release},
    {sipName_samples, meth_QOpenGLTexture_samples, METH_VARARGS, doc_QOpenGLTexture_samples},
    {sipName_setAutoMipMapGenerationEnabled, meth_QOpenGLTexture_setAutoMipMapGenerationEnabled, METH_VARARGS, doc_QOpenGLTexture_setAutoMipMapGenerationEnabled},
    {sipName_setBorderColor, meth_QOpenGLTexture_setBorderColor, METH_VARARGS, doc_QOpenGLTexture_setBorderColor},
    {sipName_setComparisonFunction, meth_QOpenGLTexture_setComparisonFunction, METH_VARARGS, doc_QOpenGLTexture_setComparisonFunction},
    {sipName_setComparisonMode, meth_QOpenGLTexture_setComparisonMode, METH_VARARGS, doc_QOpenGLTexture_setComparisonMode},
    {sipName_setCompressedData, SIP_MLMETH_CAST(meth_QOpenGLTexture_setCompressedData), METH_VARARGS|METH_KEYWORDS, doc_QOpenGLTexture_setCompressedData},
    {sipName_setData, SIP_MLMETH_CAST(meth_QOpenGLTexture_setData), METH_VARARGS|METH_KEYWORDS, doc_QOpenGLTexture_setData},
    {sipName_setDepthStencilMode, meth_QOpenGLTexture_setDepthStencilMode, METH_VARARGS, doc_QOpenGLTexture_setDepthStencilMode},
    {sipName_setFixedSamplePositions, meth_QOpenGLTexture_setFixedSamplePositions, METH_VARARGS, doc_QOpenGLTexture_setFixedSamplePositions},
    {sipName_setFormat, meth_QOpenGLTexture_setFormat, METH_VARARGS, doc_QOpenGLTexture_setFormat},
    {sipName_setLayers, meth_QOpenGLTexture_setLayers, METH_VARARGS, doc_QOpenGLTexture_setLayers},
    {sipName_setLevelOfDetailRange, meth_QOpenGLTexture_setLevelOfDetailRange, METH_VARARGS, doc_QOpenGLTexture_setLevelOfDetailRange},
    {sipName_setLevelofDetailBias, meth_QOpenGLTexture_setLevelofDetailBias, METH_VARARGS, doc_QOpenGLTexture_setLevelofDetailBias},
    {sipName_setMagnificationFilter, meth_QOpenGLTexture_setMagnificationFilter, METH_VARARGS, doc_QOpenGLTexture_setMagnificationFilter},
    {sipName_setMaximumAnisotropy, meth_QOpenGLTexture_setMaximumAnisotropy, METH_VARARGS, doc_QOpenGLTexture_setMaximumAnisotropy},
    {sipName_setMaximumLevelOfDetail, meth_QOpenGLTexture_setMaximumLevelOfDetail, METH_VARARGS, doc_QOpenGLTexture_setMaximumLevelOfDetail},
    {sipName_setMinMagFilters, meth_QOpenGLTexture_setMinMagFilters, METH_VARARGS, doc_QOpenGLTexture_setMinMagFilters},
    {sipName_setMinificationFilter, meth_QOpenGLTexture_setMinificationFilter, METH_VARARGS, doc_QOpenGLTexture_setMinificationFilter},
    {sipName_setMinimumLevelOfDetail, meth_QOpenGLTexture_setMinimumLevelOfDetail, METH_VARARGS, doc_QOpenGLTexture_setMinimumLevelOfDetail},
    {sipName_setMipBaseLevel, meth_QOpenGLTexture_setMipBaseLevel, METH_VARARGS, doc_QOpenGLTexture_setMipBaseLevel},
    {sipName_setMipLevelRange, meth_QOpenGLTexture_setMipLevelRange, METH_VARARGS, doc_QOpenGLTexture_setMipLevelRange},
    {sipName_setMipLevels, meth_QOpenGLTexture_setMipLevels, METH_VARARGS, doc_QOpenGLTexture_setMipLevels},
    {sipName_setMipMaxLevel, meth_QOpenGLTexture_setMipMaxLevel, METH_VARARGS, doc_QOpenGLTexture_setMipMaxLevel},
    {sipName_setSamples, meth_QOpenGLTexture_setSamples, METH_VARARGS, doc_QOpenGLTexture_setSamples},
    {sipName_setSize, SIP_MLMETH_CAST(meth_QOpenGLTexture_setSize), METH_VARARGS|METH_KEYWORDS, doc_QOpenGLTexture_setSize},
    {sipName_setSwizzleMask, meth_QOpenGLTexture_setSwizzleMask, METH_VARARGS, doc_QOpenGLTexture_setSwizzleMask},
    {sipName_setWrapMode, meth_QOpenGLTexture_setWrapMode, METH_VARARGS, doc_QOpenGLTexture_setWrapMode},
    {sipName_swizzleMask, meth_QOpenGLTexture_swizzleMask, METH_VARARGS, doc_QOpenGLTexture_swizzleMask},
    {sipName_target, meth_QOpenGLTexture_target, METH_VARARGS, doc_QOpenGLTexture_target},
    {sipName_textureId, meth_QOpenGLTexture_textureId, METH_VARARGS, doc_QOpenGLTexture_textureId},
    {sipName_width, meth_QOpenGLTexture_width, METH_VARARGS, doc_QOpenGLTexture_width},
    {sipName_wrapMode, meth_QOpenGLTexture_wrapMode, METH_VARARGS, doc_QOpenGLTexture_wrapMode}
};

static sipEnumMemberDef enummembers_QOpenGLTexture[] = {
    {sipName_Alpha, static_cast<int>( ::QOpenGLTexture::Alpha), 171},
    {sipName_AlphaFormat, static_cast<int>( ::QOpenGLTexture::AlphaFormat), 176},
    {sipName_AlphaValue, static_cast<int>( ::QOpenGLTexture::AlphaValue), 174},
    {sipName_AnisotropicFiltering, static_cast<int>( ::QOpenGLTexture::AnisotropicFiltering), 167},
    {sipName_BGR, static_cast<int>( ::QOpenGLTexture::BGR), 171},
    {sipName_BGRA, static_cast<int>( ::QOpenGLTexture::BGRA), 171},
    {sipName_BGRA_Integer, static_cast<int>( ::QOpenGLTexture::BGRA_Integer), 171},
    {sipName_BGR_Integer, static_cast<int>( ::QOpenGLTexture::BGR_Integer), 171},
    {sipName_BindingTarget1D, static_cast<int>( ::QOpenGLTexture::BindingTarget1D), 161},
    {sipName_BindingTarget1DArray, static_cast<int>( ::QOpenGLTexture::BindingTarget1DArray), 161},
    {sipName_BindingTarget2D, static_cast<int>( ::QOpenGLTexture::BindingTarget2D), 161},
    {sipName_BindingTarget2DArray, static_cast<int>( ::QOpenGLTexture::BindingTarget2DArray), 161},
    {sipName_BindingTarget2DMultisample, static_cast<int>( ::QOpenGLTexture::BindingTarget2DMultisample), 161},
    {sipName_BindingTarget2DMultisampleArray, static_cast<int>( ::QOpenGLTexture::BindingTarget2DMultisampleArray), 161},
    {sipName_BindingTarget3D, static_cast<int>( ::QOpenGLTexture::BindingTarget3D), 161},
    {sipName_BindingTargetBuffer, static_cast<int>( ::QOpenGLTexture::BindingTargetBuffer), 161},
    {sipName_BindingTargetCubeMap, static_cast<int>( ::QOpenGLTexture::BindingTargetCubeMap), 161},
    {sipName_BindingTargetCubeMapArray, static_cast<int>( ::QOpenGLTexture::BindingTargetCubeMapArray), 161},
    {sipName_BindingTargetRectangle, static_cast<int>( ::QOpenGLTexture::BindingTargetRectangle), 161},
    {sipName_BlueValue, static_cast<int>( ::QOpenGLTexture::BlueValue), 174},
    {sipName_ClampToBorder, static_cast<int>( ::QOpenGLTexture::ClampToBorder), 178},
    {sipName_ClampToEdge, static_cast<int>( ::QOpenGLTexture::ClampToEdge), 178},
    {sipName_CommpareNotEqual, static_cast<int>( ::QOpenGLTexture::CommpareNotEqual), 162},
    {sipName_CompareAlways, static_cast<int>( ::QOpenGLTexture::CompareAlways), 162},
    {sipName_CompareEqual, static_cast<int>( ::QOpenGLTexture::CompareEqual), 162},
    {sipName_CompareGreater, static_cast<int>( ::QOpenGLTexture::CompareGreater), 162},
    {sipName_CompareGreaterEqual, static_cast<int>( ::QOpenGLTexture::CompareGreaterEqual), 162},
    {sipName_CompareLess, static_cast<int>( ::QOpenGLTexture::CompareLess), 162},
    {sipName_CompareLessEqual, static_cast<int>( ::QOpenGLTexture::CompareLessEqual), 162},
    {sipName_CompareNever, static_cast<int>( ::QOpenGLTexture::CompareNever), 162},
    {sipName_CompareNone, static_cast<int>( ::QOpenGLTexture::CompareNone), 163},
    {sipName_CompareRefToTexture, static_cast<int>( ::QOpenGLTexture::CompareRefToTexture), 163},
    {sipName_CubeMapNegativeX, static_cast<int>( ::QOpenGLTexture::CubeMapNegativeX), 165},
    {sipName_CubeMapNegativeY, static_cast<int>( ::QOpenGLTexture::CubeMapNegativeY), 165},
    {sipName_CubeMapNegativeZ, static_cast<int>( ::QOpenGLTexture::CubeMapNegativeZ), 165},
    {sipName_CubeMapPositiveX, static_cast<int>( ::QOpenGLTexture::CubeMapPositiveX), 165},
    {sipName_CubeMapPositiveY, static_cast<int>( ::QOpenGLTexture::CubeMapPositiveY), 165},
    {sipName_CubeMapPositiveZ, static_cast<int>( ::QOpenGLTexture::CubeMapPositiveZ), 165},
    {sipName_D16, static_cast<int>( ::QOpenGLTexture::D16), 176},
    {sipName_D24, static_cast<int>( ::QOpenGLTexture::D24), 176},
    {sipName_D24S8, static_cast<int>( ::QOpenGLTexture::D24S8), 176},
    {sipName_D32, static_cast<int>( ::QOpenGLTexture::D32), 176},
    {sipName_D32F, static_cast<int>( ::QOpenGLTexture::D32F), 176},
    {sipName_D32FS8X24, static_cast<int>( ::QOpenGLTexture::D32FS8X24), 176},
    {sipName_Depth, static_cast<int>( ::QOpenGLTexture::Depth), 171},
    {sipName_DepthFormat, static_cast<int>( ::QOpenGLTexture::DepthFormat), 176},
    {sipName_DepthMode, static_cast<int>( ::QOpenGLTexture::DepthMode), 166},
    {sipName_DepthStencil, static_cast<int>( ::QOpenGLTexture::DepthStencil), 171},
    {sipName_DirectionR, static_cast<int>( ::QOpenGLTexture::DirectionR), 164},
    {sipName_DirectionS, static_cast<int>( ::QOpenGLTexture::DirectionS), 164},
    {sipName_DirectionT, static_cast<int>( ::QOpenGLTexture::DirectionT), 164},
    {sipName_DontGenerateMipMaps, static_cast<int>( ::QOpenGLTexture::DontGenerateMipMaps), 170},
    {sipName_DontResetTextureUnit, static_cast<int>( ::QOpenGLTexture::DontResetTextureUnit), 177},
    {sipName_Float16, static_cast<int>( ::QOpenGLTexture::Float16), 172},
    {sipName_Float16OES, static_cast<int>( ::QOpenGLTexture::Float16OES), 172},
    {sipName_Float32, static_cast<int>( ::QOpenGLTexture::Float32), 172},
    {sipName_Float32_D32_UInt32_S8_X24, static_cast<int>( ::QOpenGLTexture::Float32_D32_UInt32_S8_X24), 172},
    {sipName_GenerateMipMaps, static_cast<int>( ::QOpenGLTexture::GenerateMipMaps), 170},
    {sipName_GreenValue, static_cast<int>( ::QOpenGLTexture::GreenValue), 174},
    {sipName_ImmutableMultisampleStorage, static_cast<int>( ::QOpenGLTexture::ImmutableMultisampleStorage), 167},
    {sipName_ImmutableStorage, static_cast<int>( ::QOpenGLTexture::ImmutableStorage), 167},
    {sipName_Int16, static_cast<int>( ::QOpenGLTexture::Int16), 172},
    {sipName_Int32, static_cast<int>( ::QOpenGLTexture::Int32), 172},
    {sipName_Int8, static_cast<int>( ::QOpenGLTexture::Int8), 172},
    {sipName_Linear, static_cast<int>( ::QOpenGLTexture::Linear), 169},
    {sipName_LinearMipMapLinear, static_cast<int>( ::QOpenGLTexture::LinearMipMapLinear), 169},
    {sipName_LinearMipMapNearest, static_cast<int>( ::QOpenGLTexture::LinearMipMapNearest), 169},
    {sipName_Luminance, static_cast<int>( ::QOpenGLTexture::Luminance), 171},
    {sipName_LuminanceAlpha, static_cast<int>( ::QOpenGLTexture::LuminanceAlpha), 171},
    {sipName_LuminanceAlphaFormat, static_cast<int>( ::QOpenGLTexture::LuminanceAlphaFormat), 176},
    {sipName_LuminanceFormat, static_cast<int>( ::QOpenGLTexture::LuminanceFormat), 176},
    {sipName_MirroredRepeat, static_cast<int>( ::QOpenGLTexture::MirroredRepeat), 178},
    {sipName_NPOTTextureRepeat, static_cast<int>( ::QOpenGLTexture::NPOTTextureRepeat), 167},
    {sipName_NPOTTextures, static_cast<int>( ::QOpenGLTexture::NPOTTextures), 167},
    {sipName_Nearest, static_cast<int>( ::QOpenGLTexture::Nearest), 169},
    {sipName_NearestMipMapLinear, static_cast<int>( ::QOpenGLTexture::NearestMipMapLinear), 169},
    {sipName_NearestMipMapNearest, static_cast<int>( ::QOpenGLTexture::NearestMipMapNearest), 169},
    {sipName_NoFormat, static_cast<int>( ::QOpenGLTexture::NoFormat), 176},
    {sipName_NoPixelType, static_cast<int>( ::QOpenGLTexture::NoPixelType), 172},
    {sipName_NoSourceFormat, static_cast<int>( ::QOpenGLTexture::NoSourceFormat), 171},
    {sipName_OneValue, static_cast<int>( ::QOpenGLTexture::OneValue), 174},
    {sipName_R11_EAC_SNorm, static_cast<int>( ::QOpenGLTexture::R11_EAC_SNorm), 176},
    {sipName_R11_EAC_UNorm, static_cast<int>( ::QOpenGLTexture::R11_EAC_UNorm), 176},
    {sipName_R16F, static_cast<int>( ::QOpenGLTexture::R16F), 176},
    {sipName_R16I, static_cast<int>( ::QOpenGLTexture::R16I), 176},
    {sipName_R16U, static_cast<int>( ::QOpenGLTexture::R16U), 176},
    {sipName_R16_SNorm, static_cast<int>( ::QOpenGLTexture::R16_SNorm), 176},
    {sipName_R16_UNorm, static_cast<int>( ::QOpenGLTexture::R16_UNorm), 176},
    {sipName_R32F, static_cast<int>( ::QOpenGLTexture::R32F), 176},
    {sipName_R32I, static_cast<int>( ::QOpenGLTexture::R32I), 176},
    {sipName_R32U, static_cast<int>( ::QOpenGLTexture::R32U), 176},
    {sipName_R5G6B5, static_cast<int>( ::QOpenGLTexture::R5G6B5), 176},
    {sipName_R8I, static_cast<int>( ::QOpenGLTexture::R8I), 176},
    {sipName_R8U, static_cast<int>( ::QOpenGLTexture::R8U), 176},
    {sipName_R8_SNorm, static_cast<int>( ::QOpenGLTexture::R8_SNorm), 176},
    {sipName_R8_UNorm, static_cast<int>( ::QOpenGLTexture::R8_UNorm), 176},
    {sipName_RG, static_cast<int>( ::QOpenGLTexture::RG), 171},
    {sipName_RG11B10F, static_cast<int>( ::QOpenGLTexture::RG11B10F), 176},
    {sipName_RG11_EAC_SNorm, static_cast<int>( ::QOpenGLTexture::RG11_EAC_SNorm), 176},
    {sipName_RG11_EAC_UNorm, static_cast<int>( ::QOpenGLTexture::RG11_EAC_UNorm), 176},
    {sipName_RG16F, static_cast<int>( ::QOpenGLTexture::RG16F), 176},
    {sipName_RG16I, static_cast<int>( ::QOpenGLTexture::RG16I), 176},
    {sipName_RG16U, static_cast<int>( ::QOpenGLTexture::RG16U), 176},
    {sipName_RG16_SNorm, static_cast<int>( ::QOpenGLTexture::RG16_SNorm), 176},
    {sipName_RG16_UNorm, static_cast<int>( ::QOpenGLTexture::RG16_UNorm), 176},
    {sipName_RG32F, static_cast<int>( ::QOpenGLTexture::RG32F), 176},
    {sipName_RG32I, static_cast<int>( ::QOpenGLTexture::RG32I), 176},
    {sipName_RG32U, static_cast<int>( ::QOpenGLTexture::RG32U), 176},
    {sipName_RG3B2, static_cast<int>( ::QOpenGLTexture::RG3B2), 176},
    {sipName_RG8I, static_cast<int>( ::QOpenGLTexture::RG8I), 176},
    {sipName_RG8U, static_cast<int>( ::QOpenGLTexture::RG8U), 176},
    {sipName_RG8_SNorm, static_cast<int>( ::QOpenGLTexture::RG8_SNorm), 176},
    {sipName_RG8_UNorm, static_cast<int>( ::QOpenGLTexture::RG8_UNorm), 176},
    {sipName_RGB, static_cast<int>( ::QOpenGLTexture::RGB), 171},
    {sipName_RGB10A2, static_cast<int>( ::QOpenGLTexture::RGB10A2), 176},
    {sipName_RGB16F, static_cast<int>( ::QOpenGLTexture::RGB16F), 176},
    {sipName_RGB16I, static_cast<int>( ::QOpenGLTexture::RGB16I), 176},
    {sipName_RGB16U, static_cast<int>( ::QOpenGLTexture::RGB16U), 176},
    {sipName_RGB16_SNorm, static_cast<int>( ::QOpenGLTexture::RGB16_SNorm), 176},
    {sipName_RGB16_UNorm, static_cast<int>( ::QOpenGLTexture::RGB16_UNorm), 176},
    {sipName_RGB32F, static_cast<int>( ::QOpenGLTexture::RGB32F), 176},
    {sipName_RGB32I, static_cast<int>( ::QOpenGLTexture::RGB32I), 176},
    {sipName_RGB32U, static_cast<int>( ::QOpenGLTexture::RGB32U), 176},
    {sipName_RGB5A1, static_cast<int>( ::QOpenGLTexture::RGB5A1), 176},
    {sipName_RGB8I, static_cast<int>( ::QOpenGLTexture::RGB8I), 176},
    {sipName_RGB8U, static_cast<int>( ::QOpenGLTexture::RGB8U), 176},
    {sipName_RGB8_ETC1, static_cast<int>( ::QOpenGLTexture::RGB8_ETC1), 176},
    {sipName_RGB8_ETC2, static_cast<int>( ::QOpenGLTexture::RGB8_ETC2), 176},
    {sipName_RGB8_PunchThrough_Alpha1_ETC2, static_cast<int>( ::QOpenGLTexture::RGB8_PunchThrough_Alpha1_ETC2), 176},
    {sipName_RGB8_SNorm, static_cast<int>( ::QOpenGLTexture::RGB8_SNorm), 176},
    {sipName_RGB8_UNorm, static_cast<int>( ::QOpenGLTexture::RGB8_UNorm), 176},
    {sipName_RGB9E5, static_cast<int>( ::QOpenGLTexture::RGB9E5), 176},
    {sipName_RGBA, static_cast<int>( ::QOpenGLTexture::RGBA), 171},
    {sipName_RGBA16F, static_cast<int>( ::QOpenGLTexture::RGBA16F), 176},
    {sipName_RGBA16I, static_cast<int>( ::QOpenGLTexture::RGBA16I), 176},
    {sipName_RGBA16U, static_cast<int>( ::QOpenGLTexture::RGBA16U), 176},
    {sipName_RGBA16_SNorm, static_cast<int>( ::QOpenGLTexture::RGBA16_SNorm), 176},
    {sipName_RGBA16_UNorm, static_cast<int>( ::QOpenGLTexture::RGBA16_UNorm), 176},
    {sipName_RGBA32F, static_cast<int>( ::QOpenGLTexture::RGBA32F), 176},
    {sipName_RGBA32I, static_cast<int>( ::QOpenGLTexture::RGBA32I), 176},
    {sipName_RGBA32U, static_cast<int>( ::QOpenGLTexture::RGBA32U), 176},
    {sipName_RGBA4, static_cast<int>( ::QOpenGLTexture::RGBA4), 176},
    {sipName_RGBA8I, static_cast<int>( ::QOpenGLTexture::RGBA8I), 176},
    {sipName_RGBA8U, static_cast<int>( ::QOpenGLTexture::RGBA8U), 176},
    {sipName_RGBA8_ETC2_EAC, static_cast<int>( ::QOpenGLTexture::RGBA8_ETC2_EAC), 176},
    {sipName_RGBA8_SNorm, static_cast<int>( ::QOpenGLTexture::RGBA8_SNorm), 176},
    {sipName_RGBA8_UNorm, static_cast<int>( ::QOpenGLTexture::RGBA8_UNorm), 176},
    {sipName_RGBAFormat, static_cast<int>( ::QOpenGLTexture::RGBAFormat), 176},
    {sipName_RGBA_ASTC_10x10, static_cast<int>( ::QOpenGLTexture::RGBA_ASTC_10x10), 176},
    {sipName_RGBA_ASTC_10x5, static_cast<int>( ::QOpenGLTexture::RGBA_ASTC_10x5), 176},
    {sipName_RGBA_ASTC_10x6, static_cast<int>( ::QOpenGLTexture::RGBA_ASTC_10x6), 176},
    {sipName_RGBA_ASTC_10x8, static_cast<int>( ::QOpenGLTexture::RGBA_ASTC_10x8), 176},
    {sipName_RGBA_ASTC_12x10, static_cast<int>( ::QOpenGLTexture::RGBA_ASTC_12x10), 176},
    {sipName_RGBA_ASTC_12x12, static_cast<int>( ::QOpenGLTexture::RGBA_ASTC_12x12), 176},
    {sipName_RGBA_ASTC_4x4, static_cast<int>( ::QOpenGLTexture::RGBA_ASTC_4x4), 176},
    {sipName_RGBA_ASTC_5x4, static_cast<int>( ::QOpenGLTexture::RGBA_ASTC_5x4), 176},
    {sipName_RGBA_ASTC_5x5, static_cast<int>( ::QOpenGLTexture::RGBA_ASTC_5x5), 176},
    {sipName_RGBA_ASTC_6x5, static_cast<int>( ::QOpenGLTexture::RGBA_ASTC_6x5), 176},
    {sipName_RGBA_ASTC_6x6, static_cast<int>( ::QOpenGLTexture::RGBA_ASTC_6x6), 176},
    {sipName_RGBA_ASTC_8x5, static_cast<int>( ::QOpenGLTexture::RGBA_ASTC_8x5), 176},
    {sipName_RGBA_ASTC_8x6, static_cast<int>( ::QOpenGLTexture::RGBA_ASTC_8x6), 176},
    {sipName_RGBA_ASTC_8x8, static_cast<int>( ::QOpenGLTexture::RGBA_ASTC_8x8), 176},
    {sipName_RGBA_DXT1, static_cast<int>( ::QOpenGLTexture::RGBA_DXT1), 176},
    {sipName_RGBA_DXT3, static_cast<int>( ::QOpenGLTexture::RGBA_DXT3), 176},
    {sipName_RGBA_DXT5, static_cast<int>( ::QOpenGLTexture::RGBA_DXT5), 176},
    {sipName_RGBA_Integer, static_cast<int>( ::QOpenGLTexture::RGBA_Integer), 171},
    {sipName_RGBFormat, static_cast<int>( ::QOpenGLTexture::RGBFormat), 176},
    {sipName_RGB_BP_SIGNED_FLOAT, static_cast<int>( ::QOpenGLTexture::RGB_BP_SIGNED_FLOAT), 176},
    {sipName_RGB_BP_UNSIGNED_FLOAT, static_cast<int>( ::QOpenGLTexture::RGB_BP_UNSIGNED_FLOAT), 176},
    {sipName_RGB_BP_UNorm, static_cast<int>( ::QOpenGLTexture::RGB_BP_UNorm), 176},
    {sipName_RGB_DXT1, static_cast<int>( ::QOpenGLTexture::RGB_DXT1), 176},
    {sipName_RGB_Integer, static_cast<int>( ::QOpenGLTexture::RGB_Integer), 171},
    {sipName_RG_ATI2N_SNorm, static_cast<int>( ::QOpenGLTexture::RG_ATI2N_SNorm), 176},
    {sipName_RG_ATI2N_UNorm, static_cast<int>( ::QOpenGLTexture::RG_ATI2N_UNorm), 176},
    {sipName_RG_Integer, static_cast<int>( ::QOpenGLTexture::RG_Integer), 171},
    {sipName_R_ATI1N_SNorm, static_cast<int>( ::QOpenGLTexture::R_ATI1N_SNorm), 176},
    {sipName_R_ATI1N_UNorm, static_cast<int>( ::QOpenGLTexture::R_ATI1N_UNorm), 176},
    {sipName_Red, static_cast<int>( ::QOpenGLTexture::Red), 171},
    {sipName_RedValue, static_cast<int>( ::QOpenGLTexture::RedValue), 174},
    {sipName_Red_Integer, static_cast<int>( ::QOpenGLTexture::Red_Integer), 171},
    {sipName_Repeat, static_cast<int>( ::QOpenGLTexture::Repeat), 178},
    {sipName_ResetTextureUnit, static_cast<int>( ::QOpenGLTexture::ResetTextureUnit), 177},
    {sipName_S8, static_cast<int>( ::QOpenGLTexture::S8), 176},
    {sipName_SRGB8, static_cast<int>( ::QOpenGLTexture::SRGB8), 176},
    {sipName_SRGB8_Alpha8, static_cast<int>( ::QOpenGLTexture::SRGB8_Alpha8), 176},
    {sipName_SRGB8_Alpha8_ASTC_10x10, static_cast<int>( ::QOpenGLTexture::SRGB8_Alpha8_ASTC_10x10), 176},
    {sipName_SRGB8_Alpha8_ASTC_10x5, static_cast<int>( ::QOpenGLTexture::SRGB8_Alpha8_ASTC_10x5), 176},
    {sipName_SRGB8_Alpha8_ASTC_10x6, static_cast<int>( ::QOpenGLTexture::SRGB8_Alpha8_ASTC_10x6), 176},
    {sipName_SRGB8_Alpha8_ASTC_10x8, static_cast<int>( ::QOpenGLTexture::SRGB8_Alpha8_ASTC_10x8), 176},
    {sipName_SRGB8_Alpha8_ASTC_12x10, static_cast<int>( ::QOpenGLTexture::SRGB8_Alpha8_ASTC_12x10), 176},
    {sipName_SRGB8_Alpha8_ASTC_12x12, static_cast<int>( ::QOpenGLTexture::SRGB8_Alpha8_ASTC_12x12), 176},
    {sipName_SRGB8_Alpha8_ASTC_4x4, static_cast<int>( ::QOpenGLTexture::SRGB8_Alpha8_ASTC_4x4), 176},
    {sipName_SRGB8_Alpha8_ASTC_5x4, static_cast<int>( ::QOpenGLTexture::SRGB8_Alpha8_ASTC_5x4), 176},
    {sipName_SRGB8_Alpha8_ASTC_5x5, static_cast<int>( ::QOpenGLTexture::SRGB8_Alpha8_ASTC_5x5), 176},
    {sipName_SRGB8_Alpha8_ASTC_6x5, static_cast<int>( ::QOpenGLTexture::SRGB8_Alpha8_ASTC_6x5), 176},
    {sipName_SRGB8_Alpha8_ASTC_6x6, static_cast<int>( ::QOpenGLTexture::SRGB8_Alpha8_ASTC_6x6), 176},
    {sipName_SRGB8_Alpha8_ASTC_8x5, static_cast<int>( ::QOpenGLTexture::SRGB8_Alpha8_ASTC_8x5), 176},
    {sipName_SRGB8_Alpha8_ASTC_8x6, static_cast<int>( ::QOpenGLTexture::SRGB8_Alpha8_ASTC_8x6), 176},
    {sipName_SRGB8_Alpha8_ASTC_8x8, static_cast<int>( ::QOpenGLTexture::SRGB8_Alpha8_ASTC_8x8), 176},
    {sipName_SRGB8_Alpha8_ETC2_EAC, static_cast<int>( ::QOpenGLTexture::SRGB8_Alpha8_ETC2_EAC), 176},
    {sipName_SRGB8_ETC2, static_cast<int>( ::QOpenGLTexture::SRGB8_ETC2), 176},
    {sipName_SRGB8_PunchThrough_Alpha1_ETC2, static_cast<int>( ::QOpenGLTexture::SRGB8_PunchThrough_Alpha1_ETC2), 176},
    {sipName_SRGB_Alpha_DXT1, static_cast<int>( ::QOpenGLTexture::SRGB_Alpha_DXT1), 176},
    {sipName_SRGB_Alpha_DXT3, static_cast<int>( ::QOpenGLTexture::SRGB_Alpha_DXT3), 176},
    {sipName_SRGB_Alpha_DXT5, static_cast<int>( ::QOpenGLTexture::SRGB_Alpha_DXT5), 176},
    {sipName_SRGB_BP_UNorm, static_cast<int>( ::QOpenGLTexture::SRGB_BP_UNorm), 176},
    {sipName_SRGB_DXT1, static_cast<int>( ::QOpenGLTexture::SRGB_DXT1), 176},
    {sipName_Stencil, static_cast<int>( ::QOpenGLTexture::Stencil), 171},
    {sipName_StencilMode, static_cast<int>( ::QOpenGLTexture::StencilMode), 166},
    {sipName_StencilTexturing, static_cast<int>( ::QOpenGLTexture::StencilTexturing), 167},
    {sipName_Swizzle, static_cast<int>( ::QOpenGLTexture::Swizzle), 167},
    {sipName_SwizzleAlpha, static_cast<int>( ::QOpenGLTexture::SwizzleAlpha), 173},
    {sipName_SwizzleBlue, static_cast<int>( ::QOpenGLTexture::SwizzleBlue), 173},
    {sipName_SwizzleGreen, static_cast<int>( ::QOpenGLTexture::SwizzleGreen), 173},
    {sipName_SwizzleRed, static_cast<int>( ::QOpenGLTexture::SwizzleRed), 173},
    {sipName_Target1D, static_cast<int>( ::QOpenGLTexture::Target1D), 175},
    {sipName_Target1DArray, static_cast<int>( ::QOpenGLTexture::Target1DArray), 175},
    {sipName_Target2D, static_cast<int>( ::QOpenGLTexture::Target2D), 175},
    {sipName_Target2DArray, static_cast<int>( ::QOpenGLTexture::Target2DArray), 175},
    {sipName_Target2DMultisample, static_cast<int>( ::QOpenGLTexture::Target2DMultisample), 175},
    {sipName_Target2DMultisampleArray, static_cast<int>( ::QOpenGLTexture::Target2DMultisampleArray), 175},
    {sipName_Target3D, static_cast<int>( ::QOpenGLTexture::Target3D), 175},
    {sipName_TargetBuffer, static_cast<int>( ::QOpenGLTexture::TargetBuffer), 175},
    {sipName_TargetCubeMap, static_cast<int>( ::QOpenGLTexture::TargetCubeMap), 175},
    {sipName_TargetCubeMapArray, static_cast<int>( ::QOpenGLTexture::TargetCubeMapArray), 175},
    {sipName_TargetRectangle, static_cast<int>( ::QOpenGLTexture::TargetRectangle), 175},
    {sipName_Texture1D, static_cast<int>( ::QOpenGLTexture::Texture1D), 167},
    {sipName_Texture3D, static_cast<int>( ::QOpenGLTexture::Texture3D), 167},
    {sipName_TextureArrays, static_cast<int>( ::QOpenGLTexture::TextureArrays), 167},
    {sipName_TextureBuffer, static_cast<int>( ::QOpenGLTexture::TextureBuffer), 167},
    {sipName_TextureComparisonOperators, static_cast<int>( ::QOpenGLTexture::TextureComparisonOperators), 167},
    {sipName_TextureCubeMapArrays, static_cast<int>( ::QOpenGLTexture::TextureCubeMapArrays), 167},
    {sipName_TextureMipMapLevel, static_cast<int>( ::QOpenGLTexture::TextureMipMapLevel), 167},
    {sipName_TextureMultisample, static_cast<int>( ::QOpenGLTexture::TextureMultisample), 167},
    {sipName_TextureRectangle, static_cast<int>( ::QOpenGLTexture::TextureRectangle), 167},
    {sipName_UInt16, static_cast<int>( ::QOpenGLTexture::UInt16), 172},
    {sipName_UInt16_R5G6B5, static_cast<int>( ::QOpenGLTexture::UInt16_R5G6B5), 172},
    {sipName_UInt16_R5G6B5_Rev, static_cast<int>( ::QOpenGLTexture::UInt16_R5G6B5_Rev), 172},
    {sipName_UInt16_RGB5A1, static_cast<int>( ::QOpenGLTexture::UInt16_RGB5A1), 172},
    {sipName_UInt16_RGB5A1_Rev, static_cast<int>( ::QOpenGLTexture::UInt16_RGB5A1_Rev), 172},
    {sipName_UInt16_RGBA4, static_cast<int>( ::QOpenGLTexture::UInt16_RGBA4), 172},
    {sipName_UInt16_RGBA4_Rev, static_cast<int>( ::QOpenGLTexture::UInt16_RGBA4_Rev), 172},
    {sipName_UInt32, static_cast<int>( ::QOpenGLTexture::UInt32), 172},
    {sipName_UInt32_D24S8, static_cast<int>( ::QOpenGLTexture::UInt32_D24S8), 172},
    {sipName_UInt32_RG11B10F, static_cast<int>( ::QOpenGLTexture::UInt32_RG11B10F), 172},
    {sipName_UInt32_RGB10A2, static_cast<int>( ::QOpenGLTexture::UInt32_RGB10A2), 172},
    {sipName_UInt32_RGB10A2_Rev, static_cast<int>( ::QOpenGLTexture::UInt32_RGB10A2_Rev), 172},
    {sipName_UInt32_RGB9_E5, static_cast<int>( ::QOpenGLTexture::UInt32_RGB9_E5), 172},
    {sipName_UInt32_RGBA8, static_cast<int>( ::QOpenGLTexture::UInt32_RGBA8), 172},
    {sipName_UInt32_RGBA8_Rev, static_cast<int>( ::QOpenGLTexture::UInt32_RGBA8_Rev), 172},
    {sipName_UInt8, static_cast<int>( ::QOpenGLTexture::UInt8), 172},
    {sipName_UInt8_RG3B2, static_cast<int>( ::QOpenGLTexture::UInt8_RG3B2), 172},
    {sipName_UInt8_RG3B2_Rev, static_cast<int>( ::QOpenGLTexture::UInt8_RG3B2_Rev), 172},
    {sipName_ZeroValue, static_cast<int>( ::QOpenGLTexture::ZeroValue), 174},
};

PyDoc_STRVAR(doc_QOpenGLTexture, "\1QOpenGLTexture(QOpenGLTexture.Target)\n"
"QOpenGLTexture(QImage, genMipMaps: QOpenGLTexture.MipMapGeneration = QOpenGLTexture.GenerateMipMaps)");


static pyqt5ClassPluginDef plugin_QOpenGLTexture = {
    SIP_NULLPTR,
    0,
    SIP_NULLPTR,
    SIP_NULLPTR
};


sipClassTypeDef sipTypeDef_QtGui_QOpenGLTexture = {
    {
        -1,
        SIP_NULLPTR,
        SIP_NULLPTR,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QOpenGLTexture,
        SIP_NULLPTR,
        &plugin_QOpenGLTexture
    },
    {
        sipNameNr_QOpenGLTexture,
        {0, 0, 1},
        69, methods_QOpenGLTexture,
        254, enummembers_QOpenGLTexture,
        0, SIP_NULLPTR,
        {SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    },
    doc_QOpenGLTexture,
    -1,
    sipNameNr_sip_simplewrapper,
    SIP_NULLPTR,
    SIP_NULLPTR,
    init_type_QOpenGLTexture,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    dealloc_QOpenGLTexture,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    release_QOpenGLTexture,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    sizeof ( ::QOpenGLTexture),
};
