lib/cutego
1
0
Fork 0
mirror of https://github.com/bluszcz/cutego.git synced 2024-09-28 21:25:16 +03:00
Code Issues Projects Releases Packages Wiki Activity
cutego/gui/gui.cpp

99812 lines
3.9 MiB
Raw Blame History

// +build !minimal
#define protected public
#define private public
#include "gui.h"
#include "_cgo_export.h"
#include <QAbstractItemModel>
#include <QAbstractTextDocumentLayout>
#include <QAccessible>
#include <QAccessibleActionInterface>
#include <QAccessibleEditableTextInterface>
#include <QAccessibleEvent>
#include <QAccessibleInterface>
#include <QAccessibleObject>
#include <QAccessiblePlugin>
#include <QAccessibleStateChangeEvent>
#include <QAccessibleTableCellInterface>
#include <QAccessibleTableInterface>
#include <QAccessibleTableModelChangeEvent>
#include <QAccessibleTextCursorEvent>
#include <QAccessibleTextInsertEvent>
#include <QAccessibleTextInterface>
#include <QAccessibleTextRemoveEvent>
#include <QAccessibleTextSelectionEvent>
#include <QAccessibleTextUpdateEvent>
#include <QAccessibleValueChangeEvent>
#include <QAccessibleValueInterface>
#include <QAccessibleWidget>
#include <QAction>
#include <QActionEvent>
#include <QBackingStore>
#include <QBitmap>
#include <QBrush>
#include <QByteArray>
#include <QCamera>
#include <QCameraImageCapture>
#include <QChar>
#include <QChildEvent>
#include <QClipboard>
#include <QCloseEvent>
#include <QColor>
#include <QConicalGradient>
#include <QContextMenuEvent>
#include <QCursor>
#include <QDBusPendingCall>
#include <QDBusPendingCallWatcher>
#include <QDataStream>
#include <QDesktopServices>
#include <QDoubleValidator>
#include <QDrag>
#include <QDragEnterEvent>
#include <QDragLeaveEvent>
#include <QDragMoveEvent>
#include <QDropEvent>
#include <QEnterEvent>
#include <QEvent>
#include <QExposeEvent>
#include <QExtensionFactory>
#include <QExtensionManager>
#include <QFile>
#include <QFileOpenEvent>
#include <QFocusEvent>
#include <QFont>
#include <QFontDatabase>
#include <QFontInfo>
#include <QFontMetrics>
#include <QFontMetricsF>
#include <QGenericPlugin>
#include <QGenericPluginFactory>
#include <QGlyphRun>
#include <QGradient>
#include <QGraphicsObject>
#include <QGraphicsWidget>
#include <QGuiApplication>
#include <QHash>
#include <QHelpEvent>
#include <QHideEvent>
#include <QHoverEvent>
#include <QIODevice>
#include <QIcon>
#include <QIconDragEvent>
#include <QIconEngine>
#include <QIconEnginePlugin>
#include <QImage>
#include <QImageIOHandler>
#include <QImageIOPlugin>
#include <QImageReader>
#include <QImageWriter>
#include <QInputEvent>
#include <QInputMethod>
#include <QInputMethodEvent>
#include <QInputMethodQueryEvent>
#include <QIntValidator>
#include <QKeyEvent>
#include <QKeySequence>
#include <QLatin1String>
#include <QLayout>
#include <QLine>
#include <QLineF>
#include <QLinearGradient>
#include <QLocale>
#include <QMap>
#include <QMargins>
#include <QMarginsF>
#include <QMatrix>
#include <QMatrix4x4>
#include <QMediaPlaylist>
#include <QMediaRecorder>
#include <QMetaMethod>
#include <QMetaObject>
#include <QMimeData>
#include <QModelIndex>
#include <QMouseEvent>
#include <QMoveEvent>
#include <QMovie>
#include <QNativeGestureEvent>
#include <QObject>
#include <QOffscreenSurface>
#include <QOpenGLBuffer>
#include <QOpenGLContext>
#include <QOpenGLContextGroup>
#include <QOpenGLDebugLogger>
#include <QOpenGLDebugMessage>
#include <QOpenGLExtraFunctions>
#include <QOpenGLFramebufferObject>
#include <QOpenGLFramebufferObjectFormat>
#include <QOpenGLFunctions>
#include <QOpenGLFunctions_1_0>
#include <QOpenGLFunctions_1_1>
#include <QOpenGLFunctions_1_2>
#include <QOpenGLFunctions_1_3>
#include <QOpenGLFunctions_1_4>
#include <QOpenGLFunctions_1_5>
#include <QOpenGLFunctions_2_0>
#include <QOpenGLFunctions_2_1>
#include <QOpenGLFunctions_3_0>
#include <QOpenGLFunctions_3_1>
#include <QOpenGLFunctions_3_2_Compatibility>
#include <QOpenGLFunctions_3_2_Core>
#include <QOpenGLFunctions_3_3_Compatibility>
#include <QOpenGLFunctions_3_3_Core>
#include <QOpenGLFunctions_4_0_Compatibility>
#include <QOpenGLFunctions_4_0_Core>
#include <QOpenGLFunctions_4_1_Compatibility>
#include <QOpenGLFunctions_4_1_Core>
#include <QOpenGLFunctions_4_2_Compatibility>
#include <QOpenGLFunctions_4_2_Core>
#include <QOpenGLFunctions_4_3_Compatibility>
#include <QOpenGLFunctions_4_3_Core>
#include <QOpenGLFunctions_4_4_Compatibility>
#include <QOpenGLFunctions_4_4_Core>
#include <QOpenGLFunctions_4_5_Compatibility>
#include <QOpenGLFunctions_4_5_Core>
#include <QOpenGLPaintDevice>
#include <QOpenGLPixelTransferOptions>
#include <QOpenGLShader>
#include <QOpenGLShaderProgram>
#include <QOpenGLTexture>
#include <QOpenGLTextureBlitter>
#include <QOpenGLTimeMonitor>
#include <QOpenGLTimerQuery>
#include <QOpenGLVersionProfile>
#include <QOpenGLVertexArrayObject>
#include <QOpenGLWindow>
#include <QPageLayout>
#include <QPageSize>
#include <QPagedPaintDevice>
#include <QPaintDevice>
#include <QPaintDeviceWindow>
#include <QPaintEngine>
#include <QPaintEngineState>
#include <QPaintEvent>
#include <QPainter>
#include <QPainterPath>
#include <QPainterPathStroker>
#include <QPalette>
#include <QPdfWriter>
#include <QPen>
#include <QPersistentModelIndex>
#include <QPicture>
#include <QPictureFormatPlugin>
#include <QPictureIO>
#include <QPixelFormat>
#include <QPixmap>
#include <QPixmapCache>
#include <QPlatformSurfaceEvent>
#include <QPoint>
#include <QPointF>
#include <QPointingDeviceUniqueId>
#include <QPolygon>
#include <QPolygonF>
#include <QQuaternion>
#include <QQuickItem>
#include <QRadialGradient>
#include <QRadioData>
#include <QRasterWindow>
#include <QRawFont>
#include <QRect>
#include <QRectF>
#include <QRegExp>
#include <QRegExpValidator>
#include <QRegion>
#include <QRegularExpression>
#include <QRegularExpressionValidator>
#include <QResizeEvent>
#include <QRgba64>
#include <QScreen>
#include <QScrollEvent>
#include <QScrollPrepareEvent>
#include <QSessionManager>
#include <QShortcut>
#include <QShortcutEvent>
#include <QShowEvent>
#include <QSize>
#include <QSizeF>
#include <QStandardItem>
#include <QStandardItemModel>
#include <QStaticText>
#include <QStatusTipEvent>
#include <QString>
#include <QStyle>
#include <QStyleHints>
#include <QSurface>
#include <QSurfaceFormat>
#include <QSyntaxHighlighter>
#include <QTabletEvent>
#include <QTextBlock>
#include <QTextBlockFormat>
#include <QTextBlockGroup>
#include <QTextBlockUserData>
#include <QTextCharFormat>
#include <QTextCodec>
#include <QTextCursor>
#include <QTextDocument>
#include <QTextDocumentFragment>
#include <QTextDocumentWriter>
#include <QTextFormat>
#include <QTextFragment>
#include <QTextFrame>
#include <QTextFrameFormat>
#include <QTextImageFormat>
#include <QTextInlineObject>
#include <QTextItem>
#include <QTextLayout>
#include <QTextLength>
#include <QTextLine>
#include <QTextList>
#include <QTextListFormat>
#include <QTextObject>
#include <QTextObjectInterface>
#include <QTextOption>
#include <QTextTable>
#include <QTextTableCell>
#include <QTextTableCellFormat>
#include <QTextTableFormat>
#include <QTime>
#include <QTimer>
#include <QTimerEvent>
#include <QTouchDevice>
#include <QTouchEvent>
#include <QTransform>
#include <QUrl>
#include <QValidator>
#include <QVariant>
#include <QVector>
#include <QVector2D>
#include <QVector3D>
#include <QVector4D>
#include <QWhatsThis>
#include <QWhatsThisClickedEvent>
#include <QWheelEvent>
#include <QWidget>
#include <QWindow>
#include <QWindowStateChangeEvent>
void* PaintContext_NewPaintContext()
{
return new QAbstractTextDocumentLayout::PaintContext();
}
void* PaintContext_Clip(void* ptr)
{
return ({ QRectF tmpValue = static_cast<QAbstractTextDocumentLayout::PaintContext*>(ptr)->clip; new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void PaintContext_SetClip(void* ptr, void* vqr)
{
static_cast<QAbstractTextDocumentLayout::PaintContext*>(ptr)->clip = *static_cast<QRectF*>(vqr);
}
int PaintContext_CursorPosition(void* ptr)
{
return static_cast<QAbstractTextDocumentLayout::PaintContext*>(ptr)->cursorPosition;
}
void PaintContext_SetCursorPosition(void* ptr, int vin)
{
static_cast<QAbstractTextDocumentLayout::PaintContext*>(ptr)->cursorPosition = vin;
}
void* PaintContext_Palette(void* ptr)
{
return new QPalette(static_cast<QAbstractTextDocumentLayout::PaintContext*>(ptr)->palette);
}
void PaintContext_SetPalette(void* ptr, void* vqp)
{
static_cast<QAbstractTextDocumentLayout::PaintContext*>(ptr)->palette = *static_cast<QPalette*>(vqp);
}
class MyQAbstractTextDocumentLayout: public QAbstractTextDocumentLayout
{
public:
void documentChanged(int position, int charsRemoved, int charsAdded) { callbackQAbstractTextDocumentLayout_DocumentChanged(this, position, charsRemoved, charsAdded); };
void Signal_DocumentSizeChanged(const QSizeF & newSize) { callbackQAbstractTextDocumentLayout_DocumentSizeChanged(this, const_cast<QSizeF*>(&newSize)); };
void Signal_PageCountChanged(int newPages) { callbackQAbstractTextDocumentLayout_PageCountChanged(this, newPages); };
void Signal_Update(const QRectF & rect) { callbackQAbstractTextDocumentLayout_Update(this, const_cast<QRectF*>(&rect)); };
void Signal_UpdateBlock(const QTextBlock & block) { callbackQAbstractTextDocumentLayout_UpdateBlock(this, const_cast<QTextBlock*>(&block)); };
QRectF blockBoundingRect(const QTextBlock & block) const { return *static_cast<QRectF*>(callbackQAbstractTextDocumentLayout_BlockBoundingRect(const_cast<void*>(static_cast<const void*>(this)), const_cast<QTextBlock*>(&block))); };
QRectF frameBoundingRect(QTextFrame * frame) const { return *static_cast<QRectF*>(callbackQAbstractTextDocumentLayout_FrameBoundingRect(const_cast<void*>(static_cast<const void*>(this)), frame)); };
QSizeF documentSize() const { return *static_cast<QSizeF*>(callbackQAbstractTextDocumentLayout_DocumentSize(const_cast<void*>(static_cast<const void*>(this)))); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstractTextDocumentLayout_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
int hitTest(const QPointF & point, Qt::HitTestAccuracy accuracy) const { return callbackQAbstractTextDocumentLayout_HitTest(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPointF*>(&point), accuracy); };
int pageCount() const { return callbackQAbstractTextDocumentLayout_PageCount(const_cast<void*>(static_cast<const void*>(this))); };
bool event(QEvent * e) { return callbackQAbstractTextDocumentLayout_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQAbstractTextDocumentLayout_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQAbstractTextDocumentLayout_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQAbstractTextDocumentLayout_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQAbstractTextDocumentLayout_CustomEvent(this, event); };
void deleteLater() { callbackQAbstractTextDocumentLayout_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQAbstractTextDocumentLayout_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQAbstractTextDocumentLayout_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQAbstractTextDocumentLayout_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQAbstractTextDocumentLayout_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQAbstractTextDocumentLayout*)
int QAbstractTextDocumentLayout_QAbstractTextDocumentLayout_QRegisterMetaType(){qRegisterMetaType<QAbstractTextDocumentLayout*>(); return qRegisterMetaType<MyQAbstractTextDocumentLayout*>();}
struct QtGui_PackedString QAbstractTextDocumentLayout_QAbstractTextDocumentLayout_Tr(char* s, char* c, int n)
{
return ({ QByteArray tf1d2ba = QAbstractTextDocumentLayout::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(tf1d2ba.prepend("WHITESPACE").constData()+10), tf1d2ba.size()-10 }; });
}
struct QtGui_PackedString QAbstractTextDocumentLayout_QAbstractTextDocumentLayout_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray tcf3bd1 = QAbstractTextDocumentLayout::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(tcf3bd1.prepend("WHITESPACE").constData()+10), tcf3bd1.size()-10 }; });
}
void* QAbstractTextDocumentLayout_Format(void* ptr, int position)
{
return new QTextCharFormat(static_cast<QAbstractTextDocumentLayout*>(ptr)->format(position));
}
void QAbstractTextDocumentLayout_DocumentChanged(void* ptr, int position, int charsRemoved, int charsAdded)
{
static_cast<QAbstractTextDocumentLayout*>(ptr)->documentChanged(position, charsRemoved, charsAdded);
}
void QAbstractTextDocumentLayout_ConnectDocumentSizeChanged(void* ptr)
{
QObject::connect(static_cast<QAbstractTextDocumentLayout*>(ptr), static_cast<void (QAbstractTextDocumentLayout::*)(const QSizeF &)>(&QAbstractTextDocumentLayout::documentSizeChanged), static_cast<MyQAbstractTextDocumentLayout*>(ptr), static_cast<void (MyQAbstractTextDocumentLayout::*)(const QSizeF &)>(&MyQAbstractTextDocumentLayout::Signal_DocumentSizeChanged));
}
void QAbstractTextDocumentLayout_DisconnectDocumentSizeChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstractTextDocumentLayout*>(ptr), static_cast<void (QAbstractTextDocumentLayout::*)(const QSizeF &)>(&QAbstractTextDocumentLayout::documentSizeChanged), static_cast<MyQAbstractTextDocumentLayout*>(ptr), static_cast<void (MyQAbstractTextDocumentLayout::*)(const QSizeF &)>(&MyQAbstractTextDocumentLayout::Signal_DocumentSizeChanged));
}
void QAbstractTextDocumentLayout_DocumentSizeChanged(void* ptr, void* newSize)
{
static_cast<QAbstractTextDocumentLayout*>(ptr)->documentSizeChanged(*static_cast<QSizeF*>(newSize));
}
void QAbstractTextDocumentLayout_DrawInlineObject(void* ptr, void* painter, void* rect, void* object, int posInDocument, void* format)
{
static_cast<QAbstractTextDocumentLayout*>(ptr)->drawInlineObject(static_cast<QPainter*>(painter), *static_cast<QRectF*>(rect), *static_cast<QTextInlineObject*>(object), posInDocument, *static_cast<QTextFormat*>(format));
}
void QAbstractTextDocumentLayout_DrawInlineObjectDefault(void* ptr, void* painter, void* rect, void* object, int posInDocument, void* format)
{
static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::drawInlineObject(static_cast<QPainter*>(painter), *static_cast<QRectF*>(rect), *static_cast<QTextInlineObject*>(object), posInDocument, *static_cast<QTextFormat*>(format));
}
void QAbstractTextDocumentLayout_ConnectPageCountChanged(void* ptr)
{
QObject::connect(static_cast<QAbstractTextDocumentLayout*>(ptr), static_cast<void (QAbstractTextDocumentLayout::*)(int)>(&QAbstractTextDocumentLayout::pageCountChanged), static_cast<MyQAbstractTextDocumentLayout*>(ptr), static_cast<void (MyQAbstractTextDocumentLayout::*)(int)>(&MyQAbstractTextDocumentLayout::Signal_PageCountChanged));
}
void QAbstractTextDocumentLayout_DisconnectPageCountChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstractTextDocumentLayout*>(ptr), static_cast<void (QAbstractTextDocumentLayout::*)(int)>(&QAbstractTextDocumentLayout::pageCountChanged), static_cast<MyQAbstractTextDocumentLayout*>(ptr), static_cast<void (MyQAbstractTextDocumentLayout::*)(int)>(&MyQAbstractTextDocumentLayout::Signal_PageCountChanged));
}
void QAbstractTextDocumentLayout_PageCountChanged(void* ptr, int newPages)
{
static_cast<QAbstractTextDocumentLayout*>(ptr)->pageCountChanged(newPages);
}
void QAbstractTextDocumentLayout_PositionInlineObject(void* ptr, void* item, int posInDocument, void* format)
{
static_cast<QAbstractTextDocumentLayout*>(ptr)->positionInlineObject(*static_cast<QTextInlineObject*>(item), posInDocument, *static_cast<QTextFormat*>(format));
}
void QAbstractTextDocumentLayout_PositionInlineObjectDefault(void* ptr, void* item, int posInDocument, void* format)
{
static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::positionInlineObject(*static_cast<QTextInlineObject*>(item), posInDocument, *static_cast<QTextFormat*>(format));
}
void QAbstractTextDocumentLayout_RegisterHandler(void* ptr, int objectType, void* component)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(component))) {
static_cast<QAbstractTextDocumentLayout*>(ptr)->registerHandler(objectType, static_cast<QOffscreenSurface*>(component));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(component))) {
static_cast<QAbstractTextDocumentLayout*>(ptr)->registerHandler(objectType, static_cast<QPaintDeviceWindow*>(component));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(component))) {
static_cast<QAbstractTextDocumentLayout*>(ptr)->registerHandler(objectType, static_cast<QPdfWriter*>(component));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(component))) {
static_cast<QAbstractTextDocumentLayout*>(ptr)->registerHandler(objectType, static_cast<QWindow*>(component));
} else {
static_cast<QAbstractTextDocumentLayout*>(ptr)->registerHandler(objectType, static_cast<QObject*>(component));
}
}
void QAbstractTextDocumentLayout_ResizeInlineObject(void* ptr, void* item, int posInDocument, void* format)
{
static_cast<QAbstractTextDocumentLayout*>(ptr)->resizeInlineObject(*static_cast<QTextInlineObject*>(item), posInDocument, *static_cast<QTextFormat*>(format));
}
void QAbstractTextDocumentLayout_ResizeInlineObjectDefault(void* ptr, void* item, int posInDocument, void* format)
{
static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::resizeInlineObject(*static_cast<QTextInlineObject*>(item), posInDocument, *static_cast<QTextFormat*>(format));
}
void QAbstractTextDocumentLayout_SetPaintDevice(void* ptr, void* device)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(device))) {
static_cast<QAbstractTextDocumentLayout*>(ptr)->setPaintDevice(static_cast<QPaintDeviceWindow*>(device));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(device))) {
static_cast<QAbstractTextDocumentLayout*>(ptr)->setPaintDevice(static_cast<QPdfWriter*>(device));
} else {
static_cast<QAbstractTextDocumentLayout*>(ptr)->setPaintDevice(static_cast<QPaintDevice*>(device));
}
}
void QAbstractTextDocumentLayout_UnregisterHandler(void* ptr, int objectType, void* component)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(component))) {
static_cast<QAbstractTextDocumentLayout*>(ptr)->unregisterHandler(objectType, static_cast<QOffscreenSurface*>(component));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(component))) {
static_cast<QAbstractTextDocumentLayout*>(ptr)->unregisterHandler(objectType, static_cast<QPaintDeviceWindow*>(component));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(component))) {
static_cast<QAbstractTextDocumentLayout*>(ptr)->unregisterHandler(objectType, static_cast<QPdfWriter*>(component));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(component))) {
static_cast<QAbstractTextDocumentLayout*>(ptr)->unregisterHandler(objectType, static_cast<QWindow*>(component));
} else {
static_cast<QAbstractTextDocumentLayout*>(ptr)->unregisterHandler(objectType, static_cast<QObject*>(component));
}
}
void QAbstractTextDocumentLayout_ConnectUpdate(void* ptr)
{
QObject::connect(static_cast<QAbstractTextDocumentLayout*>(ptr), static_cast<void (QAbstractTextDocumentLayout::*)(const QRectF &)>(&QAbstractTextDocumentLayout::update), static_cast<MyQAbstractTextDocumentLayout*>(ptr), static_cast<void (MyQAbstractTextDocumentLayout::*)(const QRectF &)>(&MyQAbstractTextDocumentLayout::Signal_Update));
}
void QAbstractTextDocumentLayout_DisconnectUpdate(void* ptr)
{
QObject::disconnect(static_cast<QAbstractTextDocumentLayout*>(ptr), static_cast<void (QAbstractTextDocumentLayout::*)(const QRectF &)>(&QAbstractTextDocumentLayout::update), static_cast<MyQAbstractTextDocumentLayout*>(ptr), static_cast<void (MyQAbstractTextDocumentLayout::*)(const QRectF &)>(&MyQAbstractTextDocumentLayout::Signal_Update));
}
void QAbstractTextDocumentLayout_Update(void* ptr, void* rect)
{
static_cast<QAbstractTextDocumentLayout*>(ptr)->update(*static_cast<QRectF*>(rect));
}
void QAbstractTextDocumentLayout_ConnectUpdateBlock(void* ptr)
{
QObject::connect(static_cast<QAbstractTextDocumentLayout*>(ptr), static_cast<void (QAbstractTextDocumentLayout::*)(const QTextBlock &)>(&QAbstractTextDocumentLayout::updateBlock), static_cast<MyQAbstractTextDocumentLayout*>(ptr), static_cast<void (MyQAbstractTextDocumentLayout::*)(const QTextBlock &)>(&MyQAbstractTextDocumentLayout::Signal_UpdateBlock));
}
void QAbstractTextDocumentLayout_DisconnectUpdateBlock(void* ptr)
{
QObject::disconnect(static_cast<QAbstractTextDocumentLayout*>(ptr), static_cast<void (QAbstractTextDocumentLayout::*)(const QTextBlock &)>(&QAbstractTextDocumentLayout::updateBlock), static_cast<MyQAbstractTextDocumentLayout*>(ptr), static_cast<void (MyQAbstractTextDocumentLayout::*)(const QTextBlock &)>(&MyQAbstractTextDocumentLayout::Signal_UpdateBlock));
}
void QAbstractTextDocumentLayout_UpdateBlock(void* ptr, void* block)
{
static_cast<QAbstractTextDocumentLayout*>(ptr)->updateBlock(*static_cast<QTextBlock*>(block));
}
void* QAbstractTextDocumentLayout_PaintDevice(void* ptr)
{
return static_cast<QAbstractTextDocumentLayout*>(ptr)->paintDevice();
}
void* QAbstractTextDocumentLayout_BlockBoundingRect(void* ptr, void* block)
{
return ({ QRectF tmpValue = static_cast<QAbstractTextDocumentLayout*>(ptr)->blockBoundingRect(*static_cast<QTextBlock*>(block)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QAbstractTextDocumentLayout_FrameBoundingRect(void* ptr, void* frame)
{
return ({ QRectF tmpValue = static_cast<QAbstractTextDocumentLayout*>(ptr)->frameBoundingRect(static_cast<QTextFrame*>(frame)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QAbstractTextDocumentLayout_DocumentSize(void* ptr)
{
return ({ QSizeF tmpValue = static_cast<QAbstractTextDocumentLayout*>(ptr)->documentSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}
struct QtGui_PackedString QAbstractTextDocumentLayout_AnchorAt(void* ptr, void* position)
{
return ({ QByteArray t81dfdf = static_cast<QAbstractTextDocumentLayout*>(ptr)->anchorAt(*static_cast<QPointF*>(position)).toUtf8(); QtGui_PackedString { const_cast<char*>(t81dfdf.prepend("WHITESPACE").constData()+10), t81dfdf.size()-10 }; });
}
struct QtGui_PackedString QAbstractTextDocumentLayout_ImageAt(void* ptr, void* pos)
{
return ({ QByteArray t0eaa79 = static_cast<QAbstractTextDocumentLayout*>(ptr)->imageAt(*static_cast<QPointF*>(pos)).toUtf8(); QtGui_PackedString { const_cast<char*>(t0eaa79.prepend("WHITESPACE").constData()+10), t0eaa79.size()-10 }; });
}
void* QAbstractTextDocumentLayout_Document(void* ptr)
{
return static_cast<QAbstractTextDocumentLayout*>(ptr)->document();
}
void* QAbstractTextDocumentLayout_FormatAt(void* ptr, void* pos)
{
return new QTextFormat(static_cast<QAbstractTextDocumentLayout*>(ptr)->formatAt(*static_cast<QPointF*>(pos)));
}
void* QAbstractTextDocumentLayout_HandlerForObject(void* ptr, int objectType)
{
return static_cast<QAbstractTextDocumentLayout*>(ptr)->handlerForObject(objectType);
}
void* QAbstractTextDocumentLayout_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::metaObject());
}
int QAbstractTextDocumentLayout_HitTest(void* ptr, void* point, long long accuracy)
{
return static_cast<QAbstractTextDocumentLayout*>(ptr)->hitTest(*static_cast<QPointF*>(point), static_cast<Qt::HitTestAccuracy>(accuracy));
}
int QAbstractTextDocumentLayout_PageCount(void* ptr)
{
return static_cast<QAbstractTextDocumentLayout*>(ptr)->pageCount();
}
void* QAbstractTextDocumentLayout___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QAbstractTextDocumentLayout___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QAbstractTextDocumentLayout___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QAbstractTextDocumentLayout___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QAbstractTextDocumentLayout___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QAbstractTextDocumentLayout___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QAbstractTextDocumentLayout___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QAbstractTextDocumentLayout___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QAbstractTextDocumentLayout___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QAbstractTextDocumentLayout___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QAbstractTextDocumentLayout___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QAbstractTextDocumentLayout___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QAbstractTextDocumentLayout___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QAbstractTextDocumentLayout___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QAbstractTextDocumentLayout___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QAbstractTextDocumentLayout_EventDefault(void* ptr, void* e)
{
return static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::event(static_cast<QEvent*>(e));
}
char QAbstractTextDocumentLayout_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QAbstractTextDocumentLayout_ChildEventDefault(void* ptr, void* event)
{
static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::childEvent(static_cast<QChildEvent*>(event));
}
void QAbstractTextDocumentLayout_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QAbstractTextDocumentLayout_CustomEventDefault(void* ptr, void* event)
{
static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::customEvent(static_cast<QEvent*>(event));
}
void QAbstractTextDocumentLayout_DeleteLaterDefault(void* ptr)
{
static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::deleteLater();
}
void QAbstractTextDocumentLayout_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QAbstractTextDocumentLayout_TimerEventDefault(void* ptr, void* event)
{
static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::timerEvent(static_cast<QTimerEvent*>(event));
}
void* QAccessible_QAccessible_QueryAccessibleInterface(void* object)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(object))) {
return QAccessible::queryAccessibleInterface(static_cast<QOffscreenSurface*>(object));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(object))) {
return QAccessible::queryAccessibleInterface(static_cast<QPaintDeviceWindow*>(object));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(object))) {
return QAccessible::queryAccessibleInterface(static_cast<QPdfWriter*>(object));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(object))) {
return QAccessible::queryAccessibleInterface(static_cast<QWindow*>(object));
} else {
return QAccessible::queryAccessibleInterface(static_cast<QObject*>(object));
}
}
char QAccessible_QAccessible_IsActive()
{
return QAccessible::isActive();
}
void QAccessible_QAccessible_SetRootObject(void* object)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(object))) {
QAccessible::setRootObject(static_cast<QOffscreenSurface*>(object));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(object))) {
QAccessible::setRootObject(static_cast<QPaintDeviceWindow*>(object));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(object))) {
QAccessible::setRootObject(static_cast<QPdfWriter*>(object));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(object))) {
QAccessible::setRootObject(static_cast<QWindow*>(object));
} else {
QAccessible::setRootObject(static_cast<QObject*>(object));
}
}
void QAccessible_QAccessible_UpdateAccessibility(void* event)
{
QAccessible::updateAccessibility(static_cast<QAccessibleEvent*>(event));
}
class MyQAccessibleActionInterface: public QAccessibleActionInterface
{
public:
void doAction(const QString & actionName) { QByteArray tcd1a8c = actionName.toUtf8(); QtGui_PackedString actionNamePacked = { const_cast<char*>(tcd1a8c.prepend("WHITESPACE").constData()+10), tcd1a8c.size()-10 };callbackQAccessibleActionInterface_DoAction(this, actionNamePacked); };
~MyQAccessibleActionInterface() { callbackQAccessibleActionInterface_DestroyQAccessibleActionInterface(this); };
QString localizedActionDescription(const QString & actionName) const { QByteArray tcd1a8c = actionName.toUtf8(); QtGui_PackedString actionNamePacked = { const_cast<char*>(tcd1a8c.prepend("WHITESPACE").constData()+10), tcd1a8c.size()-10 };return ({ QtGui_PackedString tempVal = callbackQAccessibleActionInterface_LocalizedActionDescription(const_cast<void*>(static_cast<const void*>(this)), actionNamePacked); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
QString localizedActionName(const QString & actionName) const { QByteArray tcd1a8c = actionName.toUtf8(); QtGui_PackedString actionNamePacked = { const_cast<char*>(tcd1a8c.prepend("WHITESPACE").constData()+10), tcd1a8c.size()-10 };return ({ QtGui_PackedString tempVal = callbackQAccessibleActionInterface_LocalizedActionName(const_cast<void*>(static_cast<const void*>(this)), actionNamePacked); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
QStringList actionNames() const { return ({ QtGui_PackedString tempVal = callbackQAccessibleActionInterface_ActionNames(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("|", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
QStringList keyBindingsForAction(const QString & actionName) const { QByteArray tcd1a8c = actionName.toUtf8(); QtGui_PackedString actionNamePacked = { const_cast<char*>(tcd1a8c.prepend("WHITESPACE").constData()+10), tcd1a8c.size()-10 };return ({ QtGui_PackedString tempVal = callbackQAccessibleActionInterface_KeyBindingsForAction(const_cast<void*>(static_cast<const void*>(this)), actionNamePacked); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("|", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
};
struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_NextPageAction()
{
return ({ QByteArray t1ad988 = QAccessibleActionInterface::nextPageAction().toUtf8(); QtGui_PackedString { const_cast<char*>(t1ad988.prepend("WHITESPACE").constData()+10), t1ad988.size()-10 }; });
}
struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_PreviousPageAction()
{
return ({ QByteArray t44741f = QAccessibleActionInterface::previousPageAction().toUtf8(); QtGui_PackedString { const_cast<char*>(t44741f.prepend("WHITESPACE").constData()+10), t44741f.size()-10 }; });
}
struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_ScrollDownAction()
{
return ({ QByteArray tf765c1 = QAccessibleActionInterface::scrollDownAction().toUtf8(); QtGui_PackedString { const_cast<char*>(tf765c1.prepend("WHITESPACE").constData()+10), tf765c1.size()-10 }; });
}
struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_ScrollLeftAction()
{
return ({ QByteArray t35286b = QAccessibleActionInterface::scrollLeftAction().toUtf8(); QtGui_PackedString { const_cast<char*>(t35286b.prepend("WHITESPACE").constData()+10), t35286b.size()-10 }; });
}
struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_ScrollRightAction()
{
return ({ QByteArray taa7ac9 = QAccessibleActionInterface::scrollRightAction().toUtf8(); QtGui_PackedString { const_cast<char*>(taa7ac9.prepend("WHITESPACE").constData()+10), taa7ac9.size()-10 }; });
}
struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_ScrollUpAction()
{
return ({ QByteArray t6e10e7 = QAccessibleActionInterface::scrollUpAction().toUtf8(); QtGui_PackedString { const_cast<char*>(t6e10e7.prepend("WHITESPACE").constData()+10), t6e10e7.size()-10 }; });
}
struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_Tr(char* sourceText, char* disambiguation, int n)
{
return ({ QByteArray ta97743 = QAccessibleActionInterface::tr(const_cast<const char*>(sourceText), const_cast<const char*>(disambiguation), n).toUtf8(); QtGui_PackedString { const_cast<char*>(ta97743.prepend("WHITESPACE").constData()+10), ta97743.size()-10 }; });
}
struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_TrUtf8(char* sourceText, char* disambiguation, int n)
{
return ({ QByteArray t8052cc = QAccessibleActionInterface::trUtf8(const_cast<const char*>(sourceText), const_cast<const char*>(disambiguation), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t8052cc.prepend("WHITESPACE").constData()+10), t8052cc.size()-10 }; });
}
struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_DecreaseAction()
{
return ({ QByteArray t572cdb = QAccessibleActionInterface::decreaseAction().toUtf8(); QtGui_PackedString { const_cast<char*>(t572cdb.prepend("WHITESPACE").constData()+10), t572cdb.size()-10 }; });
}
struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_IncreaseAction()
{
return ({ QByteArray tf61c5c = QAccessibleActionInterface::increaseAction().toUtf8(); QtGui_PackedString { const_cast<char*>(tf61c5c.prepend("WHITESPACE").constData()+10), tf61c5c.size()-10 }; });
}
struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_PressAction()
{
return ({ QByteArray t899f7e = QAccessibleActionInterface::pressAction().toUtf8(); QtGui_PackedString { const_cast<char*>(t899f7e.prepend("WHITESPACE").constData()+10), t899f7e.size()-10 }; });
}
struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_SetFocusAction()
{
return ({ QByteArray t8516d1 = QAccessibleActionInterface::setFocusAction().toUtf8(); QtGui_PackedString { const_cast<char*>(t8516d1.prepend("WHITESPACE").constData()+10), t8516d1.size()-10 }; });
}
struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_ShowMenuAction()
{
return ({ QByteArray tfc8b6a = QAccessibleActionInterface::showMenuAction().toUtf8(); QtGui_PackedString { const_cast<char*>(tfc8b6a.prepend("WHITESPACE").constData()+10), tfc8b6a.size()-10 }; });
}
struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_ToggleAction()
{
return ({ QByteArray tc0e2c4 = QAccessibleActionInterface::toggleAction().toUtf8(); QtGui_PackedString { const_cast<char*>(tc0e2c4.prepend("WHITESPACE").constData()+10), tc0e2c4.size()-10 }; });
}
void QAccessibleActionInterface_DoAction(void* ptr, struct QtGui_PackedString actionName)
{
static_cast<QAccessibleActionInterface*>(ptr)->doAction(QString::fromUtf8(actionName.data, actionName.len));
}
void QAccessibleActionInterface_DestroyQAccessibleActionInterface(void* ptr)
{
static_cast<QAccessibleActionInterface*>(ptr)->~QAccessibleActionInterface();
}
void QAccessibleActionInterface_DestroyQAccessibleActionInterfaceDefault(void* ptr)
{
Q_UNUSED(ptr);
}
struct QtGui_PackedString QAccessibleActionInterface_LocalizedActionDescription(void* ptr, struct QtGui_PackedString actionName)
{
return ({ QByteArray tbea3be = static_cast<QAccessibleActionInterface*>(ptr)->localizedActionDescription(QString::fromUtf8(actionName.data, actionName.len)).toUtf8(); QtGui_PackedString { const_cast<char*>(tbea3be.prepend("WHITESPACE").constData()+10), tbea3be.size()-10 }; });
}
struct QtGui_PackedString QAccessibleActionInterface_LocalizedActionDescriptionDefault(void* ptr, struct QtGui_PackedString actionName)
{
return ({ QByteArray t62e182 = static_cast<QAccessibleActionInterface*>(ptr)->QAccessibleActionInterface::localizedActionDescription(QString::fromUtf8(actionName.data, actionName.len)).toUtf8(); QtGui_PackedString { const_cast<char*>(t62e182.prepend("WHITESPACE").constData()+10), t62e182.size()-10 }; });
}
struct QtGui_PackedString QAccessibleActionInterface_LocalizedActionName(void* ptr, struct QtGui_PackedString actionName)
{
return ({ QByteArray t0ed8e5 = static_cast<QAccessibleActionInterface*>(ptr)->localizedActionName(QString::fromUtf8(actionName.data, actionName.len)).toUtf8(); QtGui_PackedString { const_cast<char*>(t0ed8e5.prepend("WHITESPACE").constData()+10), t0ed8e5.size()-10 }; });
}
struct QtGui_PackedString QAccessibleActionInterface_LocalizedActionNameDefault(void* ptr, struct QtGui_PackedString actionName)
{
return ({ QByteArray t96c424 = static_cast<QAccessibleActionInterface*>(ptr)->QAccessibleActionInterface::localizedActionName(QString::fromUtf8(actionName.data, actionName.len)).toUtf8(); QtGui_PackedString { const_cast<char*>(t96c424.prepend("WHITESPACE").constData()+10), t96c424.size()-10 }; });
}
struct QtGui_PackedString QAccessibleActionInterface_ActionNames(void* ptr)
{
return ({ QByteArray t71e118 = static_cast<QAccessibleActionInterface*>(ptr)->actionNames().join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t71e118.prepend("WHITESPACE").constData()+10), t71e118.size()-10 }; });
}
struct QtGui_PackedString QAccessibleActionInterface_KeyBindingsForAction(void* ptr, struct QtGui_PackedString actionName)
{
return ({ QByteArray te37e4d = static_cast<QAccessibleActionInterface*>(ptr)->keyBindingsForAction(QString::fromUtf8(actionName.data, actionName.len)).join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(te37e4d.prepend("WHITESPACE").constData()+10), te37e4d.size()-10 }; });
}
class MyQAccessibleEditableTextInterface: public QAccessibleEditableTextInterface
{
public:
void deleteText(int startOffset, int endOffset) { callbackQAccessibleEditableTextInterface_DeleteText(this, startOffset, endOffset); };
void insertText(int offset, const QString & text) { QByteArray t372ea0 = text.toUtf8(); QtGui_PackedString textPacked = { const_cast<char*>(t372ea0.prepend("WHITESPACE").constData()+10), t372ea0.size()-10 };callbackQAccessibleEditableTextInterface_InsertText(this, offset, textPacked); };
void replaceText(int startOffset, int endOffset, const QString & text) { QByteArray t372ea0 = text.toUtf8(); QtGui_PackedString textPacked = { const_cast<char*>(t372ea0.prepend("WHITESPACE").constData()+10), t372ea0.size()-10 };callbackQAccessibleEditableTextInterface_ReplaceText(this, startOffset, endOffset, textPacked); };
~MyQAccessibleEditableTextInterface() { callbackQAccessibleEditableTextInterface_DestroyQAccessibleEditableTextInterface(this); };
};
void QAccessibleEditableTextInterface_DeleteText(void* ptr, int startOffset, int endOffset)
{
static_cast<QAccessibleEditableTextInterface*>(ptr)->deleteText(startOffset, endOffset);
}
void QAccessibleEditableTextInterface_InsertText(void* ptr, int offset, struct QtGui_PackedString text)
{
static_cast<QAccessibleEditableTextInterface*>(ptr)->insertText(offset, QString::fromUtf8(text.data, text.len));
}
void QAccessibleEditableTextInterface_ReplaceText(void* ptr, int startOffset, int endOffset, struct QtGui_PackedString text)
{
static_cast<QAccessibleEditableTextInterface*>(ptr)->replaceText(startOffset, endOffset, QString::fromUtf8(text.data, text.len));
}
void QAccessibleEditableTextInterface_DestroyQAccessibleEditableTextInterface(void* ptr)
{
static_cast<QAccessibleEditableTextInterface*>(ptr)->~QAccessibleEditableTextInterface();
}
void QAccessibleEditableTextInterface_DestroyQAccessibleEditableTextInterfaceDefault(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQAccessibleEvent: public QAccessibleEvent
{
public:
MyQAccessibleEvent(QAccessibleInterface *interfa, QAccessible::Event ty) : QAccessibleEvent(interfa, ty) {};
MyQAccessibleEvent(QObject *object, QAccessible::Event ty) : QAccessibleEvent(object, ty) {};
~MyQAccessibleEvent() { callbackQAccessibleEvent_DestroyQAccessibleEvent(this); };
QAccessibleInterface * accessibleInterface() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleEvent_AccessibleInterface(const_cast<void*>(static_cast<const void*>(this)))); };
};
void* QAccessibleEvent_NewQAccessibleEvent3(void* interfa, long long ty)
{
if (dynamic_cast<QAccessibleWidget*>(static_cast<QAccessibleInterface*>(interfa))) {
return new MyQAccessibleEvent(static_cast<QAccessibleWidget*>(interfa), static_cast<QAccessible::Event>(ty));
} else {
return new MyQAccessibleEvent(static_cast<QAccessibleInterface*>(interfa), static_cast<QAccessible::Event>(ty));
}
}
void* QAccessibleEvent_NewQAccessibleEvent(void* object, long long ty)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
return new MyQAccessibleEvent(static_cast<QCameraImageCapture*>(object), static_cast<QAccessible::Event>(ty));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(object))) {
return new MyQAccessibleEvent(static_cast<QDBusPendingCallWatcher*>(object), static_cast<QAccessible::Event>(ty));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(object))) {
return new MyQAccessibleEvent(static_cast<QExtensionFactory*>(object), static_cast<QAccessible::Event>(ty));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(object))) {
return new MyQAccessibleEvent(static_cast<QExtensionManager*>(object), static_cast<QAccessible::Event>(ty));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(object))) {
return new MyQAccessibleEvent(static_cast<QGraphicsObject*>(object), static_cast<QAccessible::Event>(ty));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(object))) {
return new MyQAccessibleEvent(static_cast<QGraphicsWidget*>(object), static_cast<QAccessible::Event>(ty));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(object))) {
return new MyQAccessibleEvent(static_cast<QLayout*>(object), static_cast<QAccessible::Event>(ty));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
return new MyQAccessibleEvent(static_cast<QMediaPlaylist*>(object), static_cast<QAccessible::Event>(ty));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
return new MyQAccessibleEvent(static_cast<QMediaRecorder*>(object), static_cast<QAccessible::Event>(ty));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(object))) {
return new MyQAccessibleEvent(static_cast<QOffscreenSurface*>(object), static_cast<QAccessible::Event>(ty));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(object))) {
return new MyQAccessibleEvent(static_cast<QPaintDeviceWindow*>(object), static_cast<QAccessible::Event>(ty));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(object))) {
return new MyQAccessibleEvent(static_cast<QPdfWriter*>(object), static_cast<QAccessible::Event>(ty));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(object))) {
return new MyQAccessibleEvent(static_cast<QQuickItem*>(object), static_cast<QAccessible::Event>(ty));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
return new MyQAccessibleEvent(static_cast<QRadioData*>(object), static_cast<QAccessible::Event>(ty));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(object))) {
return new MyQAccessibleEvent(static_cast<QWidget*>(object), static_cast<QAccessible::Event>(ty));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(object))) {
return new MyQAccessibleEvent(static_cast<QWindow*>(object), static_cast<QAccessible::Event>(ty));
} else {
return new MyQAccessibleEvent(static_cast<QObject*>(object), static_cast<QAccessible::Event>(ty));
}
}
void QAccessibleEvent_SetChild(void* ptr, int child)
{
static_cast<QAccessibleEvent*>(ptr)->setChild(child);
}
void QAccessibleEvent_DestroyQAccessibleEvent(void* ptr)
{
static_cast<QAccessibleEvent*>(ptr)->~QAccessibleEvent();
}
void QAccessibleEvent_DestroyQAccessibleEventDefault(void* ptr)
{
Q_UNUSED(ptr);
}
long long QAccessibleEvent_Type(void* ptr)
{
return static_cast<QAccessibleEvent*>(ptr)->type();
}
void* QAccessibleEvent_AccessibleInterface(void* ptr)
{
return static_cast<QAccessibleEvent*>(ptr)->accessibleInterface();
}
void* QAccessibleEvent_AccessibleInterfaceDefault(void* ptr)
{
if (dynamic_cast<QAccessibleValueChangeEvent*>(static_cast<QAccessibleEvent*>(ptr))) {
return static_cast<QAccessibleValueChangeEvent*>(ptr)->QAccessibleValueChangeEvent::accessibleInterface();
} else if (dynamic_cast<QAccessibleTextUpdateEvent*>(static_cast<QAccessibleEvent*>(ptr))) {
return static_cast<QAccessibleTextUpdateEvent*>(ptr)->QAccessibleTextUpdateEvent::accessibleInterface();
} else if (dynamic_cast<QAccessibleTextSelectionEvent*>(static_cast<QAccessibleEvent*>(ptr))) {
return static_cast<QAccessibleTextSelectionEvent*>(ptr)->QAccessibleTextSelectionEvent::accessibleInterface();
} else if (dynamic_cast<QAccessibleTextRemoveEvent*>(static_cast<QAccessibleEvent*>(ptr))) {
return static_cast<QAccessibleTextRemoveEvent*>(ptr)->QAccessibleTextRemoveEvent::accessibleInterface();
} else if (dynamic_cast<QAccessibleTextInsertEvent*>(static_cast<QAccessibleEvent*>(ptr))) {
return static_cast<QAccessibleTextInsertEvent*>(ptr)->QAccessibleTextInsertEvent::accessibleInterface();
} else if (dynamic_cast<QAccessibleTextCursorEvent*>(static_cast<QAccessibleEvent*>(ptr))) {
return static_cast<QAccessibleTextCursorEvent*>(ptr)->QAccessibleTextCursorEvent::accessibleInterface();
} else if (dynamic_cast<QAccessibleTableModelChangeEvent*>(static_cast<QAccessibleEvent*>(ptr))) {
return static_cast<QAccessibleTableModelChangeEvent*>(ptr)->QAccessibleTableModelChangeEvent::accessibleInterface();
} else if (dynamic_cast<QAccessibleStateChangeEvent*>(static_cast<QAccessibleEvent*>(ptr))) {
return static_cast<QAccessibleStateChangeEvent*>(ptr)->QAccessibleStateChangeEvent::accessibleInterface();
} else {
return static_cast<QAccessibleEvent*>(ptr)->QAccessibleEvent::accessibleInterface();
}
}
void* QAccessibleEvent_Object(void* ptr)
{
return static_cast<QAccessibleEvent*>(ptr)->object();
}
int QAccessibleEvent_Child(void* ptr)
{
return static_cast<QAccessibleEvent*>(ptr)->child();
}
void* QAccessibleEvent_M_object(void* ptr)
{
return static_cast<QAccessibleEvent*>(ptr)->m_object;
}
void QAccessibleEvent_SetM_object(void* ptr, void* vqo)
{
static_cast<QAccessibleEvent*>(ptr)->m_object = static_cast<QObject*>(vqo);
}
long long QAccessibleEvent_M_type(void* ptr)
{
return static_cast<QAccessibleEvent*>(ptr)->m_type;
}
void QAccessibleEvent_SetM_type(void* ptr, long long vqa)
{
static_cast<QAccessibleEvent*>(ptr)->m_type = static_cast<QAccessible::Event>(vqa);
}
class MyQAccessibleInterface: public QAccessibleInterface
{
public:
void * interface_cast(QAccessible::InterfaceType ty) { return callbackQAccessibleInterface_Interface_cast(this, ty); };
void setText(QAccessible::Text t, const QString & text) { QByteArray t372ea0 = text.toUtf8(); QtGui_PackedString textPacked = { const_cast<char*>(t372ea0.prepend("WHITESPACE").constData()+10), t372ea0.size()-10 };callbackQAccessibleInterface_SetText(this, t, textPacked); };
~MyQAccessibleInterface() { callbackQAccessibleInterface_DestroyQAccessibleInterface(this); };
QAccessible::Role role() const { return static_cast<QAccessible::Role>(callbackQAccessibleInterface_Role(const_cast<void*>(static_cast<const void*>(this)))); };
QAccessibleInterface * child(int index) const { return static_cast<QAccessibleInterface*>(callbackQAccessibleInterface_Child(const_cast<void*>(static_cast<const void*>(this)), index)); };
QAccessibleInterface * childAt(int x, int y) const { return static_cast<QAccessibleInterface*>(callbackQAccessibleInterface_ChildAt(const_cast<void*>(static_cast<const void*>(this)), x, y)); };
QAccessibleInterface * focusChild() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleInterface_FocusChild(const_cast<void*>(static_cast<const void*>(this)))); };
QAccessibleInterface * parent() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleInterface_Parent(const_cast<void*>(static_cast<const void*>(this)))); };
QColor backgroundColor() const { return *static_cast<QColor*>(callbackQAccessibleInterface_BackgroundColor(const_cast<void*>(static_cast<const void*>(this)))); };
QColor foregroundColor() const { return *static_cast<QColor*>(callbackQAccessibleInterface_ForegroundColor(const_cast<void*>(static_cast<const void*>(this)))); };
QObject * object() const { return static_cast<QObject*>(callbackQAccessibleInterface_Object(const_cast<void*>(static_cast<const void*>(this)))); };
QRect rect() const { return *static_cast<QRect*>(callbackQAccessibleInterface_Rect(const_cast<void*>(static_cast<const void*>(this)))); };
QString text(QAccessible::Text t) const { return ({ QtGui_PackedString tempVal = callbackQAccessibleInterface_Text(const_cast<void*>(static_cast<const void*>(this)), t); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
QWindow * window() const { return static_cast<QWindow*>(callbackQAccessibleInterface_Window(const_cast<void*>(static_cast<const void*>(this)))); };
bool isValid() const { return callbackQAccessibleInterface_IsValid(const_cast<void*>(static_cast<const void*>(this))) != 0; };
int childCount() const { return callbackQAccessibleInterface_ChildCount(const_cast<void*>(static_cast<const void*>(this))); };
int indexOfChild(const QAccessibleInterface * child) const { return callbackQAccessibleInterface_IndexOfChild(const_cast<void*>(static_cast<const void*>(this)), const_cast<QAccessibleInterface*>(child)); };
};
void* QAccessibleInterface_ActionInterface(void* ptr)
{
return static_cast<QAccessibleInterface*>(ptr)->actionInterface();
}
void* QAccessibleInterface_TableCellInterface(void* ptr)
{
return static_cast<QAccessibleInterface*>(ptr)->tableCellInterface();
}
void* QAccessibleInterface_TableInterface(void* ptr)
{
return static_cast<QAccessibleInterface*>(ptr)->tableInterface();
}
void* QAccessibleInterface_TextInterface(void* ptr)
{
return static_cast<QAccessibleInterface*>(ptr)->textInterface();
}
void* QAccessibleInterface_ValueInterface(void* ptr)
{
return static_cast<QAccessibleInterface*>(ptr)->valueInterface();
}
void* QAccessibleInterface_Interface_cast(void* ptr, long long ty)
{
return static_cast<QAccessibleInterface*>(ptr)->interface_cast(static_cast<QAccessible::InterfaceType>(ty));
}
void* QAccessibleInterface_Interface_castDefault(void* ptr, long long ty)
{
if (dynamic_cast<QAccessibleObject*>(static_cast<QAccessibleInterface*>(ptr))) {
return static_cast<QAccessibleObject*>(ptr)->QAccessibleObject::interface_cast(static_cast<QAccessible::InterfaceType>(ty));
} else {
return static_cast<QAccessibleInterface*>(ptr)->QAccessibleInterface::interface_cast(static_cast<QAccessible::InterfaceType>(ty));
}
}
void QAccessibleInterface_SetText(void* ptr, long long t, struct QtGui_PackedString text)
{
static_cast<QAccessibleInterface*>(ptr)->setText(static_cast<QAccessible::Text>(t), QString::fromUtf8(text.data, text.len));
}
void QAccessibleInterface_DestroyQAccessibleInterface(void* ptr)
{
static_cast<QAccessibleInterface*>(ptr)->~QAccessibleInterface();
}
void QAccessibleInterface_DestroyQAccessibleInterfaceDefault(void* ptr)
{
Q_UNUSED(ptr);
}
long long QAccessibleInterface_Role(void* ptr)
{
return static_cast<QAccessibleInterface*>(ptr)->role();
}
void* QAccessibleInterface_Child(void* ptr, int index)
{
return static_cast<QAccessibleInterface*>(ptr)->child(index);
}
void* QAccessibleInterface_ChildAt(void* ptr, int x, int y)
{
return static_cast<QAccessibleInterface*>(ptr)->childAt(x, y);
}
void* QAccessibleInterface_FocusChild(void* ptr)
{
return static_cast<QAccessibleInterface*>(ptr)->focusChild();
}
void* QAccessibleInterface_FocusChildDefault(void* ptr)
{
if (dynamic_cast<QAccessibleObject*>(static_cast<QAccessibleInterface*>(ptr))) {
return static_cast<QAccessibleObject*>(ptr)->QAccessibleObject::focusChild();
} else {
return static_cast<QAccessibleInterface*>(ptr)->QAccessibleInterface::focusChild();
}
}
void* QAccessibleInterface_Parent(void* ptr)
{
return static_cast<QAccessibleInterface*>(ptr)->parent();
}
void* QAccessibleInterface_BackgroundColor(void* ptr)
{
return new QColor(static_cast<QAccessibleInterface*>(ptr)->backgroundColor());
}
void* QAccessibleInterface_BackgroundColorDefault(void* ptr)
{
if (dynamic_cast<QAccessibleObject*>(static_cast<QAccessibleInterface*>(ptr))) {
return new QColor(static_cast<QAccessibleObject*>(ptr)->QAccessibleObject::backgroundColor());
} else {
return new QColor(static_cast<QAccessibleInterface*>(ptr)->QAccessibleInterface::backgroundColor());
}
}
void* QAccessibleInterface_ForegroundColor(void* ptr)
{
return new QColor(static_cast<QAccessibleInterface*>(ptr)->foregroundColor());
}
void* QAccessibleInterface_ForegroundColorDefault(void* ptr)
{
if (dynamic_cast<QAccessibleObject*>(static_cast<QAccessibleInterface*>(ptr))) {
return new QColor(static_cast<QAccessibleObject*>(ptr)->QAccessibleObject::foregroundColor());
} else {
return new QColor(static_cast<QAccessibleInterface*>(ptr)->QAccessibleInterface::foregroundColor());
}
}
void* QAccessibleInterface_Object(void* ptr)
{
return static_cast<QAccessibleInterface*>(ptr)->object();
}
void* QAccessibleInterface_Rect(void* ptr)
{
return ({ QRect tmpValue = static_cast<QAccessibleInterface*>(ptr)->rect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
struct QtGui_PackedString QAccessibleInterface_Text(void* ptr, long long t)
{
return ({ QByteArray t0d7711 = static_cast<QAccessibleInterface*>(ptr)->text(static_cast<QAccessible::Text>(t)).toUtf8(); QtGui_PackedString { const_cast<char*>(t0d7711.prepend("WHITESPACE").constData()+10), t0d7711.size()-10 }; });
}
void* QAccessibleInterface_Window(void* ptr)
{
return static_cast<QAccessibleInterface*>(ptr)->window();
}
void* QAccessibleInterface_WindowDefault(void* ptr)
{
if (dynamic_cast<QAccessibleObject*>(static_cast<QAccessibleInterface*>(ptr))) {
return static_cast<QAccessibleObject*>(ptr)->QAccessibleObject::window();
} else {
return static_cast<QAccessibleInterface*>(ptr)->QAccessibleInterface::window();
}
}
char QAccessibleInterface_IsValid(void* ptr)
{
return static_cast<QAccessibleInterface*>(ptr)->isValid();
}
int QAccessibleInterface_ChildCount(void* ptr)
{
return static_cast<QAccessibleInterface*>(ptr)->childCount();
}
int QAccessibleInterface_IndexOfChild(void* ptr, void* child)
{
return static_cast<QAccessibleInterface*>(ptr)->indexOfChild(static_cast<QAccessibleInterface*>(child));
}
class MyQAccessibleObject: public QAccessibleObject
{
public:
void setText(QAccessible::Text t, const QString & text) { QByteArray t372ea0 = text.toUtf8(); QtGui_PackedString textPacked = { const_cast<char*>(t372ea0.prepend("WHITESPACE").constData()+10), t372ea0.size()-10 };callbackQAccessibleObject_SetText(this, t, textPacked); };
~MyQAccessibleObject() { callbackQAccessibleObject_DestroyQAccessibleObject(this); };
QAccessibleInterface * childAt(int x, int y) const { return static_cast<QAccessibleInterface*>(callbackQAccessibleObject_ChildAt(const_cast<void*>(static_cast<const void*>(this)), x, y)); };
QObject * object() const { return static_cast<QObject*>(callbackQAccessibleObject_Object(const_cast<void*>(static_cast<const void*>(this)))); };
QRect rect() const { return *static_cast<QRect*>(callbackQAccessibleObject_Rect(const_cast<void*>(static_cast<const void*>(this)))); };
bool isValid() const { return callbackQAccessibleObject_IsValid(const_cast<void*>(static_cast<const void*>(this))) != 0; };
void * interface_cast(QAccessible::InterfaceType ty) { return callbackQAccessibleInterface_Interface_cast(this, ty); };
QAccessible::Role role() const { return static_cast<QAccessible::Role>(callbackQAccessibleObject_Role(const_cast<void*>(static_cast<const void*>(this)))); };
QAccessibleInterface * child(int index) const { return static_cast<QAccessibleInterface*>(callbackQAccessibleObject_Child(const_cast<void*>(static_cast<const void*>(this)), index)); };
QAccessibleInterface * focusChild() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleInterface_FocusChild(const_cast<void*>(static_cast<const void*>(this)))); };
QAccessibleInterface * parent() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleObject_Parent(const_cast<void*>(static_cast<const void*>(this)))); };
QColor backgroundColor() const { return *static_cast<QColor*>(callbackQAccessibleInterface_BackgroundColor(const_cast<void*>(static_cast<const void*>(this)))); };
QColor foregroundColor() const { return *static_cast<QColor*>(callbackQAccessibleInterface_ForegroundColor(const_cast<void*>(static_cast<const void*>(this)))); };
QString text(QAccessible::Text t) const { return ({ QtGui_PackedString tempVal = callbackQAccessibleObject_Text(const_cast<void*>(static_cast<const void*>(this)), t); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
QWindow * window() const { return static_cast<QWindow*>(callbackQAccessibleInterface_Window(const_cast<void*>(static_cast<const void*>(this)))); };
int childCount() const { return callbackQAccessibleObject_ChildCount(const_cast<void*>(static_cast<const void*>(this))); };
int indexOfChild(const QAccessibleInterface * child) const { return callbackQAccessibleObject_IndexOfChild(const_cast<void*>(static_cast<const void*>(this)), const_cast<QAccessibleInterface*>(child)); };
};
void QAccessibleObject_SetText(void* ptr, long long t, struct QtGui_PackedString text)
{
static_cast<QAccessibleObject*>(ptr)->setText(static_cast<QAccessible::Text>(t), QString::fromUtf8(text.data, text.len));
}
void QAccessibleObject_SetTextDefault(void* ptr, long long t, struct QtGui_PackedString text)
{
static_cast<QAccessibleObject*>(ptr)->QAccessibleObject::setText(static_cast<QAccessible::Text>(t), QString::fromUtf8(text.data, text.len));
}
void QAccessibleObject_DestroyQAccessibleObject(void* ptr)
{
static_cast<QAccessibleObject*>(ptr)->~QAccessibleObject();
}
void QAccessibleObject_DestroyQAccessibleObjectDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QAccessibleObject_ChildAt(void* ptr, int x, int y)
{
return static_cast<QAccessibleObject*>(ptr)->childAt(x, y);
}
void* QAccessibleObject_ChildAtDefault(void* ptr, int x, int y)
{
return static_cast<QAccessibleObject*>(ptr)->QAccessibleObject::childAt(x, y);
}
void* QAccessibleObject_Object(void* ptr)
{
return static_cast<QAccessibleObject*>(ptr)->object();
}
void* QAccessibleObject_ObjectDefault(void* ptr)
{
return static_cast<QAccessibleObject*>(ptr)->QAccessibleObject::object();
}
void* QAccessibleObject_Rect(void* ptr)
{
return ({ QRect tmpValue = static_cast<QAccessibleObject*>(ptr)->rect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QAccessibleObject_RectDefault(void* ptr)
{
return ({ QRect tmpValue = static_cast<QAccessibleObject*>(ptr)->QAccessibleObject::rect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
char QAccessibleObject_IsValid(void* ptr)
{
return static_cast<QAccessibleObject*>(ptr)->isValid();
}
char QAccessibleObject_IsValidDefault(void* ptr)
{
return static_cast<QAccessibleObject*>(ptr)->QAccessibleObject::isValid();
}
long long QAccessibleObject_Role(void* ptr)
{
return static_cast<QAccessibleObject*>(ptr)->role();
}
long long QAccessibleObject_RoleDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QAccessibleObject_Child(void* ptr, int index)
{
return static_cast<QAccessibleObject*>(ptr)->child(index);
}
void* QAccessibleObject_ChildDefault(void* ptr, int index)
{
Q_UNUSED(ptr);
Q_UNUSED(index);
}
void* QAccessibleObject_Parent(void* ptr)
{
return static_cast<QAccessibleObject*>(ptr)->parent();
}
void* QAccessibleObject_ParentDefault(void* ptr)
{
Q_UNUSED(ptr);
}
struct QtGui_PackedString QAccessibleObject_Text(void* ptr, long long t)
{
return ({ QByteArray td7ef98 = static_cast<QAccessibleObject*>(ptr)->text(static_cast<QAccessible::Text>(t)).toUtf8(); QtGui_PackedString { const_cast<char*>(td7ef98.prepend("WHITESPACE").constData()+10), td7ef98.size()-10 }; });
}
struct QtGui_PackedString QAccessibleObject_TextDefault(void* ptr, long long t)
{
Q_UNUSED(ptr);
Q_UNUSED(t);
}
int QAccessibleObject_ChildCount(void* ptr)
{
return static_cast<QAccessibleObject*>(ptr)->childCount();
}
int QAccessibleObject_ChildCountDefault(void* ptr)
{
Q_UNUSED(ptr);
}
int QAccessibleObject_IndexOfChild(void* ptr, void* child)
{
return static_cast<QAccessibleObject*>(ptr)->indexOfChild(static_cast<QAccessibleInterface*>(child));
}
int QAccessibleObject_IndexOfChildDefault(void* ptr, void* child)
{
Q_UNUSED(ptr);
Q_UNUSED(child);
}
class MyQAccessiblePlugin: public QAccessiblePlugin
{
public:
MyQAccessiblePlugin(QObject *parent = Q_NULLPTR) : QAccessiblePlugin(parent) {QAccessiblePlugin_QAccessiblePlugin_QRegisterMetaType();};
QAccessibleInterface * create(const QString & key, QObject * object) { QByteArray ta62f22 = key.toUtf8(); QtGui_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };return static_cast<QAccessibleInterface*>(callbackQAccessiblePlugin_Create(this, keyPacked, object)); };
~MyQAccessiblePlugin() { callbackQAccessiblePlugin_DestroyQAccessiblePlugin(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAccessiblePlugin_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQAccessiblePlugin_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQAccessiblePlugin_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQAccessiblePlugin_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQAccessiblePlugin_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQAccessiblePlugin_CustomEvent(this, event); };
void deleteLater() { callbackQAccessiblePlugin_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQAccessiblePlugin_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQAccessiblePlugin_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQAccessiblePlugin_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQAccessiblePlugin_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQAccessiblePlugin*)
int QAccessiblePlugin_QAccessiblePlugin_QRegisterMetaType(){qRegisterMetaType<QAccessiblePlugin*>(); return qRegisterMetaType<MyQAccessiblePlugin*>();}
void* QAccessiblePlugin_Create(void* ptr, struct QtGui_PackedString key, void* object)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(object))) {
return static_cast<QAccessiblePlugin*>(ptr)->create(QString::fromUtf8(key.data, key.len), static_cast<QOffscreenSurface*>(object));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(object))) {
return static_cast<QAccessiblePlugin*>(ptr)->create(QString::fromUtf8(key.data, key.len), static_cast<QPaintDeviceWindow*>(object));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(object))) {
return static_cast<QAccessiblePlugin*>(ptr)->create(QString::fromUtf8(key.data, key.len), static_cast<QPdfWriter*>(object));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(object))) {
return static_cast<QAccessiblePlugin*>(ptr)->create(QString::fromUtf8(key.data, key.len), static_cast<QWindow*>(object));
} else {
return static_cast<QAccessiblePlugin*>(ptr)->create(QString::fromUtf8(key.data, key.len), static_cast<QObject*>(object));
}
}
void* QAccessiblePlugin_NewQAccessiblePlugin(void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQAccessiblePlugin(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQAccessiblePlugin(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQAccessiblePlugin(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQAccessiblePlugin(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQAccessiblePlugin(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQAccessiblePlugin(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQAccessiblePlugin(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQAccessiblePlugin(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQAccessiblePlugin(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQAccessiblePlugin(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQAccessiblePlugin(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQAccessiblePlugin(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQAccessiblePlugin(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQAccessiblePlugin(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQAccessiblePlugin(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQAccessiblePlugin(static_cast<QWindow*>(parent));
} else {
return new MyQAccessiblePlugin(static_cast<QObject*>(parent));
}
}
struct QtGui_PackedString QAccessiblePlugin_QAccessiblePlugin_Tr(char* s, char* c, int n)
{
return ({ QByteArray t95c25d = QAccessiblePlugin::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t95c25d.prepend("WHITESPACE").constData()+10), t95c25d.size()-10 }; });
}
struct QtGui_PackedString QAccessiblePlugin_QAccessiblePlugin_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray tf5d3c7 = QAccessiblePlugin::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(tf5d3c7.prepend("WHITESPACE").constData()+10), tf5d3c7.size()-10 }; });
}
void QAccessiblePlugin_DestroyQAccessiblePlugin(void* ptr)
{
static_cast<QAccessiblePlugin*>(ptr)->~QAccessiblePlugin();
}
void QAccessiblePlugin_DestroyQAccessiblePluginDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QAccessiblePlugin_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::metaObject());
}
void* QAccessiblePlugin___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QAccessiblePlugin___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QAccessiblePlugin___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QAccessiblePlugin___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QAccessiblePlugin___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QAccessiblePlugin___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QAccessiblePlugin___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QAccessiblePlugin___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QAccessiblePlugin___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QAccessiblePlugin___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QAccessiblePlugin___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QAccessiblePlugin___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QAccessiblePlugin___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QAccessiblePlugin___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QAccessiblePlugin___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QAccessiblePlugin_EventDefault(void* ptr, void* e)
{
return static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::event(static_cast<QEvent*>(e));
}
char QAccessiblePlugin_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QAccessiblePlugin_ChildEventDefault(void* ptr, void* event)
{
static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::childEvent(static_cast<QChildEvent*>(event));
}
void QAccessiblePlugin_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QAccessiblePlugin_CustomEventDefault(void* ptr, void* event)
{
static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::customEvent(static_cast<QEvent*>(event));
}
void QAccessiblePlugin_DeleteLaterDefault(void* ptr)
{
static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::deleteLater();
}
void QAccessiblePlugin_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QAccessiblePlugin_TimerEventDefault(void* ptr, void* event)
{
static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::timerEvent(static_cast<QTimerEvent*>(event));
}
class MyQAccessibleStateChangeEvent: public QAccessibleStateChangeEvent
{
public:
QAccessibleInterface * accessibleInterface() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleEvent_AccessibleInterface(const_cast<void*>(static_cast<const void*>(this)))); };
};
class MyQAccessibleTableCellInterface: public QAccessibleTableCellInterface
{
public:
~MyQAccessibleTableCellInterface() { callbackQAccessibleTableCellInterface_DestroyQAccessibleTableCellInterface(this); };
QAccessibleInterface * table() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleTableCellInterface_Table(const_cast<void*>(static_cast<const void*>(this)))); };
QList<QAccessibleInterface *> columnHeaderCells() const { return ({ QList<QAccessibleInterface *>* tmpP = static_cast<QList<QAccessibleInterface *>*>(callbackQAccessibleTableCellInterface_ColumnHeaderCells(const_cast<void*>(static_cast<const void*>(this)))); QList<QAccessibleInterface *> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
QList<QAccessibleInterface *> rowHeaderCells() const { return ({ QList<QAccessibleInterface *>* tmpP = static_cast<QList<QAccessibleInterface *>*>(callbackQAccessibleTableCellInterface_RowHeaderCells(const_cast<void*>(static_cast<const void*>(this)))); QList<QAccessibleInterface *> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
bool isSelected() const { return callbackQAccessibleTableCellInterface_IsSelected(const_cast<void*>(static_cast<const void*>(this))) != 0; };
int columnExtent() const { return callbackQAccessibleTableCellInterface_ColumnExtent(const_cast<void*>(static_cast<const void*>(this))); };
int columnIndex() const { return callbackQAccessibleTableCellInterface_ColumnIndex(const_cast<void*>(static_cast<const void*>(this))); };
int rowExtent() const { return callbackQAccessibleTableCellInterface_RowExtent(const_cast<void*>(static_cast<const void*>(this))); };
int rowIndex() const { return callbackQAccessibleTableCellInterface_RowIndex(const_cast<void*>(static_cast<const void*>(this))); };
};
void QAccessibleTableCellInterface_DestroyQAccessibleTableCellInterface(void* ptr)
{
static_cast<QAccessibleTableCellInterface*>(ptr)->~QAccessibleTableCellInterface();
}
void QAccessibleTableCellInterface_DestroyQAccessibleTableCellInterfaceDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QAccessibleTableCellInterface_Table(void* ptr)
{
return static_cast<QAccessibleTableCellInterface*>(ptr)->table();
}
struct QtGui_PackedList QAccessibleTableCellInterface_ColumnHeaderCells(void* ptr)
{
return ({ QList<QAccessibleInterface *>* tmpValue = new QList<QAccessibleInterface *>(static_cast<QAccessibleTableCellInterface*>(ptr)->columnHeaderCells()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedList QAccessibleTableCellInterface_RowHeaderCells(void* ptr)
{
return ({ QList<QAccessibleInterface *>* tmpValue = new QList<QAccessibleInterface *>(static_cast<QAccessibleTableCellInterface*>(ptr)->rowHeaderCells()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
char QAccessibleTableCellInterface_IsSelected(void* ptr)
{
return static_cast<QAccessibleTableCellInterface*>(ptr)->isSelected();
}
int QAccessibleTableCellInterface_ColumnExtent(void* ptr)
{
return static_cast<QAccessibleTableCellInterface*>(ptr)->columnExtent();
}
int QAccessibleTableCellInterface_ColumnIndex(void* ptr)
{
return static_cast<QAccessibleTableCellInterface*>(ptr)->columnIndex();
}
int QAccessibleTableCellInterface_RowExtent(void* ptr)
{
return static_cast<QAccessibleTableCellInterface*>(ptr)->rowExtent();
}
int QAccessibleTableCellInterface_RowIndex(void* ptr)
{
return static_cast<QAccessibleTableCellInterface*>(ptr)->rowIndex();
}
void* QAccessibleTableCellInterface___columnHeaderCells_atList(void* ptr, int i)
{
return ({QAccessibleInterface * tmp = static_cast<QList<QAccessibleInterface *>*>(ptr)->at(i); if (i == static_cast<QList<QAccessibleInterface *>*>(ptr)->size()-1) { static_cast<QList<QAccessibleInterface *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QAccessibleTableCellInterface___columnHeaderCells_setList(void* ptr, void* i)
{
static_cast<QList<QAccessibleInterface *>*>(ptr)->append(static_cast<QAccessibleInterface*>(i));
}
void* QAccessibleTableCellInterface___columnHeaderCells_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QAccessibleInterface *>();
}
void* QAccessibleTableCellInterface___rowHeaderCells_atList(void* ptr, int i)
{
return ({QAccessibleInterface * tmp = static_cast<QList<QAccessibleInterface *>*>(ptr)->at(i); if (i == static_cast<QList<QAccessibleInterface *>*>(ptr)->size()-1) { static_cast<QList<QAccessibleInterface *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QAccessibleTableCellInterface___rowHeaderCells_setList(void* ptr, void* i)
{
static_cast<QList<QAccessibleInterface *>*>(ptr)->append(static_cast<QAccessibleInterface*>(i));
}
void* QAccessibleTableCellInterface___rowHeaderCells_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QAccessibleInterface *>();
}
class MyQAccessibleTableInterface: public QAccessibleTableInterface
{
public:
bool selectColumn(int column) { return callbackQAccessibleTableInterface_SelectColumn(this, column) != 0; };
bool selectRow(int row) { return callbackQAccessibleTableInterface_SelectRow(this, row) != 0; };
bool unselectColumn(int column) { return callbackQAccessibleTableInterface_UnselectColumn(this, column) != 0; };
bool unselectRow(int row) { return callbackQAccessibleTableInterface_UnselectRow(this, row) != 0; };
void modelChange(QAccessibleTableModelChangeEvent * event) { callbackQAccessibleTableInterface_ModelChange(this, event); };
~MyQAccessibleTableInterface() { callbackQAccessibleTableInterface_DestroyQAccessibleTableInterface(this); };
QAccessibleInterface * caption() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleTableInterface_Caption(const_cast<void*>(static_cast<const void*>(this)))); };
QAccessibleInterface * cellAt(int row, int column) const { return static_cast<QAccessibleInterface*>(callbackQAccessibleTableInterface_CellAt(const_cast<void*>(static_cast<const void*>(this)), row, column)); };
QAccessibleInterface * summary() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleTableInterface_Summary(const_cast<void*>(static_cast<const void*>(this)))); };
QList<QAccessibleInterface *> selectedCells() const { return ({ QList<QAccessibleInterface *>* tmpP = static_cast<QList<QAccessibleInterface *>*>(callbackQAccessibleTableInterface_SelectedCells(const_cast<void*>(static_cast<const void*>(this)))); QList<QAccessibleInterface *> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
QList<int> selectedColumns() const { return ({ QList<int>* tmpP = static_cast<QList<int>*>(callbackQAccessibleTableInterface_SelectedColumns(const_cast<void*>(static_cast<const void*>(this)))); QList<int> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
QList<int> selectedRows() const { return ({ QList<int>* tmpP = static_cast<QList<int>*>(callbackQAccessibleTableInterface_SelectedRows(const_cast<void*>(static_cast<const void*>(this)))); QList<int> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
QString columnDescription(int column) const { return ({ QtGui_PackedString tempVal = callbackQAccessibleTableInterface_ColumnDescription(const_cast<void*>(static_cast<const void*>(this)), column); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
QString rowDescription(int row) const { return ({ QtGui_PackedString tempVal = callbackQAccessibleTableInterface_RowDescription(const_cast<void*>(static_cast<const void*>(this)), row); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
bool isColumnSelected(int column) const { return callbackQAccessibleTableInterface_IsColumnSelected(const_cast<void*>(static_cast<const void*>(this)), column) != 0; };
bool isRowSelected(int row) const { return callbackQAccessibleTableInterface_IsRowSelected(const_cast<void*>(static_cast<const void*>(this)), row) != 0; };
int columnCount() const { return callbackQAccessibleTableInterface_ColumnCount(const_cast<void*>(static_cast<const void*>(this))); };
int rowCount() const { return callbackQAccessibleTableInterface_RowCount(const_cast<void*>(static_cast<const void*>(this))); };
int selectedCellCount() const { return callbackQAccessibleTableInterface_SelectedCellCount(const_cast<void*>(static_cast<const void*>(this))); };
int selectedColumnCount() const { return callbackQAccessibleTableInterface_SelectedColumnCount(const_cast<void*>(static_cast<const void*>(this))); };
int selectedRowCount() const { return callbackQAccessibleTableInterface_SelectedRowCount(const_cast<void*>(static_cast<const void*>(this))); };
};
char QAccessibleTableInterface_SelectColumn(void* ptr, int column)
{
return static_cast<QAccessibleTableInterface*>(ptr)->selectColumn(column);
}
char QAccessibleTableInterface_SelectRow(void* ptr, int row)
{
return static_cast<QAccessibleTableInterface*>(ptr)->selectRow(row);
}
char QAccessibleTableInterface_UnselectColumn(void* ptr, int column)
{
return static_cast<QAccessibleTableInterface*>(ptr)->unselectColumn(column);
}
char QAccessibleTableInterface_UnselectRow(void* ptr, int row)
{
return static_cast<QAccessibleTableInterface*>(ptr)->unselectRow(row);
}
void QAccessibleTableInterface_ModelChange(void* ptr, void* event)
{
static_cast<QAccessibleTableInterface*>(ptr)->modelChange(static_cast<QAccessibleTableModelChangeEvent*>(event));
}
void QAccessibleTableInterface_DestroyQAccessibleTableInterface(void* ptr)
{
static_cast<QAccessibleTableInterface*>(ptr)->~QAccessibleTableInterface();
}
void QAccessibleTableInterface_DestroyQAccessibleTableInterfaceDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QAccessibleTableInterface_Caption(void* ptr)
{
return static_cast<QAccessibleTableInterface*>(ptr)->caption();
}
void* QAccessibleTableInterface_CellAt(void* ptr, int row, int column)
{
return static_cast<QAccessibleTableInterface*>(ptr)->cellAt(row, column);
}
void* QAccessibleTableInterface_Summary(void* ptr)
{
return static_cast<QAccessibleTableInterface*>(ptr)->summary();
}
struct QtGui_PackedList QAccessibleTableInterface_SelectedCells(void* ptr)
{
return ({ QList<QAccessibleInterface *>* tmpValue = new QList<QAccessibleInterface *>(static_cast<QAccessibleTableInterface*>(ptr)->selectedCells()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedList QAccessibleTableInterface_SelectedColumns(void* ptr)
{
return ({ QList<int>* tmpValue = new QList<int>(static_cast<QAccessibleTableInterface*>(ptr)->selectedColumns()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedList QAccessibleTableInterface_SelectedRows(void* ptr)
{
return ({ QList<int>* tmpValue = new QList<int>(static_cast<QAccessibleTableInterface*>(ptr)->selectedRows()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedString QAccessibleTableInterface_ColumnDescription(void* ptr, int column)
{
return ({ QByteArray t31bac7 = static_cast<QAccessibleTableInterface*>(ptr)->columnDescription(column).toUtf8(); QtGui_PackedString { const_cast<char*>(t31bac7.prepend("WHITESPACE").constData()+10), t31bac7.size()-10 }; });
}
struct QtGui_PackedString QAccessibleTableInterface_RowDescription(void* ptr, int row)
{
return ({ QByteArray t5db49c = static_cast<QAccessibleTableInterface*>(ptr)->rowDescription(row).toUtf8(); QtGui_PackedString { const_cast<char*>(t5db49c.prepend("WHITESPACE").constData()+10), t5db49c.size()-10 }; });
}
char QAccessibleTableInterface_IsColumnSelected(void* ptr, int column)
{
return static_cast<QAccessibleTableInterface*>(ptr)->isColumnSelected(column);
}
char QAccessibleTableInterface_IsRowSelected(void* ptr, int row)
{
return static_cast<QAccessibleTableInterface*>(ptr)->isRowSelected(row);
}
int QAccessibleTableInterface_ColumnCount(void* ptr)
{
return static_cast<QAccessibleTableInterface*>(ptr)->columnCount();
}
int QAccessibleTableInterface_RowCount(void* ptr)
{
return static_cast<QAccessibleTableInterface*>(ptr)->rowCount();
}
int QAccessibleTableInterface_SelectedCellCount(void* ptr)
{
return static_cast<QAccessibleTableInterface*>(ptr)->selectedCellCount();
}
int QAccessibleTableInterface_SelectedColumnCount(void* ptr)
{
return static_cast<QAccessibleTableInterface*>(ptr)->selectedColumnCount();
}
int QAccessibleTableInterface_SelectedRowCount(void* ptr)
{
return static_cast<QAccessibleTableInterface*>(ptr)->selectedRowCount();
}
void* QAccessibleTableInterface___selectedCells_atList(void* ptr, int i)
{
return ({QAccessibleInterface * tmp = static_cast<QList<QAccessibleInterface *>*>(ptr)->at(i); if (i == static_cast<QList<QAccessibleInterface *>*>(ptr)->size()-1) { static_cast<QList<QAccessibleInterface *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QAccessibleTableInterface___selectedCells_setList(void* ptr, void* i)
{
static_cast<QList<QAccessibleInterface *>*>(ptr)->append(static_cast<QAccessibleInterface*>(i));
}
void* QAccessibleTableInterface___selectedCells_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QAccessibleInterface *>();
}
int QAccessibleTableInterface___selectedColumns_atList(void* ptr, int i)
{
return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QAccessibleTableInterface___selectedColumns_setList(void* ptr, int i)
{
static_cast<QList<int>*>(ptr)->append(i);
}
void* QAccessibleTableInterface___selectedColumns_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<int>();
}
int QAccessibleTableInterface___selectedRows_atList(void* ptr, int i)
{
return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QAccessibleTableInterface___selectedRows_setList(void* ptr, int i)
{
static_cast<QList<int>*>(ptr)->append(i);
}
void* QAccessibleTableInterface___selectedRows_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<int>();
}
class MyQAccessibleTableModelChangeEvent: public QAccessibleTableModelChangeEvent
{
public:
MyQAccessibleTableModelChangeEvent(QAccessibleInterface *iface, QAccessibleTableModelChangeEvent::ModelChangeType changeType) : QAccessibleTableModelChangeEvent(iface, changeType) {};
MyQAccessibleTableModelChangeEvent(QObject *object, QAccessibleTableModelChangeEvent::ModelChangeType changeType) : QAccessibleTableModelChangeEvent(object, changeType) {};
QAccessibleInterface * accessibleInterface() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleEvent_AccessibleInterface(const_cast<void*>(static_cast<const void*>(this)))); };
};
void* QAccessibleTableModelChangeEvent_NewQAccessibleTableModelChangeEvent2(void* iface, long long changeType)
{
if (dynamic_cast<QAccessibleWidget*>(static_cast<QAccessibleInterface*>(iface))) {
return new MyQAccessibleTableModelChangeEvent(static_cast<QAccessibleWidget*>(iface), static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(changeType));
} else {
return new MyQAccessibleTableModelChangeEvent(static_cast<QAccessibleInterface*>(iface), static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(changeType));
}
}
void* QAccessibleTableModelChangeEvent_NewQAccessibleTableModelChangeEvent(void* object, long long changeType)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTableModelChangeEvent(static_cast<QCameraImageCapture*>(object), static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(changeType));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTableModelChangeEvent(static_cast<QDBusPendingCallWatcher*>(object), static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(changeType));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTableModelChangeEvent(static_cast<QExtensionFactory*>(object), static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(changeType));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTableModelChangeEvent(static_cast<QExtensionManager*>(object), static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(changeType));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTableModelChangeEvent(static_cast<QGraphicsObject*>(object), static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(changeType));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTableModelChangeEvent(static_cast<QGraphicsWidget*>(object), static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(changeType));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTableModelChangeEvent(static_cast<QLayout*>(object), static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(changeType));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTableModelChangeEvent(static_cast<QMediaPlaylist*>(object), static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(changeType));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTableModelChangeEvent(static_cast<QMediaRecorder*>(object), static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(changeType));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTableModelChangeEvent(static_cast<QOffscreenSurface*>(object), static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(changeType));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTableModelChangeEvent(static_cast<QPaintDeviceWindow*>(object), static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(changeType));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTableModelChangeEvent(static_cast<QPdfWriter*>(object), static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(changeType));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTableModelChangeEvent(static_cast<QQuickItem*>(object), static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(changeType));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTableModelChangeEvent(static_cast<QRadioData*>(object), static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(changeType));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTableModelChangeEvent(static_cast<QWidget*>(object), static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(changeType));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTableModelChangeEvent(static_cast<QWindow*>(object), static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(changeType));
} else {
return new MyQAccessibleTableModelChangeEvent(static_cast<QObject*>(object), static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(changeType));
}
}
void QAccessibleTableModelChangeEvent_SetFirstColumn(void* ptr, int column)
{
static_cast<QAccessibleTableModelChangeEvent*>(ptr)->setFirstColumn(column);
}
void QAccessibleTableModelChangeEvent_SetFirstRow(void* ptr, int row)
{
static_cast<QAccessibleTableModelChangeEvent*>(ptr)->setFirstRow(row);
}
void QAccessibleTableModelChangeEvent_SetLastColumn(void* ptr, int column)
{
static_cast<QAccessibleTableModelChangeEvent*>(ptr)->setLastColumn(column);
}
void QAccessibleTableModelChangeEvent_SetLastRow(void* ptr, int row)
{
static_cast<QAccessibleTableModelChangeEvent*>(ptr)->setLastRow(row);
}
void QAccessibleTableModelChangeEvent_SetModelChangeType(void* ptr, long long changeType)
{
static_cast<QAccessibleTableModelChangeEvent*>(ptr)->setModelChangeType(static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(changeType));
}
long long QAccessibleTableModelChangeEvent_ModelChangeType(void* ptr)
{
return static_cast<QAccessibleTableModelChangeEvent*>(ptr)->modelChangeType();
}
int QAccessibleTableModelChangeEvent_FirstColumn(void* ptr)
{
return static_cast<QAccessibleTableModelChangeEvent*>(ptr)->firstColumn();
}
int QAccessibleTableModelChangeEvent_FirstRow(void* ptr)
{
return static_cast<QAccessibleTableModelChangeEvent*>(ptr)->firstRow();
}
int QAccessibleTableModelChangeEvent_LastColumn(void* ptr)
{
return static_cast<QAccessibleTableModelChangeEvent*>(ptr)->lastColumn();
}
int QAccessibleTableModelChangeEvent_LastRow(void* ptr)
{
return static_cast<QAccessibleTableModelChangeEvent*>(ptr)->lastRow();
}
int QAccessibleTableModelChangeEvent_M_firstColumn(void* ptr)
{
return static_cast<QAccessibleTableModelChangeEvent*>(ptr)->m_firstColumn;
}
void QAccessibleTableModelChangeEvent_SetM_firstColumn(void* ptr, int vin)
{
static_cast<QAccessibleTableModelChangeEvent*>(ptr)->m_firstColumn = vin;
}
int QAccessibleTableModelChangeEvent_M_firstRow(void* ptr)
{
return static_cast<QAccessibleTableModelChangeEvent*>(ptr)->m_firstRow;
}
void QAccessibleTableModelChangeEvent_SetM_firstRow(void* ptr, int vin)
{
static_cast<QAccessibleTableModelChangeEvent*>(ptr)->m_firstRow = vin;
}
int QAccessibleTableModelChangeEvent_M_lastColumn(void* ptr)
{
return static_cast<QAccessibleTableModelChangeEvent*>(ptr)->m_lastColumn;
}
void QAccessibleTableModelChangeEvent_SetM_lastColumn(void* ptr, int vin)
{
static_cast<QAccessibleTableModelChangeEvent*>(ptr)->m_lastColumn = vin;
}
int QAccessibleTableModelChangeEvent_M_lastRow(void* ptr)
{
return static_cast<QAccessibleTableModelChangeEvent*>(ptr)->m_lastRow;
}
void QAccessibleTableModelChangeEvent_SetM_lastRow(void* ptr, int vin)
{
static_cast<QAccessibleTableModelChangeEvent*>(ptr)->m_lastRow = vin;
}
long long QAccessibleTableModelChangeEvent_M_modelChangeType(void* ptr)
{
return static_cast<QAccessibleTableModelChangeEvent*>(ptr)->m_modelChangeType;
}
void QAccessibleTableModelChangeEvent_SetM_modelChangeType(void* ptr, long long vqa)
{
static_cast<QAccessibleTableModelChangeEvent*>(ptr)->m_modelChangeType = static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(vqa);
}
class MyQAccessibleTextCursorEvent: public QAccessibleTextCursorEvent
{
public:
MyQAccessibleTextCursorEvent(QAccessibleInterface *iface, int cursorPos) : QAccessibleTextCursorEvent(iface, cursorPos) {};
MyQAccessibleTextCursorEvent(QObject *object, int cursorPos) : QAccessibleTextCursorEvent(object, cursorPos) {};
QAccessibleInterface * accessibleInterface() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleEvent_AccessibleInterface(const_cast<void*>(static_cast<const void*>(this)))); };
};
void* QAccessibleTextCursorEvent_NewQAccessibleTextCursorEvent2(void* iface, int cursorPos)
{
if (dynamic_cast<QAccessibleWidget*>(static_cast<QAccessibleInterface*>(iface))) {
return new MyQAccessibleTextCursorEvent(static_cast<QAccessibleWidget*>(iface), cursorPos);
} else {
return new MyQAccessibleTextCursorEvent(static_cast<QAccessibleInterface*>(iface), cursorPos);
}
}
void* QAccessibleTextCursorEvent_NewQAccessibleTextCursorEvent(void* object, int cursorPos)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextCursorEvent(static_cast<QCameraImageCapture*>(object), cursorPos);
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextCursorEvent(static_cast<QDBusPendingCallWatcher*>(object), cursorPos);
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextCursorEvent(static_cast<QExtensionFactory*>(object), cursorPos);
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextCursorEvent(static_cast<QExtensionManager*>(object), cursorPos);
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextCursorEvent(static_cast<QGraphicsObject*>(object), cursorPos);
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextCursorEvent(static_cast<QGraphicsWidget*>(object), cursorPos);
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextCursorEvent(static_cast<QLayout*>(object), cursorPos);
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextCursorEvent(static_cast<QMediaPlaylist*>(object), cursorPos);
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextCursorEvent(static_cast<QMediaRecorder*>(object), cursorPos);
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextCursorEvent(static_cast<QOffscreenSurface*>(object), cursorPos);
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextCursorEvent(static_cast<QPaintDeviceWindow*>(object), cursorPos);
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextCursorEvent(static_cast<QPdfWriter*>(object), cursorPos);
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextCursorEvent(static_cast<QQuickItem*>(object), cursorPos);
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextCursorEvent(static_cast<QRadioData*>(object), cursorPos);
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextCursorEvent(static_cast<QWidget*>(object), cursorPos);
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextCursorEvent(static_cast<QWindow*>(object), cursorPos);
} else {
return new MyQAccessibleTextCursorEvent(static_cast<QObject*>(object), cursorPos);
}
}
void QAccessibleTextCursorEvent_SetCursorPosition(void* ptr, int position)
{
static_cast<QAccessibleTextCursorEvent*>(ptr)->setCursorPosition(position);
}
int QAccessibleTextCursorEvent_CursorPosition(void* ptr)
{
return static_cast<QAccessibleTextCursorEvent*>(ptr)->cursorPosition();
}
int QAccessibleTextCursorEvent_M_cursorPosition(void* ptr)
{
return static_cast<QAccessibleTextCursorEvent*>(ptr)->m_cursorPosition;
}
void QAccessibleTextCursorEvent_SetM_cursorPosition(void* ptr, int vin)
{
static_cast<QAccessibleTextCursorEvent*>(ptr)->m_cursorPosition = vin;
}
class MyQAccessibleTextInsertEvent: public QAccessibleTextInsertEvent
{
public:
MyQAccessibleTextInsertEvent(QAccessibleInterface *iface, int position, const QString &text) : QAccessibleTextInsertEvent(iface, position, text) {};
MyQAccessibleTextInsertEvent(QObject *object, int position, const QString &text) : QAccessibleTextInsertEvent(object, position, text) {};
QAccessibleInterface * accessibleInterface() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleEvent_AccessibleInterface(const_cast<void*>(static_cast<const void*>(this)))); };
};
void* QAccessibleTextInsertEvent_NewQAccessibleTextInsertEvent2(void* iface, int position, struct QtGui_PackedString text)
{
if (dynamic_cast<QAccessibleWidget*>(static_cast<QAccessibleInterface*>(iface))) {
return new MyQAccessibleTextInsertEvent(static_cast<QAccessibleWidget*>(iface), position, QString::fromUtf8(text.data, text.len));
} else {
return new MyQAccessibleTextInsertEvent(static_cast<QAccessibleInterface*>(iface), position, QString::fromUtf8(text.data, text.len));
}
}
void* QAccessibleTextInsertEvent_NewQAccessibleTextInsertEvent(void* object, int position, struct QtGui_PackedString text)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextInsertEvent(static_cast<QCameraImageCapture*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextInsertEvent(static_cast<QDBusPendingCallWatcher*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextInsertEvent(static_cast<QExtensionFactory*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextInsertEvent(static_cast<QExtensionManager*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextInsertEvent(static_cast<QGraphicsObject*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextInsertEvent(static_cast<QGraphicsWidget*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextInsertEvent(static_cast<QLayout*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextInsertEvent(static_cast<QMediaPlaylist*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextInsertEvent(static_cast<QMediaRecorder*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextInsertEvent(static_cast<QOffscreenSurface*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextInsertEvent(static_cast<QPaintDeviceWindow*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextInsertEvent(static_cast<QPdfWriter*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextInsertEvent(static_cast<QQuickItem*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextInsertEvent(static_cast<QRadioData*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextInsertEvent(static_cast<QWidget*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextInsertEvent(static_cast<QWindow*>(object), position, QString::fromUtf8(text.data, text.len));
} else {
return new MyQAccessibleTextInsertEvent(static_cast<QObject*>(object), position, QString::fromUtf8(text.data, text.len));
}
}
struct QtGui_PackedString QAccessibleTextInsertEvent_TextInserted(void* ptr)
{
return ({ QByteArray te79f7b = static_cast<QAccessibleTextInsertEvent*>(ptr)->textInserted().toUtf8(); QtGui_PackedString { const_cast<char*>(te79f7b.prepend("WHITESPACE").constData()+10), te79f7b.size()-10 }; });
}
int QAccessibleTextInsertEvent_ChangePosition(void* ptr)
{
return static_cast<QAccessibleTextInsertEvent*>(ptr)->changePosition();
}
int QAccessibleTextInsertEvent_M_position(void* ptr)
{
return static_cast<QAccessibleTextInsertEvent*>(ptr)->m_position;
}
void QAccessibleTextInsertEvent_SetM_position(void* ptr, int vin)
{
static_cast<QAccessibleTextInsertEvent*>(ptr)->m_position = vin;
}
struct QtGui_PackedString QAccessibleTextInsertEvent_M_text(void* ptr)
{
return ({ QByteArray t1f901e = static_cast<QAccessibleTextInsertEvent*>(ptr)->m_text.toUtf8(); QtGui_PackedString { const_cast<char*>(t1f901e.prepend("WHITESPACE").constData()+10), t1f901e.size()-10 }; });
}
void QAccessibleTextInsertEvent_SetM_text(void* ptr, struct QtGui_PackedString vqs)
{
static_cast<QAccessibleTextInsertEvent*>(ptr)->m_text = QString::fromUtf8(vqs.data, vqs.len);
}
class MyQAccessibleTextInterface: public QAccessibleTextInterface
{
public:
void addSelection(int startOffset, int endOffset) { callbackQAccessibleTextInterface_AddSelection(this, startOffset, endOffset); };
void removeSelection(int selectionIndex) { callbackQAccessibleTextInterface_RemoveSelection(this, selectionIndex); };
void scrollToSubstring(int startIndex, int endIndex) { callbackQAccessibleTextInterface_ScrollToSubstring(this, startIndex, endIndex); };
void setCursorPosition(int position) { callbackQAccessibleTextInterface_SetCursorPosition(this, position); };
void setSelection(int selectionIndex, int startOffset, int endOffset) { callbackQAccessibleTextInterface_SetSelection(this, selectionIndex, startOffset, endOffset); };
~MyQAccessibleTextInterface() { callbackQAccessibleTextInterface_DestroyQAccessibleTextInterface(this); };
QRect characterRect(int offset) const { return *static_cast<QRect*>(callbackQAccessibleTextInterface_CharacterRect(const_cast<void*>(static_cast<const void*>(this)), offset)); };
QString text(int startOffset, int endOffset) const { return ({ QtGui_PackedString tempVal = callbackQAccessibleTextInterface_Text(const_cast<void*>(static_cast<const void*>(this)), startOffset, endOffset); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
QString textAfterOffset(int offset, QAccessible::TextBoundaryType boundaryType, int * startOffset, int * endOffset) const { return ({ QtGui_PackedString tempVal = callbackQAccessibleTextInterface_TextAfterOffset(const_cast<void*>(static_cast<const void*>(this)), offset, boundaryType, *startOffset, *endOffset); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
QString textAtOffset(int offset, QAccessible::TextBoundaryType boundaryType, int * startOffset, int * endOffset) const { return ({ QtGui_PackedString tempVal = callbackQAccessibleTextInterface_TextAtOffset(const_cast<void*>(static_cast<const void*>(this)), offset, boundaryType, *startOffset, *endOffset); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
QString textBeforeOffset(int offset, QAccessible::TextBoundaryType boundaryType, int * startOffset, int * endOffset) const { return ({ QtGui_PackedString tempVal = callbackQAccessibleTextInterface_TextBeforeOffset(const_cast<void*>(static_cast<const void*>(this)), offset, boundaryType, *startOffset, *endOffset); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
int characterCount() const { return callbackQAccessibleTextInterface_CharacterCount(const_cast<void*>(static_cast<const void*>(this))); };
int cursorPosition() const { return callbackQAccessibleTextInterface_CursorPosition(const_cast<void*>(static_cast<const void*>(this))); };
int offsetAtPoint(const QPoint & point) const { return callbackQAccessibleTextInterface_OffsetAtPoint(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPoint*>(&point)); };
int selectionCount() const { return callbackQAccessibleTextInterface_SelectionCount(const_cast<void*>(static_cast<const void*>(this))); };
void selection(int selectionIndex, int * startOffset, int * endOffset) const { callbackQAccessibleTextInterface_Selection(const_cast<void*>(static_cast<const void*>(this)), selectionIndex, *startOffset, *endOffset); };
};
void QAccessibleTextInterface_AddSelection(void* ptr, int startOffset, int endOffset)
{
static_cast<QAccessibleTextInterface*>(ptr)->addSelection(startOffset, endOffset);
}
void QAccessibleTextInterface_RemoveSelection(void* ptr, int selectionIndex)
{
static_cast<QAccessibleTextInterface*>(ptr)->removeSelection(selectionIndex);
}
void QAccessibleTextInterface_ScrollToSubstring(void* ptr, int startIndex, int endIndex)
{
static_cast<QAccessibleTextInterface*>(ptr)->scrollToSubstring(startIndex, endIndex);
}
void QAccessibleTextInterface_SetCursorPosition(void* ptr, int position)
{
static_cast<QAccessibleTextInterface*>(ptr)->setCursorPosition(position);
}
void QAccessibleTextInterface_SetSelection(void* ptr, int selectionIndex, int startOffset, int endOffset)
{
static_cast<QAccessibleTextInterface*>(ptr)->setSelection(selectionIndex, startOffset, endOffset);
}
void QAccessibleTextInterface_DestroyQAccessibleTextInterface(void* ptr)
{
static_cast<QAccessibleTextInterface*>(ptr)->~QAccessibleTextInterface();
}
void QAccessibleTextInterface_DestroyQAccessibleTextInterfaceDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QAccessibleTextInterface_CharacterRect(void* ptr, int offset)
{
return ({ QRect tmpValue = static_cast<QAccessibleTextInterface*>(ptr)->characterRect(offset); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
struct QtGui_PackedString QAccessibleTextInterface_Text(void* ptr, int startOffset, int endOffset)
{
return ({ QByteArray td7097f = static_cast<QAccessibleTextInterface*>(ptr)->text(startOffset, endOffset).toUtf8(); QtGui_PackedString { const_cast<char*>(td7097f.prepend("WHITESPACE").constData()+10), td7097f.size()-10 }; });
}
struct QtGui_PackedString QAccessibleTextInterface_TextAfterOffset(void* ptr, int offset, long long boundaryType, int startOffset, int endOffset)
{
return ({ QByteArray t56e464 = static_cast<QAccessibleTextInterface*>(ptr)->textAfterOffset(offset, static_cast<QAccessible::TextBoundaryType>(boundaryType), &startOffset, &endOffset).toUtf8(); QtGui_PackedString { const_cast<char*>(t56e464.prepend("WHITESPACE").constData()+10), t56e464.size()-10 }; });
}
struct QtGui_PackedString QAccessibleTextInterface_TextAfterOffsetDefault(void* ptr, int offset, long long boundaryType, int startOffset, int endOffset)
{
return ({ QByteArray t495d09 = static_cast<QAccessibleTextInterface*>(ptr)->QAccessibleTextInterface::textAfterOffset(offset, static_cast<QAccessible::TextBoundaryType>(boundaryType), &startOffset, &endOffset).toUtf8(); QtGui_PackedString { const_cast<char*>(t495d09.prepend("WHITESPACE").constData()+10), t495d09.size()-10 }; });
}
struct QtGui_PackedString QAccessibleTextInterface_TextAtOffset(void* ptr, int offset, long long boundaryType, int startOffset, int endOffset)
{
return ({ QByteArray t01d82d = static_cast<QAccessibleTextInterface*>(ptr)->textAtOffset(offset, static_cast<QAccessible::TextBoundaryType>(boundaryType), &startOffset, &endOffset).toUtf8(); QtGui_PackedString { const_cast<char*>(t01d82d.prepend("WHITESPACE").constData()+10), t01d82d.size()-10 }; });
}
struct QtGui_PackedString QAccessibleTextInterface_TextAtOffsetDefault(void* ptr, int offset, long long boundaryType, int startOffset, int endOffset)
{
return ({ QByteArray tb855b8 = static_cast<QAccessibleTextInterface*>(ptr)->QAccessibleTextInterface::textAtOffset(offset, static_cast<QAccessible::TextBoundaryType>(boundaryType), &startOffset, &endOffset).toUtf8(); QtGui_PackedString { const_cast<char*>(tb855b8.prepend("WHITESPACE").constData()+10), tb855b8.size()-10 }; });
}
struct QtGui_PackedString QAccessibleTextInterface_TextBeforeOffset(void* ptr, int offset, long long boundaryType, int startOffset, int endOffset)
{
return ({ QByteArray tde81ca = static_cast<QAccessibleTextInterface*>(ptr)->textBeforeOffset(offset, static_cast<QAccessible::TextBoundaryType>(boundaryType), &startOffset, &endOffset).toUtf8(); QtGui_PackedString { const_cast<char*>(tde81ca.prepend("WHITESPACE").constData()+10), tde81ca.size()-10 }; });
}
struct QtGui_PackedString QAccessibleTextInterface_TextBeforeOffsetDefault(void* ptr, int offset, long long boundaryType, int startOffset, int endOffset)
{
return ({ QByteArray tb76866 = static_cast<QAccessibleTextInterface*>(ptr)->QAccessibleTextInterface::textBeforeOffset(offset, static_cast<QAccessible::TextBoundaryType>(boundaryType), &startOffset, &endOffset).toUtf8(); QtGui_PackedString { const_cast<char*>(tb76866.prepend("WHITESPACE").constData()+10), tb76866.size()-10 }; });
}
int QAccessibleTextInterface_CharacterCount(void* ptr)
{
return static_cast<QAccessibleTextInterface*>(ptr)->characterCount();
}
int QAccessibleTextInterface_CursorPosition(void* ptr)
{
return static_cast<QAccessibleTextInterface*>(ptr)->cursorPosition();
}
int QAccessibleTextInterface_OffsetAtPoint(void* ptr, void* point)
{
return static_cast<QAccessibleTextInterface*>(ptr)->offsetAtPoint(*static_cast<QPoint*>(point));
}
int QAccessibleTextInterface_SelectionCount(void* ptr)
{
return static_cast<QAccessibleTextInterface*>(ptr)->selectionCount();
}
void QAccessibleTextInterface_Selection(void* ptr, int selectionIndex, int startOffset, int endOffset)
{
static_cast<QAccessibleTextInterface*>(ptr)->selection(selectionIndex, &startOffset, &endOffset);
}
class MyQAccessibleTextRemoveEvent: public QAccessibleTextRemoveEvent
{
public:
MyQAccessibleTextRemoveEvent(QAccessibleInterface *iface, int position, const QString &text) : QAccessibleTextRemoveEvent(iface, position, text) {};
MyQAccessibleTextRemoveEvent(QObject *object, int position, const QString &text) : QAccessibleTextRemoveEvent(object, position, text) {};
QAccessibleInterface * accessibleInterface() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleEvent_AccessibleInterface(const_cast<void*>(static_cast<const void*>(this)))); };
};
void* QAccessibleTextRemoveEvent_NewQAccessibleTextRemoveEvent2(void* iface, int position, struct QtGui_PackedString text)
{
if (dynamic_cast<QAccessibleWidget*>(static_cast<QAccessibleInterface*>(iface))) {
return new MyQAccessibleTextRemoveEvent(static_cast<QAccessibleWidget*>(iface), position, QString::fromUtf8(text.data, text.len));
} else {
return new MyQAccessibleTextRemoveEvent(static_cast<QAccessibleInterface*>(iface), position, QString::fromUtf8(text.data, text.len));
}
}
void* QAccessibleTextRemoveEvent_NewQAccessibleTextRemoveEvent(void* object, int position, struct QtGui_PackedString text)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextRemoveEvent(static_cast<QCameraImageCapture*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextRemoveEvent(static_cast<QDBusPendingCallWatcher*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextRemoveEvent(static_cast<QExtensionFactory*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextRemoveEvent(static_cast<QExtensionManager*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextRemoveEvent(static_cast<QGraphicsObject*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextRemoveEvent(static_cast<QGraphicsWidget*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextRemoveEvent(static_cast<QLayout*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextRemoveEvent(static_cast<QMediaPlaylist*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextRemoveEvent(static_cast<QMediaRecorder*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextRemoveEvent(static_cast<QOffscreenSurface*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextRemoveEvent(static_cast<QPaintDeviceWindow*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextRemoveEvent(static_cast<QPdfWriter*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextRemoveEvent(static_cast<QQuickItem*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextRemoveEvent(static_cast<QRadioData*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextRemoveEvent(static_cast<QWidget*>(object), position, QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextRemoveEvent(static_cast<QWindow*>(object), position, QString::fromUtf8(text.data, text.len));
} else {
return new MyQAccessibleTextRemoveEvent(static_cast<QObject*>(object), position, QString::fromUtf8(text.data, text.len));
}
}
struct QtGui_PackedString QAccessibleTextRemoveEvent_TextRemoved(void* ptr)
{
return ({ QByteArray t7bb24c = static_cast<QAccessibleTextRemoveEvent*>(ptr)->textRemoved().toUtf8(); QtGui_PackedString { const_cast<char*>(t7bb24c.prepend("WHITESPACE").constData()+10), t7bb24c.size()-10 }; });
}
int QAccessibleTextRemoveEvent_ChangePosition(void* ptr)
{
return static_cast<QAccessibleTextRemoveEvent*>(ptr)->changePosition();
}
int QAccessibleTextRemoveEvent_M_position(void* ptr)
{
return static_cast<QAccessibleTextRemoveEvent*>(ptr)->m_position;
}
void QAccessibleTextRemoveEvent_SetM_position(void* ptr, int vin)
{
static_cast<QAccessibleTextRemoveEvent*>(ptr)->m_position = vin;
}
struct QtGui_PackedString QAccessibleTextRemoveEvent_M_text(void* ptr)
{
return ({ QByteArray tff23be = static_cast<QAccessibleTextRemoveEvent*>(ptr)->m_text.toUtf8(); QtGui_PackedString { const_cast<char*>(tff23be.prepend("WHITESPACE").constData()+10), tff23be.size()-10 }; });
}
void QAccessibleTextRemoveEvent_SetM_text(void* ptr, struct QtGui_PackedString vqs)
{
static_cast<QAccessibleTextRemoveEvent*>(ptr)->m_text = QString::fromUtf8(vqs.data, vqs.len);
}
class MyQAccessibleTextSelectionEvent: public QAccessibleTextSelectionEvent
{
public:
MyQAccessibleTextSelectionEvent(QAccessibleInterface *iface, int start, int end) : QAccessibleTextSelectionEvent(iface, start, end) {};
MyQAccessibleTextSelectionEvent(QObject *object, int start, int end) : QAccessibleTextSelectionEvent(object, start, end) {};
QAccessibleInterface * accessibleInterface() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleEvent_AccessibleInterface(const_cast<void*>(static_cast<const void*>(this)))); };
};
void* QAccessibleTextSelectionEvent_NewQAccessibleTextSelectionEvent2(void* iface, int start, int end)
{
if (dynamic_cast<QAccessibleWidget*>(static_cast<QAccessibleInterface*>(iface))) {
return new MyQAccessibleTextSelectionEvent(static_cast<QAccessibleWidget*>(iface), start, end);
} else {
return new MyQAccessibleTextSelectionEvent(static_cast<QAccessibleInterface*>(iface), start, end);
}
}
void* QAccessibleTextSelectionEvent_NewQAccessibleTextSelectionEvent(void* object, int start, int end)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextSelectionEvent(static_cast<QCameraImageCapture*>(object), start, end);
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextSelectionEvent(static_cast<QDBusPendingCallWatcher*>(object), start, end);
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextSelectionEvent(static_cast<QExtensionFactory*>(object), start, end);
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextSelectionEvent(static_cast<QExtensionManager*>(object), start, end);
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextSelectionEvent(static_cast<QGraphicsObject*>(object), start, end);
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextSelectionEvent(static_cast<QGraphicsWidget*>(object), start, end);
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextSelectionEvent(static_cast<QLayout*>(object), start, end);
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextSelectionEvent(static_cast<QMediaPlaylist*>(object), start, end);
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextSelectionEvent(static_cast<QMediaRecorder*>(object), start, end);
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextSelectionEvent(static_cast<QOffscreenSurface*>(object), start, end);
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextSelectionEvent(static_cast<QPaintDeviceWindow*>(object), start, end);
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextSelectionEvent(static_cast<QPdfWriter*>(object), start, end);
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextSelectionEvent(static_cast<QQuickItem*>(object), start, end);
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextSelectionEvent(static_cast<QRadioData*>(object), start, end);
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextSelectionEvent(static_cast<QWidget*>(object), start, end);
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextSelectionEvent(static_cast<QWindow*>(object), start, end);
} else {
return new MyQAccessibleTextSelectionEvent(static_cast<QObject*>(object), start, end);
}
}
void QAccessibleTextSelectionEvent_SetSelection(void* ptr, int start, int end)
{
static_cast<QAccessibleTextSelectionEvent*>(ptr)->setSelection(start, end);
}
int QAccessibleTextSelectionEvent_SelectionEnd(void* ptr)
{
return static_cast<QAccessibleTextSelectionEvent*>(ptr)->selectionEnd();
}
int QAccessibleTextSelectionEvent_SelectionStart(void* ptr)
{
return static_cast<QAccessibleTextSelectionEvent*>(ptr)->selectionStart();
}
int QAccessibleTextSelectionEvent_M_selectionEnd(void* ptr)
{
return static_cast<QAccessibleTextSelectionEvent*>(ptr)->m_selectionEnd;
}
void QAccessibleTextSelectionEvent_SetM_selectionEnd(void* ptr, int vin)
{
static_cast<QAccessibleTextSelectionEvent*>(ptr)->m_selectionEnd = vin;
}
int QAccessibleTextSelectionEvent_M_selectionStart(void* ptr)
{
return static_cast<QAccessibleTextSelectionEvent*>(ptr)->m_selectionStart;
}
void QAccessibleTextSelectionEvent_SetM_selectionStart(void* ptr, int vin)
{
static_cast<QAccessibleTextSelectionEvent*>(ptr)->m_selectionStart = vin;
}
class MyQAccessibleTextUpdateEvent: public QAccessibleTextUpdateEvent
{
public:
MyQAccessibleTextUpdateEvent(QAccessibleInterface *iface, int position, const QString &oldText, const QString &text) : QAccessibleTextUpdateEvent(iface, position, oldText, text) {};
MyQAccessibleTextUpdateEvent(QObject *object, int position, const QString &oldText, const QString &text) : QAccessibleTextUpdateEvent(object, position, oldText, text) {};
QAccessibleInterface * accessibleInterface() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleEvent_AccessibleInterface(const_cast<void*>(static_cast<const void*>(this)))); };
};
void* QAccessibleTextUpdateEvent_NewQAccessibleTextUpdateEvent2(void* iface, int position, struct QtGui_PackedString oldText, struct QtGui_PackedString text)
{
if (dynamic_cast<QAccessibleWidget*>(static_cast<QAccessibleInterface*>(iface))) {
return new MyQAccessibleTextUpdateEvent(static_cast<QAccessibleWidget*>(iface), position, QString::fromUtf8(oldText.data, oldText.len), QString::fromUtf8(text.data, text.len));
} else {
return new MyQAccessibleTextUpdateEvent(static_cast<QAccessibleInterface*>(iface), position, QString::fromUtf8(oldText.data, oldText.len), QString::fromUtf8(text.data, text.len));
}
}
void* QAccessibleTextUpdateEvent_NewQAccessibleTextUpdateEvent(void* object, int position, struct QtGui_PackedString oldText, struct QtGui_PackedString text)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextUpdateEvent(static_cast<QCameraImageCapture*>(object), position, QString::fromUtf8(oldText.data, oldText.len), QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextUpdateEvent(static_cast<QDBusPendingCallWatcher*>(object), position, QString::fromUtf8(oldText.data, oldText.len), QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextUpdateEvent(static_cast<QExtensionFactory*>(object), position, QString::fromUtf8(oldText.data, oldText.len), QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextUpdateEvent(static_cast<QExtensionManager*>(object), position, QString::fromUtf8(oldText.data, oldText.len), QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextUpdateEvent(static_cast<QGraphicsObject*>(object), position, QString::fromUtf8(oldText.data, oldText.len), QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextUpdateEvent(static_cast<QGraphicsWidget*>(object), position, QString::fromUtf8(oldText.data, oldText.len), QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextUpdateEvent(static_cast<QLayout*>(object), position, QString::fromUtf8(oldText.data, oldText.len), QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextUpdateEvent(static_cast<QMediaPlaylist*>(object), position, QString::fromUtf8(oldText.data, oldText.len), QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextUpdateEvent(static_cast<QMediaRecorder*>(object), position, QString::fromUtf8(oldText.data, oldText.len), QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextUpdateEvent(static_cast<QOffscreenSurface*>(object), position, QString::fromUtf8(oldText.data, oldText.len), QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextUpdateEvent(static_cast<QPaintDeviceWindow*>(object), position, QString::fromUtf8(oldText.data, oldText.len), QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextUpdateEvent(static_cast<QPdfWriter*>(object), position, QString::fromUtf8(oldText.data, oldText.len), QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextUpdateEvent(static_cast<QQuickItem*>(object), position, QString::fromUtf8(oldText.data, oldText.len), QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextUpdateEvent(static_cast<QRadioData*>(object), position, QString::fromUtf8(oldText.data, oldText.len), QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextUpdateEvent(static_cast<QWidget*>(object), position, QString::fromUtf8(oldText.data, oldText.len), QString::fromUtf8(text.data, text.len));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(object))) {
return new MyQAccessibleTextUpdateEvent(static_cast<QWindow*>(object), position, QString::fromUtf8(oldText.data, oldText.len), QString::fromUtf8(text.data, text.len));
} else {
return new MyQAccessibleTextUpdateEvent(static_cast<QObject*>(object), position, QString::fromUtf8(oldText.data, oldText.len), QString::fromUtf8(text.data, text.len));
}
}
struct QtGui_PackedString QAccessibleTextUpdateEvent_TextInserted(void* ptr)
{
return ({ QByteArray t055e50 = static_cast<QAccessibleTextUpdateEvent*>(ptr)->textInserted().toUtf8(); QtGui_PackedString { const_cast<char*>(t055e50.prepend("WHITESPACE").constData()+10), t055e50.size()-10 }; });
}
struct QtGui_PackedString QAccessibleTextUpdateEvent_TextRemoved(void* ptr)
{
return ({ QByteArray t313b9a = static_cast<QAccessibleTextUpdateEvent*>(ptr)->textRemoved().toUtf8(); QtGui_PackedString { const_cast<char*>(t313b9a.prepend("WHITESPACE").constData()+10), t313b9a.size()-10 }; });
}
int QAccessibleTextUpdateEvent_ChangePosition(void* ptr)
{
return static_cast<QAccessibleTextUpdateEvent*>(ptr)->changePosition();
}
struct QtGui_PackedString QAccessibleTextUpdateEvent_M_oldText(void* ptr)
{
return ({ QByteArray t602ea6 = static_cast<QAccessibleTextUpdateEvent*>(ptr)->m_oldText.toUtf8(); QtGui_PackedString { const_cast<char*>(t602ea6.prepend("WHITESPACE").constData()+10), t602ea6.size()-10 }; });
}
void QAccessibleTextUpdateEvent_SetM_oldText(void* ptr, struct QtGui_PackedString vqs)
{
static_cast<QAccessibleTextUpdateEvent*>(ptr)->m_oldText = QString::fromUtf8(vqs.data, vqs.len);
}
int QAccessibleTextUpdateEvent_M_position(void* ptr)
{
return static_cast<QAccessibleTextUpdateEvent*>(ptr)->m_position;
}
void QAccessibleTextUpdateEvent_SetM_position(void* ptr, int vin)
{
static_cast<QAccessibleTextUpdateEvent*>(ptr)->m_position = vin;
}
struct QtGui_PackedString QAccessibleTextUpdateEvent_M_text(void* ptr)
{
return ({ QByteArray tf01ee2 = static_cast<QAccessibleTextUpdateEvent*>(ptr)->m_text.toUtf8(); QtGui_PackedString { const_cast<char*>(tf01ee2.prepend("WHITESPACE").constData()+10), tf01ee2.size()-10 }; });
}
void QAccessibleTextUpdateEvent_SetM_text(void* ptr, struct QtGui_PackedString vqs)
{
static_cast<QAccessibleTextUpdateEvent*>(ptr)->m_text = QString::fromUtf8(vqs.data, vqs.len);
}
class MyQAccessibleValueChangeEvent: public QAccessibleValueChangeEvent
{
public:
MyQAccessibleValueChangeEvent(QAccessibleInterface *iface, const QVariant &val) : QAccessibleValueChangeEvent(iface, val) {};
MyQAccessibleValueChangeEvent(QObject *object, const QVariant &value) : QAccessibleValueChangeEvent(object, value) {};
QAccessibleInterface * accessibleInterface() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleEvent_AccessibleInterface(const_cast<void*>(static_cast<const void*>(this)))); };
};
void* QAccessibleValueChangeEvent_NewQAccessibleValueChangeEvent2(void* iface, void* val)
{
if (dynamic_cast<QAccessibleWidget*>(static_cast<QAccessibleInterface*>(iface))) {
return new MyQAccessibleValueChangeEvent(static_cast<QAccessibleWidget*>(iface), *static_cast<QVariant*>(val));
} else {
return new MyQAccessibleValueChangeEvent(static_cast<QAccessibleInterface*>(iface), *static_cast<QVariant*>(val));
}
}
void* QAccessibleValueChangeEvent_NewQAccessibleValueChangeEvent(void* object, void* value)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
return new MyQAccessibleValueChangeEvent(static_cast<QCameraImageCapture*>(object), *static_cast<QVariant*>(value));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(object))) {
return new MyQAccessibleValueChangeEvent(static_cast<QDBusPendingCallWatcher*>(object), *static_cast<QVariant*>(value));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(object))) {
return new MyQAccessibleValueChangeEvent(static_cast<QExtensionFactory*>(object), *static_cast<QVariant*>(value));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(object))) {
return new MyQAccessibleValueChangeEvent(static_cast<QExtensionManager*>(object), *static_cast<QVariant*>(value));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(object))) {
return new MyQAccessibleValueChangeEvent(static_cast<QGraphicsObject*>(object), *static_cast<QVariant*>(value));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(object))) {
return new MyQAccessibleValueChangeEvent(static_cast<QGraphicsWidget*>(object), *static_cast<QVariant*>(value));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(object))) {
return new MyQAccessibleValueChangeEvent(static_cast<QLayout*>(object), *static_cast<QVariant*>(value));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
return new MyQAccessibleValueChangeEvent(static_cast<QMediaPlaylist*>(object), *static_cast<QVariant*>(value));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
return new MyQAccessibleValueChangeEvent(static_cast<QMediaRecorder*>(object), *static_cast<QVariant*>(value));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(object))) {
return new MyQAccessibleValueChangeEvent(static_cast<QOffscreenSurface*>(object), *static_cast<QVariant*>(value));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(object))) {
return new MyQAccessibleValueChangeEvent(static_cast<QPaintDeviceWindow*>(object), *static_cast<QVariant*>(value));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(object))) {
return new MyQAccessibleValueChangeEvent(static_cast<QPdfWriter*>(object), *static_cast<QVariant*>(value));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(object))) {
return new MyQAccessibleValueChangeEvent(static_cast<QQuickItem*>(object), *static_cast<QVariant*>(value));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
return new MyQAccessibleValueChangeEvent(static_cast<QRadioData*>(object), *static_cast<QVariant*>(value));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(object))) {
return new MyQAccessibleValueChangeEvent(static_cast<QWidget*>(object), *static_cast<QVariant*>(value));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(object))) {
return new MyQAccessibleValueChangeEvent(static_cast<QWindow*>(object), *static_cast<QVariant*>(value));
} else {
return new MyQAccessibleValueChangeEvent(static_cast<QObject*>(object), *static_cast<QVariant*>(value));
}
}
void QAccessibleValueChangeEvent_SetValue(void* ptr, void* value)
{
static_cast<QAccessibleValueChangeEvent*>(ptr)->setValue(*static_cast<QVariant*>(value));
}
void* QAccessibleValueChangeEvent_Value(void* ptr)
{
return new QVariant(static_cast<QAccessibleValueChangeEvent*>(ptr)->value());
}
void* QAccessibleValueChangeEvent_M_value(void* ptr)
{
return new QVariant(static_cast<QAccessibleValueChangeEvent*>(ptr)->m_value);
}
void QAccessibleValueChangeEvent_SetM_value(void* ptr, void* vqv)
{
static_cast<QAccessibleValueChangeEvent*>(ptr)->m_value = *static_cast<QVariant*>(vqv);
}
class MyQAccessibleValueInterface: public QAccessibleValueInterface
{
public:
void setCurrentValue(const QVariant & value) { callbackQAccessibleValueInterface_SetCurrentValue(this, const_cast<QVariant*>(&value)); };
~MyQAccessibleValueInterface() { callbackQAccessibleValueInterface_DestroyQAccessibleValueInterface(this); };
QVariant currentValue() const { return *static_cast<QVariant*>(callbackQAccessibleValueInterface_CurrentValue(const_cast<void*>(static_cast<const void*>(this)))); };
QVariant maximumValue() const { return *static_cast<QVariant*>(callbackQAccessibleValueInterface_MaximumValue(const_cast<void*>(static_cast<const void*>(this)))); };
QVariant minimumStepSize() const { return *static_cast<QVariant*>(callbackQAccessibleValueInterface_MinimumStepSize(const_cast<void*>(static_cast<const void*>(this)))); };
QVariant minimumValue() const { return *static_cast<QVariant*>(callbackQAccessibleValueInterface_MinimumValue(const_cast<void*>(static_cast<const void*>(this)))); };
};
void QAccessibleValueInterface_SetCurrentValue(void* ptr, void* value)
{
static_cast<QAccessibleValueInterface*>(ptr)->setCurrentValue(*static_cast<QVariant*>(value));
}
void QAccessibleValueInterface_DestroyQAccessibleValueInterface(void* ptr)
{
static_cast<QAccessibleValueInterface*>(ptr)->~QAccessibleValueInterface();
}
void QAccessibleValueInterface_DestroyQAccessibleValueInterfaceDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QAccessibleValueInterface_CurrentValue(void* ptr)
{
return new QVariant(static_cast<QAccessibleValueInterface*>(ptr)->currentValue());
}
void* QAccessibleValueInterface_MaximumValue(void* ptr)
{
return new QVariant(static_cast<QAccessibleValueInterface*>(ptr)->maximumValue());
}
void* QAccessibleValueInterface_MinimumStepSize(void* ptr)
{
return new QVariant(static_cast<QAccessibleValueInterface*>(ptr)->minimumStepSize());
}
void* QAccessibleValueInterface_MinimumValue(void* ptr)
{
return new QVariant(static_cast<QAccessibleValueInterface*>(ptr)->minimumValue());
}
class MyQActionEvent: public QActionEvent
{
public:
MyQActionEvent(int ty, QAction *action, QAction *before = Q_NULLPTR) : QActionEvent(ty, action, before) {};
};
void* QActionEvent_NewQActionEvent(int ty, void* action, void* before)
{
return new MyQActionEvent(ty, static_cast<QAction*>(action), static_cast<QAction*>(before));
}
void* QActionEvent_Action(void* ptr)
{
return static_cast<QActionEvent*>(ptr)->action();
}
void* QActionEvent_Before(void* ptr)
{
return static_cast<QActionEvent*>(ptr)->before();
}
void* QBackingStore_NewQBackingStore(void* window)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(window))) {
return new QBackingStore(static_cast<QPaintDeviceWindow*>(window));
} else {
return new QBackingStore(static_cast<QWindow*>(window));
}
}
void* QBackingStore_PaintDevice(void* ptr)
{
return static_cast<QBackingStore*>(ptr)->paintDevice();
}
char QBackingStore_Scroll(void* ptr, void* area, int dx, int dy)
{
return static_cast<QBackingStore*>(ptr)->scroll(*static_cast<QRegion*>(area), dx, dy);
}
void QBackingStore_BeginPaint(void* ptr, void* region)
{
static_cast<QBackingStore*>(ptr)->beginPaint(*static_cast<QRegion*>(region));
}
void QBackingStore_EndPaint(void* ptr)
{
static_cast<QBackingStore*>(ptr)->endPaint();
}
void QBackingStore_Flush(void* ptr, void* region, void* window, void* offset)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(window))) {
static_cast<QBackingStore*>(ptr)->flush(*static_cast<QRegion*>(region), static_cast<QPaintDeviceWindow*>(window), *static_cast<QPoint*>(offset));
} else {
static_cast<QBackingStore*>(ptr)->flush(*static_cast<QRegion*>(region), static_cast<QWindow*>(window), *static_cast<QPoint*>(offset));
}
}
void QBackingStore_Resize(void* ptr, void* size)
{
static_cast<QBackingStore*>(ptr)->resize(*static_cast<QSize*>(size));
}
void QBackingStore_SetStaticContents(void* ptr, void* region)
{
static_cast<QBackingStore*>(ptr)->setStaticContents(*static_cast<QRegion*>(region));
}
void QBackingStore_DestroyQBackingStore(void* ptr)
{
static_cast<QBackingStore*>(ptr)->~QBackingStore();
}
void* QBackingStore_StaticContents(void* ptr)
{
return new QRegion(static_cast<QBackingStore*>(ptr)->staticContents());
}
void* QBackingStore_Size(void* ptr)
{
return ({ QSize tmpValue = static_cast<QBackingStore*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
}
void* QBackingStore_Window(void* ptr)
{
return static_cast<QBackingStore*>(ptr)->window();
}
char QBackingStore_HasStaticContents(void* ptr)
{
return static_cast<QBackingStore*>(ptr)->hasStaticContents();
}
class MyQBitmap: public QBitmap
{
public:
MyQBitmap() : QBitmap() {};
MyQBitmap(const QBitmap &other) : QBitmap(other) {};
MyQBitmap(const QPixmap &pixmap) : QBitmap(pixmap) {};
MyQBitmap(const QSize &size) : QBitmap(size) {};
MyQBitmap(const QString &fileName, const char *format = Q_NULLPTR) : QBitmap(fileName, format) {};
MyQBitmap(int width, int height) : QBitmap(width, height) {};
~MyQBitmap() { callbackQBitmap_DestroyQBitmap(this); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQPixmap_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPaintDevice_Metric(const_cast<void*>(static_cast<const void*>(this)), metric); };
};
void* QBitmap_QBitmap_FromData(void* size, char* bits, long long monoFormat)
{
return new QBitmap(QBitmap::fromData(*static_cast<QSize*>(size), const_cast<const uchar*>(static_cast<uchar*>(static_cast<void*>(bits))), static_cast<QImage::Format>(monoFormat)));
}
void* QBitmap_QBitmap_FromImage(void* image, long long flags)
{
return new QBitmap(QBitmap::fromImage(*static_cast<QImage*>(image), static_cast<Qt::ImageConversionFlag>(flags)));
}
void* QBitmap_NewQBitmap()
{
return new MyQBitmap();
}
void* QBitmap_NewQBitmap6(void* other)
{
return new MyQBitmap(*static_cast<QBitmap*>(other));
}
void* QBitmap_NewQBitmap2(void* pixmap)
{
return new MyQBitmap(*static_cast<QPixmap*>(pixmap));
}
void* QBitmap_NewQBitmap4(void* size)
{
return new MyQBitmap(*static_cast<QSize*>(size));
}
void* QBitmap_NewQBitmap5(struct QtGui_PackedString fileName, char* format)
{
return new MyQBitmap(QString::fromUtf8(fileName.data, fileName.len), const_cast<const char*>(format));
}
void* QBitmap_NewQBitmap3(int width, int height)
{
return new MyQBitmap(width, height);
}
void QBitmap_Clear(void* ptr)
{
static_cast<QBitmap*>(ptr)->clear();
}
void QBitmap_Swap(void* ptr, void* other)
{
static_cast<QBitmap*>(ptr)->swap(*static_cast<QBitmap*>(other));
}
void QBitmap_DestroyQBitmap(void* ptr)
{
static_cast<QBitmap*>(ptr)->~QBitmap();
}
void QBitmap_DestroyQBitmapDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QBitmap_Transformed(void* ptr, void* matrix)
{
return new QBitmap(static_cast<QBitmap*>(ptr)->transformed(*static_cast<QTransform*>(matrix)));
}
void* QBrush_NewQBrush()
{
return new QBrush();
}
void* QBrush_NewQBrush2(long long style)
{
return new QBrush(static_cast<Qt::BrushStyle>(style));
}
void* QBrush_NewQBrush4(long long color, long long style)
{
return new QBrush(static_cast<Qt::GlobalColor>(color), static_cast<Qt::BrushStyle>(style));
}
void* QBrush_NewQBrush6(long long color, void* pixmap)
{
return new QBrush(static_cast<Qt::GlobalColor>(color), *static_cast<QPixmap*>(pixmap));
}
void* QBrush_NewQBrush9(void* other)
{
return new QBrush(*static_cast<QBrush*>(other));
}
void* QBrush_NewQBrush3(void* color, long long style)
{
return new QBrush(*static_cast<QColor*>(color), static_cast<Qt::BrushStyle>(style));
}
void* QBrush_NewQBrush5(void* color, void* pixmap)
{
return new QBrush(*static_cast<QColor*>(color), *static_cast<QPixmap*>(pixmap));
}
void* QBrush_NewQBrush10(void* gradient)
{
return new QBrush(*static_cast<QGradient*>(gradient));
}
void* QBrush_NewQBrush8(void* image)
{
return new QBrush(*static_cast<QImage*>(image));
}
void* QBrush_NewQBrush7(void* pixmap)
{
return new QBrush(*static_cast<QPixmap*>(pixmap));
}
void QBrush_SetColor2(void* ptr, long long color)
{
static_cast<QBrush*>(ptr)->setColor(static_cast<Qt::GlobalColor>(color));
}
void QBrush_SetColor(void* ptr, void* color)
{
static_cast<QBrush*>(ptr)->setColor(*static_cast<QColor*>(color));
}
void QBrush_SetMatrix(void* ptr, void* matrix)
{
static_cast<QBrush*>(ptr)->setMatrix(*static_cast<QMatrix*>(matrix));
}
void QBrush_SetStyle(void* ptr, long long style)
{
static_cast<QBrush*>(ptr)->setStyle(static_cast<Qt::BrushStyle>(style));
}
void QBrush_SetTexture(void* ptr, void* pixmap)
{
static_cast<QBrush*>(ptr)->setTexture(*static_cast<QPixmap*>(pixmap));
}
void QBrush_SetTextureImage(void* ptr, void* image)
{
static_cast<QBrush*>(ptr)->setTextureImage(*static_cast<QImage*>(image));
}
void QBrush_SetTransform(void* ptr, void* matrix)
{
static_cast<QBrush*>(ptr)->setTransform(*static_cast<QTransform*>(matrix));
}
void QBrush_Swap(void* ptr, void* other)
{
static_cast<QBrush*>(ptr)->swap(*static_cast<QBrush*>(other));
}
void QBrush_DestroyQBrush(void* ptr)
{
static_cast<QBrush*>(ptr)->~QBrush();
}
void* QBrush_TextureImage(void* ptr)
{
return new QImage(static_cast<QBrush*>(ptr)->textureImage());
}
void* QBrush_Texture(void* ptr)
{
return new QPixmap(static_cast<QBrush*>(ptr)->texture());
}
void* QBrush_Transform(void* ptr)
{
return new QTransform(static_cast<QBrush*>(ptr)->transform());
}
long long QBrush_Style(void* ptr)
{
return static_cast<QBrush*>(ptr)->style();
}
char QBrush_IsOpaque(void* ptr)
{
return static_cast<QBrush*>(ptr)->isOpaque();
}
void* QBrush_Color(void* ptr)
{
return const_cast<QColor*>(&static_cast<QBrush*>(ptr)->color());
}
void* QBrush_Gradient(void* ptr)
{
return const_cast<QGradient*>(static_cast<QBrush*>(ptr)->gradient());
}
void* QBrush_Matrix(void* ptr)
{
return const_cast<QMatrix*>(&static_cast<QBrush*>(ptr)->matrix());
}
void* QBrush_ToVariant(void* ptr)
{
return new QVariant(*static_cast<QBrush*>(ptr));
}
class MyQClipboard: public QClipboard
{
public:
void Signal_Changed(QClipboard::Mode mode) { callbackQClipboard_Changed(this, mode); };
void Signal_DataChanged() { callbackQClipboard_DataChanged(this); };
void Signal_FindBufferChanged() { callbackQClipboard_FindBufferChanged(this); };
void Signal_SelectionChanged() { callbackQClipboard_SelectionChanged(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQClipboard_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQClipboard_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQClipboard_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQClipboard_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQClipboard_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQClipboard_CustomEvent(this, event); };
void deleteLater() { callbackQClipboard_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQClipboard_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQClipboard_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQClipboard_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQClipboard_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQClipboard*)
int QClipboard_QClipboard_QRegisterMetaType(){qRegisterMetaType<QClipboard*>(); return qRegisterMetaType<MyQClipboard*>();}
struct QtGui_PackedString QClipboard_QClipboard_Tr(char* s, char* c, int n)
{
return ({ QByteArray t659255 = QClipboard::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t659255.prepend("WHITESPACE").constData()+10), t659255.size()-10 }; });
}
struct QtGui_PackedString QClipboard_QClipboard_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray tfa2a05 = QClipboard::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(tfa2a05.prepend("WHITESPACE").constData()+10), tfa2a05.size()-10 }; });
}
void QClipboard_ConnectChanged(void* ptr)
{
QObject::connect(static_cast<QClipboard*>(ptr), static_cast<void (QClipboard::*)(QClipboard::Mode)>(&QClipboard::changed), static_cast<MyQClipboard*>(ptr), static_cast<void (MyQClipboard::*)(QClipboard::Mode)>(&MyQClipboard::Signal_Changed));
}
void QClipboard_DisconnectChanged(void* ptr)
{
QObject::disconnect(static_cast<QClipboard*>(ptr), static_cast<void (QClipboard::*)(QClipboard::Mode)>(&QClipboard::changed), static_cast<MyQClipboard*>(ptr), static_cast<void (MyQClipboard::*)(QClipboard::Mode)>(&MyQClipboard::Signal_Changed));
}
void QClipboard_Changed(void* ptr, long long mode)
{
static_cast<QClipboard*>(ptr)->changed(static_cast<QClipboard::Mode>(mode));
}
void QClipboard_Clear(void* ptr, long long mode)
{
static_cast<QClipboard*>(ptr)->clear(static_cast<QClipboard::Mode>(mode));
}
void QClipboard_ConnectDataChanged(void* ptr)
{
QObject::connect(static_cast<QClipboard*>(ptr), static_cast<void (QClipboard::*)()>(&QClipboard::dataChanged), static_cast<MyQClipboard*>(ptr), static_cast<void (MyQClipboard::*)()>(&MyQClipboard::Signal_DataChanged));
}
void QClipboard_DisconnectDataChanged(void* ptr)
{
QObject::disconnect(static_cast<QClipboard*>(ptr), static_cast<void (QClipboard::*)()>(&QClipboard::dataChanged), static_cast<MyQClipboard*>(ptr), static_cast<void (MyQClipboard::*)()>(&MyQClipboard::Signal_DataChanged));
}
void QClipboard_DataChanged(void* ptr)
{
static_cast<QClipboard*>(ptr)->dataChanged();
}
void QClipboard_ConnectFindBufferChanged(void* ptr)
{
QObject::connect(static_cast<QClipboard*>(ptr), static_cast<void (QClipboard::*)()>(&QClipboard::findBufferChanged), static_cast<MyQClipboard*>(ptr), static_cast<void (MyQClipboard::*)()>(&MyQClipboard::Signal_FindBufferChanged));
}
void QClipboard_DisconnectFindBufferChanged(void* ptr)
{
QObject::disconnect(static_cast<QClipboard*>(ptr), static_cast<void (QClipboard::*)()>(&QClipboard::findBufferChanged), static_cast<MyQClipboard*>(ptr), static_cast<void (MyQClipboard::*)()>(&MyQClipboard::Signal_FindBufferChanged));
}
void QClipboard_FindBufferChanged(void* ptr)
{
static_cast<QClipboard*>(ptr)->findBufferChanged();
}
void QClipboard_ConnectSelectionChanged(void* ptr)
{
QObject::connect(static_cast<QClipboard*>(ptr), static_cast<void (QClipboard::*)()>(&QClipboard::selectionChanged), static_cast<MyQClipboard*>(ptr), static_cast<void (MyQClipboard::*)()>(&MyQClipboard::Signal_SelectionChanged));
}
void QClipboard_DisconnectSelectionChanged(void* ptr)
{
QObject::disconnect(static_cast<QClipboard*>(ptr), static_cast<void (QClipboard::*)()>(&QClipboard::selectionChanged), static_cast<MyQClipboard*>(ptr), static_cast<void (MyQClipboard::*)()>(&MyQClipboard::Signal_SelectionChanged));
}
void QClipboard_SelectionChanged(void* ptr)
{
static_cast<QClipboard*>(ptr)->selectionChanged();
}
void QClipboard_SetImage(void* ptr, void* image, long long mode)
{
static_cast<QClipboard*>(ptr)->setImage(*static_cast<QImage*>(image), static_cast<QClipboard::Mode>(mode));
}
void QClipboard_SetMimeData(void* ptr, void* src, long long mode)
{
static_cast<QClipboard*>(ptr)->setMimeData(static_cast<QMimeData*>(src), static_cast<QClipboard::Mode>(mode));
}
void QClipboard_SetPixmap(void* ptr, void* pixmap, long long mode)
{
static_cast<QClipboard*>(ptr)->setPixmap(*static_cast<QPixmap*>(pixmap), static_cast<QClipboard::Mode>(mode));
}
void QClipboard_SetText(void* ptr, struct QtGui_PackedString text, long long mode)
{
static_cast<QClipboard*>(ptr)->setText(QString::fromUtf8(text.data, text.len), static_cast<QClipboard::Mode>(mode));
}
void* QClipboard_Image(void* ptr, long long mode)
{
return new QImage(static_cast<QClipboard*>(ptr)->image(static_cast<QClipboard::Mode>(mode)));
}
void* QClipboard_Pixmap(void* ptr, long long mode)
{
return new QPixmap(static_cast<QClipboard*>(ptr)->pixmap(static_cast<QClipboard::Mode>(mode)));
}
struct QtGui_PackedString QClipboard_Text(void* ptr, long long mode)
{
return ({ QByteArray tc36a83 = static_cast<QClipboard*>(ptr)->text(static_cast<QClipboard::Mode>(mode)).toUtf8(); QtGui_PackedString { const_cast<char*>(tc36a83.prepend("WHITESPACE").constData()+10), tc36a83.size()-10 }; });
}
struct QtGui_PackedString QClipboard_Text2(void* ptr, struct QtGui_PackedString subtype, long long mode)
{
return ({ QByteArray tde8270 = static_cast<QClipboard*>(ptr)->text(*(new QString(QString::fromUtf8(subtype.data, subtype.len))), static_cast<QClipboard::Mode>(mode)).toUtf8(); QtGui_PackedString { const_cast<char*>(tde8270.prepend("WHITESPACE").constData()+10), tde8270.size()-10 }; });
}
char QClipboard_OwnsClipboard(void* ptr)
{
return static_cast<QClipboard*>(ptr)->ownsClipboard();
}
char QClipboard_OwnsFindBuffer(void* ptr)
{
return static_cast<QClipboard*>(ptr)->ownsFindBuffer();
}
char QClipboard_OwnsSelection(void* ptr)
{
return static_cast<QClipboard*>(ptr)->ownsSelection();
}
char QClipboard_SupportsFindBuffer(void* ptr)
{
return static_cast<QClipboard*>(ptr)->supportsFindBuffer();
}
char QClipboard_SupportsSelection(void* ptr)
{
return static_cast<QClipboard*>(ptr)->supportsSelection();
}
void* QClipboard_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QClipboard*>(ptr)->QClipboard::metaObject());
}
void* QClipboard_MimeData(void* ptr, long long mode)
{
return const_cast<QMimeData*>(static_cast<QClipboard*>(ptr)->mimeData(static_cast<QClipboard::Mode>(mode)));
}
void* QClipboard___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QClipboard___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QClipboard___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QClipboard___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QClipboard___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QClipboard___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QClipboard___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QClipboard___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QClipboard___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QClipboard___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QClipboard___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QClipboard___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QClipboard___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QClipboard___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QClipboard___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QClipboard_EventDefault(void* ptr, void* e)
{
return static_cast<QClipboard*>(ptr)->QClipboard::event(static_cast<QEvent*>(e));
}
char QClipboard_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QClipboard*>(ptr)->QClipboard::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QClipboard*>(ptr)->QClipboard::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QClipboard*>(ptr)->QClipboard::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QClipboard*>(ptr)->QClipboard::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QClipboard*>(ptr)->QClipboard::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QClipboard_ChildEventDefault(void* ptr, void* event)
{
static_cast<QClipboard*>(ptr)->QClipboard::childEvent(static_cast<QChildEvent*>(event));
}
void QClipboard_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QClipboard*>(ptr)->QClipboard::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QClipboard_CustomEventDefault(void* ptr, void* event)
{
static_cast<QClipboard*>(ptr)->QClipboard::customEvent(static_cast<QEvent*>(event));
}
void QClipboard_DeleteLaterDefault(void* ptr)
{
static_cast<QClipboard*>(ptr)->QClipboard::deleteLater();
}
void QClipboard_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QClipboard*>(ptr)->QClipboard::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QClipboard_TimerEventDefault(void* ptr, void* event)
{
static_cast<QClipboard*>(ptr)->QClipboard::timerEvent(static_cast<QTimerEvent*>(event));
}
class MyQCloseEvent: public QCloseEvent
{
public:
MyQCloseEvent() : QCloseEvent() {};
};
void* QCloseEvent_NewQCloseEvent()
{
return new MyQCloseEvent();
}
void* QColor_QColor_FromCmyk(int c, int m, int y, int k, int a)
{
return new QColor(QColor::fromCmyk(c, m, y, k, a));
}
void* QColor_QColor_FromCmykF(double c, double m, double y, double k, double a)
{
return new QColor(QColor::fromCmykF(c, m, y, k, a));
}
void* QColor_QColor_FromHsl(int h, int s, int l, int a)
{
return new QColor(QColor::fromHsl(h, s, l, a));
}
void* QColor_QColor_FromHslF(double h, double s, double l, double a)
{
return new QColor(QColor::fromHslF(h, s, l, a));
}
void* QColor_QColor_FromHsv(int h, int s, int v, int a)
{
return new QColor(QColor::fromHsv(h, s, v, a));
}
void* QColor_QColor_FromHsvF(double h, double s, double v, double a)
{
return new QColor(QColor::fromHsvF(h, s, v, a));
}
void* QColor_QColor_FromRgb2(int r, int g, int b, int a)
{
return new QColor(QColor::fromRgb(r, g, b, a));
}
void* QColor_QColor_FromRgbF(double r, double g, double b, double a)
{
return new QColor(QColor::fromRgbF(r, g, b, a));
}
void* QColor_QColor_FromRgba642(void* rgba64)
{
return new QColor(QColor::fromRgba64(*static_cast<QRgba64*>(rgba64)));
}
void* QColor_QColor_FromRgba64(unsigned short r, unsigned short g, unsigned short b, unsigned short a)
{
return new QColor(QColor::fromRgba64(r, g, b, a));
}
void* QColor_NewQColor()
{
return new QColor();
}
void* QColor_NewQColor12(void* other)
{
return new QColor(*static_cast<QColor*>(other));
}
void* QColor_NewQColor9(void* name)
{
return new QColor(*static_cast<QLatin1String*>(name));
}
void* QColor_NewQColor5(void* rgba64)
{
return new QColor(*static_cast<QRgba64*>(rgba64));
}
void* QColor_NewQColor7(void* name)
{
return new QColor(*static_cast<QStringView*>(name));
}
void* QColor_NewQColor2(long long color)
{
return new QColor(static_cast<Qt::GlobalColor>(color));
}
void* QColor_NewQColor11(void* color)
{
return new QColor(*static_cast<QColor*>(color));
}
void* QColor_NewQColor6(struct QtGui_PackedString name)
{
return new QColor(QString::fromUtf8(name.data, name.len));
}
void* QColor_NewQColor8(char* name)
{
return new QColor(const_cast<const char*>(name));
}
void* QColor_NewQColor3(int r, int g, int b, int a)
{
return new QColor(r, g, b, a);
}
struct QtGui_PackedString QColor_QColor_ColorNames()
{
return ({ QByteArray t1b28c6 = QColor::colorNames().join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t1b28c6.prepend("WHITESPACE").constData()+10), t1b28c6.size()-10 }; });
}
char QColor_QColor_IsValidColor3(void* name)
{
return QColor::isValidColor(*static_cast<QLatin1String*>(name));
}
char QColor_QColor_IsValidColor2(void* name)
{
return QColor::isValidColor(*static_cast<QStringView*>(name));
}
char QColor_QColor_IsValidColor(struct QtGui_PackedString name)
{
return QColor::isValidColor(QString::fromUtf8(name.data, name.len));
}
void QColor_GetCmyk(void* ptr, int c, int m, int y, int k, int a)
{
static_cast<QColor*>(ptr)->getCmyk(&c, &m, &y, &k, &a);
}
void QColor_GetCmykF(void* ptr, double c, double m, double y, double k, double a)
{
static_cast<QColor*>(ptr)->getCmykF(&c, &m, &y, &k, &a);
}
void QColor_SetAlpha(void* ptr, int alpha)
{
static_cast<QColor*>(ptr)->setAlpha(alpha);
}
void QColor_SetAlphaF(void* ptr, double alpha)
{
static_cast<QColor*>(ptr)->setAlphaF(alpha);
}
void QColor_SetBlue(void* ptr, int blue)
{
static_cast<QColor*>(ptr)->setBlue(blue);
}
void QColor_SetBlueF(void* ptr, double blue)
{
static_cast<QColor*>(ptr)->setBlueF(blue);
}
void QColor_SetCmyk(void* ptr, int c, int m, int y, int k, int a)
{
static_cast<QColor*>(ptr)->setCmyk(c, m, y, k, a);
}
void QColor_SetCmykF(void* ptr, double c, double m, double y, double k, double a)
{
static_cast<QColor*>(ptr)->setCmykF(c, m, y, k, a);
}
void QColor_SetGreen(void* ptr, int green)
{
static_cast<QColor*>(ptr)->setGreen(green);
}
void QColor_SetGreenF(void* ptr, double green)
{
static_cast<QColor*>(ptr)->setGreenF(green);
}
void QColor_SetHsl(void* ptr, int h, int s, int l, int a)
{
static_cast<QColor*>(ptr)->setHsl(h, s, l, a);
}
void QColor_SetHslF(void* ptr, double h, double s, double l, double a)
{
static_cast<QColor*>(ptr)->setHslF(h, s, l, a);
}
void QColor_SetHsv(void* ptr, int h, int s, int v, int a)
{
static_cast<QColor*>(ptr)->setHsv(h, s, v, a);
}
void QColor_SetHsvF(void* ptr, double h, double s, double v, double a)
{
static_cast<QColor*>(ptr)->setHsvF(h, s, v, a);
}
void QColor_SetNamedColor3(void* ptr, void* name)
{
static_cast<QColor*>(ptr)->setNamedColor(*static_cast<QLatin1String*>(name));
}
void QColor_SetNamedColor2(void* ptr, void* name)
{
static_cast<QColor*>(ptr)->setNamedColor(*static_cast<QStringView*>(name));
}
void QColor_SetNamedColor(void* ptr, struct QtGui_PackedString name)
{
static_cast<QColor*>(ptr)->setNamedColor(QString::fromUtf8(name.data, name.len));
}
void QColor_SetRed(void* ptr, int red)
{
static_cast<QColor*>(ptr)->setRed(red);
}
void QColor_SetRedF(void* ptr, double red)
{
static_cast<QColor*>(ptr)->setRedF(red);
}
void QColor_SetRgb(void* ptr, int r, int g, int b, int a)
{
static_cast<QColor*>(ptr)->setRgb(r, g, b, a);
}
void QColor_SetRgbF(void* ptr, double r, double g, double b, double a)
{
static_cast<QColor*>(ptr)->setRgbF(r, g, b, a);
}
void QColor_SetRgba64(void* ptr, void* rgba)
{
static_cast<QColor*>(ptr)->setRgba64(*static_cast<QRgba64*>(rgba));
}
void* QColor_ConvertTo(void* ptr, long long colorSpec)
{
return new QColor(static_cast<QColor*>(ptr)->convertTo(static_cast<QColor::Spec>(colorSpec)));
}
void* QColor_Darker(void* ptr, int factor)
{
return new QColor(static_cast<QColor*>(ptr)->darker(factor));
}
void* QColor_Lighter(void* ptr, int factor)
{
return new QColor(static_cast<QColor*>(ptr)->lighter(factor));
}
void* QColor_ToCmyk(void* ptr)
{
return new QColor(static_cast<QColor*>(ptr)->toCmyk());
}
void* QColor_ToHsl(void* ptr)
{
return new QColor(static_cast<QColor*>(ptr)->toHsl());
}
void* QColor_ToHsv(void* ptr)
{
return new QColor(static_cast<QColor*>(ptr)->toHsv());
}
void* QColor_ToRgb(void* ptr)
{
return new QColor(static_cast<QColor*>(ptr)->toRgb());
}
long long QColor_Spec(void* ptr)
{
return static_cast<QColor*>(ptr)->spec();
}
void* QColor_Rgba64(void* ptr)
{
return new QRgba64(static_cast<QColor*>(ptr)->rgba64());
}
struct QtGui_PackedString QColor_Name(void* ptr)
{
return ({ QByteArray t9b3be4 = static_cast<QColor*>(ptr)->name().toUtf8(); QtGui_PackedString { const_cast<char*>(t9b3be4.prepend("WHITESPACE").constData()+10), t9b3be4.size()-10 }; });
}
struct QtGui_PackedString QColor_Name2(void* ptr, long long format)
{
return ({ QByteArray t4331f3 = static_cast<QColor*>(ptr)->name(static_cast<QColor::NameFormat>(format)).toUtf8(); QtGui_PackedString { const_cast<char*>(t4331f3.prepend("WHITESPACE").constData()+10), t4331f3.size()-10 }; });
}
char QColor_IsValid(void* ptr)
{
return static_cast<QColor*>(ptr)->isValid();
}
int QColor_Alpha(void* ptr)
{
return static_cast<QColor*>(ptr)->alpha();
}
int QColor_Black(void* ptr)
{
return static_cast<QColor*>(ptr)->black();
}
int QColor_Blue(void* ptr)
{
return static_cast<QColor*>(ptr)->blue();
}
int QColor_Cyan(void* ptr)
{
return static_cast<QColor*>(ptr)->cyan();
}
int QColor_Green(void* ptr)
{
return static_cast<QColor*>(ptr)->green();
}
int QColor_HslHue(void* ptr)
{
return static_cast<QColor*>(ptr)->hslHue();
}
int QColor_HslSaturation(void* ptr)
{
return static_cast<QColor*>(ptr)->hslSaturation();
}
int QColor_HsvHue(void* ptr)
{
return static_cast<QColor*>(ptr)->hsvHue();
}
int QColor_HsvSaturation(void* ptr)
{
return static_cast<QColor*>(ptr)->hsvSaturation();
}
int QColor_Hue(void* ptr)
{
return static_cast<QColor*>(ptr)->hue();
}
int QColor_Lightness(void* ptr)
{
return static_cast<QColor*>(ptr)->lightness();
}
int QColor_Magenta(void* ptr)
{
return static_cast<QColor*>(ptr)->magenta();
}
int QColor_Red(void* ptr)
{
return static_cast<QColor*>(ptr)->red();
}
int QColor_Saturation(void* ptr)
{
return static_cast<QColor*>(ptr)->saturation();
}
int QColor_Value(void* ptr)
{
return static_cast<QColor*>(ptr)->value();
}
int QColor_Yellow(void* ptr)
{
return static_cast<QColor*>(ptr)->yellow();
}
double QColor_AlphaF(void* ptr)
{
return static_cast<QColor*>(ptr)->alphaF();
}
double QColor_BlackF(void* ptr)
{
return static_cast<QColor*>(ptr)->blackF();
}
double QColor_BlueF(void* ptr)
{
return static_cast<QColor*>(ptr)->blueF();
}
double QColor_CyanF(void* ptr)
{
return static_cast<QColor*>(ptr)->cyanF();
}
double QColor_GreenF(void* ptr)
{
return static_cast<QColor*>(ptr)->greenF();
}
double QColor_HslHueF(void* ptr)
{
return static_cast<QColor*>(ptr)->hslHueF();
}
double QColor_HslSaturationF(void* ptr)
{
return static_cast<QColor*>(ptr)->hslSaturationF();
}
double QColor_HsvHueF(void* ptr)
{
return static_cast<QColor*>(ptr)->hsvHueF();
}
double QColor_HsvSaturationF(void* ptr)
{
return static_cast<QColor*>(ptr)->hsvSaturationF();
}
double QColor_HueF(void* ptr)
{
return static_cast<QColor*>(ptr)->hueF();
}
double QColor_LightnessF(void* ptr)
{
return static_cast<QColor*>(ptr)->lightnessF();
}
double QColor_MagentaF(void* ptr)
{
return static_cast<QColor*>(ptr)->magentaF();
}
double QColor_RedF(void* ptr)
{
return static_cast<QColor*>(ptr)->redF();
}
double QColor_SaturationF(void* ptr)
{
return static_cast<QColor*>(ptr)->saturationF();
}
double QColor_ValueF(void* ptr)
{
return static_cast<QColor*>(ptr)->valueF();
}
double QColor_YellowF(void* ptr)
{
return static_cast<QColor*>(ptr)->yellowF();
}
void QColor_GetHsl(void* ptr, int h, int s, int l, int a)
{
static_cast<QColor*>(ptr)->getHsl(&h, &s, &l, &a);
}
void QColor_GetHslF(void* ptr, double h, double s, double l, double a)
{
static_cast<QColor*>(ptr)->getHslF(&h, &s, &l, &a);
}
void QColor_GetHsv(void* ptr, int h, int s, int v, int a)
{
static_cast<QColor*>(ptr)->getHsv(&h, &s, &v, &a);
}
void QColor_GetHsvF(void* ptr, double h, double s, double v, double a)
{
static_cast<QColor*>(ptr)->getHsvF(&h, &s, &v, &a);
}
void QColor_GetRgb(void* ptr, int r, int g, int b, int a)
{
static_cast<QColor*>(ptr)->getRgb(&r, &g, &b, &a);
}
void QColor_GetRgbF(void* ptr, double r, double g, double b, double a)
{
static_cast<QColor*>(ptr)->getRgbF(&r, &g, &b, &a);
}
void* QColor_ToVariant(void* ptr)
{
return new QVariant(*static_cast<QColor*>(ptr));
}
void* QConicalGradient_NewQConicalGradient()
{
return new QConicalGradient();
}
void* QConicalGradient_NewQConicalGradient2(void* center, double angle)
{
return new QConicalGradient(*static_cast<QPointF*>(center), angle);
}
void* QConicalGradient_NewQConicalGradient3(double cx, double cy, double angle)
{
return new QConicalGradient(cx, cy, angle);
}
void QConicalGradient_SetAngle(void* ptr, double angle)
{
static_cast<QConicalGradient*>(ptr)->setAngle(angle);
}
void QConicalGradient_SetCenter(void* ptr, void* center)
{
static_cast<QConicalGradient*>(ptr)->setCenter(*static_cast<QPointF*>(center));
}
void QConicalGradient_SetCenter2(void* ptr, double x, double y)
{
static_cast<QConicalGradient*>(ptr)->setCenter(x, y);
}
void* QConicalGradient_Center(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QConicalGradient*>(ptr)->center(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
double QConicalGradient_Angle(void* ptr)
{
return static_cast<QConicalGradient*>(ptr)->angle();
}
class MyQContextMenuEvent: public QContextMenuEvent
{
public:
MyQContextMenuEvent(QContextMenuEvent::Reason reason, const QPoint &pos) : QContextMenuEvent(reason, pos) {};
MyQContextMenuEvent(QContextMenuEvent::Reason reason, const QPoint &pos, const QPoint &globalPos) : QContextMenuEvent(reason, pos, globalPos) {};
MyQContextMenuEvent(QContextMenuEvent::Reason reason, const QPoint &pos, const QPoint &globalPos, Qt::KeyboardModifiers modifiers) : QContextMenuEvent(reason, pos, globalPos, modifiers) {};
};
void* QContextMenuEvent_NewQContextMenuEvent3(long long reason, void* pos)
{
return new MyQContextMenuEvent(static_cast<QContextMenuEvent::Reason>(reason), *static_cast<QPoint*>(pos));
}
void* QContextMenuEvent_NewQContextMenuEvent2(long long reason, void* pos, void* globalPos)
{
return new MyQContextMenuEvent(static_cast<QContextMenuEvent::Reason>(reason), *static_cast<QPoint*>(pos), *static_cast<QPoint*>(globalPos));
}
void* QContextMenuEvent_NewQContextMenuEvent(long long reason, void* pos, void* globalPos, long long modifiers)
{
return new MyQContextMenuEvent(static_cast<QContextMenuEvent::Reason>(reason), *static_cast<QPoint*>(pos), *static_cast<QPoint*>(globalPos), static_cast<Qt::KeyboardModifier>(modifiers));
}
long long QContextMenuEvent_Reason(void* ptr)
{
return static_cast<QContextMenuEvent*>(ptr)->reason();
}
void* QContextMenuEvent_GlobalPos(void* ptr)
{
return const_cast<QPoint*>(&static_cast<QContextMenuEvent*>(ptr)->globalPos());
}
void* QContextMenuEvent_Pos(void* ptr)
{
return const_cast<QPoint*>(&static_cast<QContextMenuEvent*>(ptr)->pos());
}
int QContextMenuEvent_GlobalX(void* ptr)
{
return static_cast<QContextMenuEvent*>(ptr)->globalX();
}
int QContextMenuEvent_GlobalY(void* ptr)
{
return static_cast<QContextMenuEvent*>(ptr)->globalY();
}
int QContextMenuEvent_X(void* ptr)
{
return static_cast<QContextMenuEvent*>(ptr)->x();
}
int QContextMenuEvent_Y(void* ptr)
{
return static_cast<QContextMenuEvent*>(ptr)->y();
}
void* QContextMenuEvent_Gp(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QContextMenuEvent*>(ptr)->gp; new QPoint(tmpValue.x(), tmpValue.y()); });
}
void QContextMenuEvent_SetGp(void* ptr, void* vqp)
{
static_cast<QContextMenuEvent*>(ptr)->gp = *static_cast<QPoint*>(vqp);
}
void* QContextMenuEvent_P(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QContextMenuEvent*>(ptr)->p; new QPoint(tmpValue.x(), tmpValue.y()); });
}
void QContextMenuEvent_SetP(void* ptr, void* vqp)
{
static_cast<QContextMenuEvent*>(ptr)->p = *static_cast<QPoint*>(vqp);
}
unsigned int QContextMenuEvent_Reas(void* ptr)
{
return static_cast<QContextMenuEvent*>(ptr)->reas;
}
void QContextMenuEvent_SetReas(void* ptr, unsigned int vui)
{
static_cast<QContextMenuEvent*>(ptr)->reas = vui;
}
void* QCursor_NewQCursor()
{
return new QCursor();
}
void* QCursor_NewQCursor6(void* other)
{
return new QCursor(*static_cast<QCursor*>(other));
}
void* QCursor_NewQCursor2(long long shape)
{
return new QCursor(static_cast<Qt::CursorShape>(shape));
}
void* QCursor_NewQCursor3(void* bitmap, void* mask, int hotX, int hotY)
{
return new QCursor(*static_cast<QBitmap*>(bitmap), *static_cast<QBitmap*>(mask), hotX, hotY);
}
void* QCursor_NewQCursor5(void* c)
{
return new QCursor(*static_cast<QCursor*>(c));
}
void* QCursor_NewQCursor4(void* pixmap, int hotX, int hotY)
{
return new QCursor(*static_cast<QPixmap*>(pixmap), hotX, hotY);
}
void* QCursor_QCursor_Pos()
{
return ({ QPoint tmpValue = QCursor::pos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QCursor_QCursor_Pos2(void* screen)
{
return ({ QPoint tmpValue = QCursor::pos(static_cast<QScreen*>(screen)); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void QCursor_QCursor_SetPos4(void* screen, void* p)
{
QCursor::setPos(static_cast<QScreen*>(screen), *static_cast<QPoint*>(p));
}
void QCursor_QCursor_SetPos2(void* screen, int x, int y)
{
QCursor::setPos(static_cast<QScreen*>(screen), x, y);
}
void QCursor_QCursor_SetPos3(void* p)
{
QCursor::setPos(*static_cast<QPoint*>(p));
}
void QCursor_QCursor_SetPos(int x, int y)
{
QCursor::setPos(x, y);
}
void QCursor_SetShape(void* ptr, long long shape)
{
static_cast<QCursor*>(ptr)->setShape(static_cast<Qt::CursorShape>(shape));
}
void QCursor_Swap(void* ptr, void* other)
{
static_cast<QCursor*>(ptr)->swap(*static_cast<QCursor*>(other));
}
void QCursor_DestroyQCursor(void* ptr)
{
static_cast<QCursor*>(ptr)->~QCursor();
}
void* QCursor_Pixmap(void* ptr)
{
return new QPixmap(static_cast<QCursor*>(ptr)->pixmap());
}
void* QCursor_HotSpot(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QCursor*>(ptr)->hotSpot(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
long long QCursor_Shape(void* ptr)
{
return static_cast<QCursor*>(ptr)->shape();
}
void* QCursor_Bitmap(void* ptr)
{
return const_cast<QBitmap*>(static_cast<QCursor*>(ptr)->bitmap());
}
void* QCursor_Mask(void* ptr)
{
return const_cast<QBitmap*>(static_cast<QCursor*>(ptr)->mask());
}
char QDesktopServices_QDesktopServices_OpenUrl(void* url)
{
return QDesktopServices::openUrl(*static_cast<QUrl*>(url));
}
void QDesktopServices_QDesktopServices_SetUrlHandler(struct QtGui_PackedString scheme, void* receiver, char* method)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(receiver))) {
QDesktopServices::setUrlHandler(QString::fromUtf8(scheme.data, scheme.len), static_cast<QOffscreenSurface*>(receiver), const_cast<const char*>(method));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(receiver))) {
QDesktopServices::setUrlHandler(QString::fromUtf8(scheme.data, scheme.len), static_cast<QPaintDeviceWindow*>(receiver), const_cast<const char*>(method));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(receiver))) {
QDesktopServices::setUrlHandler(QString::fromUtf8(scheme.data, scheme.len), static_cast<QPdfWriter*>(receiver), const_cast<const char*>(method));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(receiver))) {
QDesktopServices::setUrlHandler(QString::fromUtf8(scheme.data, scheme.len), static_cast<QWindow*>(receiver), const_cast<const char*>(method));
} else {
QDesktopServices::setUrlHandler(QString::fromUtf8(scheme.data, scheme.len), static_cast<QObject*>(receiver), const_cast<const char*>(method));
}
}
void QDesktopServices_QDesktopServices_UnsetUrlHandler(struct QtGui_PackedString scheme)
{
QDesktopServices::unsetUrlHandler(QString::fromUtf8(scheme.data, scheme.len));
}
class MyQDoubleValidator: public QDoubleValidator
{
public:
MyQDoubleValidator(QObject *parent = Q_NULLPTR) : QDoubleValidator(parent) {QDoubleValidator_QDoubleValidator_QRegisterMetaType();};
MyQDoubleValidator(double bottom, double top, int decimals, QObject *parent = Q_NULLPTR) : QDoubleValidator(bottom, top, decimals, parent) {QDoubleValidator_QDoubleValidator_QRegisterMetaType();};
void setRange(double minimum, double maximum, int decimals) { callbackQDoubleValidator_SetRange(this, minimum, maximum, decimals); };
~MyQDoubleValidator() { callbackQDoubleValidator_DestroyQDoubleValidator(this); };
QValidator::State validate(QString & input, int & pos) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };return static_cast<QValidator::State>(callbackQDoubleValidator_Validate(const_cast<void*>(static_cast<const void*>(this)), inputPacked, pos)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQValidator_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_Changed() { callbackQValidator_Changed(this); };
void fixup(QString & input) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };callbackQValidator_Fixup(const_cast<void*>(static_cast<const void*>(this)), inputPacked); };
bool event(QEvent * e) { return callbackQValidator_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQValidator_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQValidator_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQValidator_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQValidator_CustomEvent(this, event); };
void deleteLater() { callbackQValidator_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQValidator_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQValidator_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQValidator_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQValidator_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQDoubleValidator*)
int QDoubleValidator_QDoubleValidator_QRegisterMetaType(){qRegisterMetaType<QDoubleValidator*>(); return qRegisterMetaType<MyQDoubleValidator*>();}
void* QDoubleValidator_NewQDoubleValidator(void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(static_cast<QWindow*>(parent));
} else {
return new MyQDoubleValidator(static_cast<QObject*>(parent));
}
}
void* QDoubleValidator_NewQDoubleValidator2(double bottom, double top, int decimals, void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(bottom, top, decimals, static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(bottom, top, decimals, static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(bottom, top, decimals, static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(bottom, top, decimals, static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(bottom, top, decimals, static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(bottom, top, decimals, static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(bottom, top, decimals, static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(bottom, top, decimals, static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(bottom, top, decimals, static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(bottom, top, decimals, static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(bottom, top, decimals, static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(bottom, top, decimals, static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(bottom, top, decimals, static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(bottom, top, decimals, static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(bottom, top, decimals, static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQDoubleValidator(bottom, top, decimals, static_cast<QWindow*>(parent));
} else {
return new MyQDoubleValidator(bottom, top, decimals, static_cast<QObject*>(parent));
}
}
void QDoubleValidator_SetBottom(void* ptr, double vdo)
{
static_cast<QDoubleValidator*>(ptr)->setBottom(vdo);
}
void QDoubleValidator_SetDecimals(void* ptr, int vin)
{
static_cast<QDoubleValidator*>(ptr)->setDecimals(vin);
}
void QDoubleValidator_SetNotation(void* ptr, long long vqd)
{
static_cast<QDoubleValidator*>(ptr)->setNotation(static_cast<QDoubleValidator::Notation>(vqd));
}
void QDoubleValidator_SetRange(void* ptr, double minimum, double maximum, int decimals)
{
static_cast<QDoubleValidator*>(ptr)->setRange(minimum, maximum, decimals);
}
void QDoubleValidator_SetRangeDefault(void* ptr, double minimum, double maximum, int decimals)
{
static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::setRange(minimum, maximum, decimals);
}
void QDoubleValidator_SetTop(void* ptr, double vdo)
{
static_cast<QDoubleValidator*>(ptr)->setTop(vdo);
}
void QDoubleValidator_DestroyQDoubleValidator(void* ptr)
{
static_cast<QDoubleValidator*>(ptr)->~QDoubleValidator();
}
void QDoubleValidator_DestroyQDoubleValidatorDefault(void* ptr)
{
Q_UNUSED(ptr);
}
long long QDoubleValidator_Notation(void* ptr)
{
return static_cast<QDoubleValidator*>(ptr)->notation();
}
long long QDoubleValidator_Validate(void* ptr, struct QtGui_PackedString input, int pos)
{
return static_cast<QDoubleValidator*>(ptr)->validate(*(new QString(QString::fromUtf8(input.data, input.len))), pos);
}
long long QDoubleValidator_ValidateDefault(void* ptr, struct QtGui_PackedString input, int pos)
{
return static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::validate(*(new QString(QString::fromUtf8(input.data, input.len))), pos);
}
double QDoubleValidator_Bottom(void* ptr)
{
return static_cast<QDoubleValidator*>(ptr)->bottom();
}
double QDoubleValidator_Top(void* ptr)
{
return static_cast<QDoubleValidator*>(ptr)->top();
}
int QDoubleValidator_Decimals(void* ptr)
{
return static_cast<QDoubleValidator*>(ptr)->decimals();
}
class MyQDrag: public QDrag
{
public:
MyQDrag(QObject *dragSource) : QDrag(dragSource) {QDrag_QDrag_QRegisterMetaType();};
void Signal_ActionChanged(Qt::DropAction action) { callbackQDrag_ActionChanged(this, action); };
void Signal_TargetChanged(QObject * newTarget) { callbackQDrag_TargetChanged(this, newTarget); };
~MyQDrag() { callbackQDrag_DestroyQDrag(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQDrag_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQDrag_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQDrag_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQDrag_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQDrag_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQDrag_CustomEvent(this, event); };
void deleteLater() { callbackQDrag_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQDrag_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQDrag_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQDrag_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQDrag_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQDrag*)
int QDrag_QDrag_QRegisterMetaType(){qRegisterMetaType<QDrag*>(); return qRegisterMetaType<MyQDrag*>();}
void* QDrag_NewQDrag(void* dragSource)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(dragSource))) {
return new MyQDrag(static_cast<QCameraImageCapture*>(dragSource));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(dragSource))) {
return new MyQDrag(static_cast<QDBusPendingCallWatcher*>(dragSource));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(dragSource))) {
return new MyQDrag(static_cast<QExtensionFactory*>(dragSource));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(dragSource))) {
return new MyQDrag(static_cast<QExtensionManager*>(dragSource));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(dragSource))) {
return new MyQDrag(static_cast<QGraphicsObject*>(dragSource));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(dragSource))) {
return new MyQDrag(static_cast<QGraphicsWidget*>(dragSource));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(dragSource))) {
return new MyQDrag(static_cast<QLayout*>(dragSource));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(dragSource))) {
return new MyQDrag(static_cast<QMediaPlaylist*>(dragSource));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(dragSource))) {
return new MyQDrag(static_cast<QMediaRecorder*>(dragSource));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(dragSource))) {
return new MyQDrag(static_cast<QOffscreenSurface*>(dragSource));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(dragSource))) {
return new MyQDrag(static_cast<QPaintDeviceWindow*>(dragSource));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(dragSource))) {
return new MyQDrag(static_cast<QPdfWriter*>(dragSource));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(dragSource))) {
return new MyQDrag(static_cast<QQuickItem*>(dragSource));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(dragSource))) {
return new MyQDrag(static_cast<QRadioData*>(dragSource));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(dragSource))) {
return new MyQDrag(static_cast<QWidget*>(dragSource));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(dragSource))) {
return new MyQDrag(static_cast<QWindow*>(dragSource));
} else {
return new MyQDrag(static_cast<QObject*>(dragSource));
}
}
struct QtGui_PackedString QDrag_QDrag_Tr(char* s, char* c, int n)
{
return ({ QByteArray tf69c2d = QDrag::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(tf69c2d.prepend("WHITESPACE").constData()+10), tf69c2d.size()-10 }; });
}
struct QtGui_PackedString QDrag_QDrag_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray t1ae729 = QDrag::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t1ae729.prepend("WHITESPACE").constData()+10), t1ae729.size()-10 }; });
}
long long QDrag_Exec(void* ptr, long long supportedActions)
{
return static_cast<QDrag*>(ptr)->exec(static_cast<Qt::DropAction>(supportedActions));
}
long long QDrag_Exec2(void* ptr, long long supportedActions, long long defaultDropAction)
{
return static_cast<QDrag*>(ptr)->exec(static_cast<Qt::DropAction>(supportedActions), static_cast<Qt::DropAction>(defaultDropAction));
}
void QDrag_ConnectActionChanged(void* ptr)
{
qRegisterMetaType<Qt::DropAction>();
QObject::connect(static_cast<QDrag*>(ptr), static_cast<void (QDrag::*)(Qt::DropAction)>(&QDrag::actionChanged), static_cast<MyQDrag*>(ptr), static_cast<void (MyQDrag::*)(Qt::DropAction)>(&MyQDrag::Signal_ActionChanged));
}
void QDrag_DisconnectActionChanged(void* ptr)
{
QObject::disconnect(static_cast<QDrag*>(ptr), static_cast<void (QDrag::*)(Qt::DropAction)>(&QDrag::actionChanged), static_cast<MyQDrag*>(ptr), static_cast<void (MyQDrag::*)(Qt::DropAction)>(&MyQDrag::Signal_ActionChanged));
}
void QDrag_ActionChanged(void* ptr, long long action)
{
static_cast<QDrag*>(ptr)->actionChanged(static_cast<Qt::DropAction>(action));
}
void QDrag_QDrag_Cancel()
{
QDrag::cancel();
}
void QDrag_SetDragCursor(void* ptr, void* cursor, long long action)
{
static_cast<QDrag*>(ptr)->setDragCursor(*static_cast<QPixmap*>(cursor), static_cast<Qt::DropAction>(action));
}
void QDrag_SetHotSpot(void* ptr, void* hotspot)
{
static_cast<QDrag*>(ptr)->setHotSpot(*static_cast<QPoint*>(hotspot));
}
void QDrag_SetMimeData(void* ptr, void* data)
{
static_cast<QDrag*>(ptr)->setMimeData(static_cast<QMimeData*>(data));
}
void QDrag_SetPixmap(void* ptr, void* pixmap)
{
static_cast<QDrag*>(ptr)->setPixmap(*static_cast<QPixmap*>(pixmap));
}
void QDrag_ConnectTargetChanged(void* ptr)
{
QObject::connect(static_cast<QDrag*>(ptr), static_cast<void (QDrag::*)(QObject *)>(&QDrag::targetChanged), static_cast<MyQDrag*>(ptr), static_cast<void (MyQDrag::*)(QObject *)>(&MyQDrag::Signal_TargetChanged));
}
void QDrag_DisconnectTargetChanged(void* ptr)
{
QObject::disconnect(static_cast<QDrag*>(ptr), static_cast<void (QDrag::*)(QObject *)>(&QDrag::targetChanged), static_cast<MyQDrag*>(ptr), static_cast<void (MyQDrag::*)(QObject *)>(&MyQDrag::Signal_TargetChanged));
}
void QDrag_TargetChanged(void* ptr, void* newTarget)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(newTarget))) {
static_cast<QDrag*>(ptr)->targetChanged(static_cast<QOffscreenSurface*>(newTarget));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(newTarget))) {
static_cast<QDrag*>(ptr)->targetChanged(static_cast<QPaintDeviceWindow*>(newTarget));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(newTarget))) {
static_cast<QDrag*>(ptr)->targetChanged(static_cast<QPdfWriter*>(newTarget));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(newTarget))) {
static_cast<QDrag*>(ptr)->targetChanged(static_cast<QWindow*>(newTarget));
} else {
static_cast<QDrag*>(ptr)->targetChanged(static_cast<QObject*>(newTarget));
}
}
void QDrag_DestroyQDrag(void* ptr)
{
static_cast<QDrag*>(ptr)->~QDrag();
}
void QDrag_DestroyQDragDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QDrag_MimeData(void* ptr)
{
return static_cast<QDrag*>(ptr)->mimeData();
}
void* QDrag_Source(void* ptr)
{
return static_cast<QDrag*>(ptr)->source();
}
void* QDrag_Target(void* ptr)
{
return static_cast<QDrag*>(ptr)->target();
}
void* QDrag_DragCursor(void* ptr, long long action)
{
return new QPixmap(static_cast<QDrag*>(ptr)->dragCursor(static_cast<Qt::DropAction>(action)));
}
void* QDrag_Pixmap(void* ptr)
{
return new QPixmap(static_cast<QDrag*>(ptr)->pixmap());
}
void* QDrag_HotSpot(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QDrag*>(ptr)->hotSpot(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
long long QDrag_DefaultAction(void* ptr)
{
return static_cast<QDrag*>(ptr)->defaultAction();
}
long long QDrag_SupportedActions(void* ptr)
{
return static_cast<QDrag*>(ptr)->supportedActions();
}
void* QDrag_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QDrag*>(ptr)->QDrag::metaObject());
}
void* QDrag___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QDrag___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QDrag___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QDrag___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QDrag___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QDrag___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QDrag___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QDrag___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QDrag___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QDrag___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QDrag___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QDrag___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QDrag___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QDrag___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QDrag___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QDrag_EventDefault(void* ptr, void* e)
{
return static_cast<QDrag*>(ptr)->QDrag::event(static_cast<QEvent*>(e));
}
char QDrag_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QDrag*>(ptr)->QDrag::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QDrag*>(ptr)->QDrag::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QDrag*>(ptr)->QDrag::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QDrag*>(ptr)->QDrag::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QDrag*>(ptr)->QDrag::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QDrag_ChildEventDefault(void* ptr, void* event)
{
static_cast<QDrag*>(ptr)->QDrag::childEvent(static_cast<QChildEvent*>(event));
}
void QDrag_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QDrag*>(ptr)->QDrag::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QDrag_CustomEventDefault(void* ptr, void* event)
{
static_cast<QDrag*>(ptr)->QDrag::customEvent(static_cast<QEvent*>(event));
}
void QDrag_DeleteLaterDefault(void* ptr)
{
static_cast<QDrag*>(ptr)->QDrag::deleteLater();
}
void QDrag_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QDrag*>(ptr)->QDrag::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QDrag_TimerEventDefault(void* ptr, void* event)
{
static_cast<QDrag*>(ptr)->QDrag::timerEvent(static_cast<QTimerEvent*>(event));
}
class MyQDragEnterEvent: public QDragEnterEvent
{
public:
MyQDragEnterEvent(const QPoint &point, Qt::DropActions actions, const QMimeData *data, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers) : QDragEnterEvent(point, actions, data, buttons, modifiers) {};
};
void* QDragEnterEvent_NewQDragEnterEvent(void* point, long long actions, void* data, long long buttons, long long modifiers)
{
return new MyQDragEnterEvent(*static_cast<QPoint*>(point), static_cast<Qt::DropAction>(actions), static_cast<QMimeData*>(data), static_cast<Qt::MouseButton>(buttons), static_cast<Qt::KeyboardModifier>(modifiers));
}
class MyQDragLeaveEvent: public QDragLeaveEvent
{
public:
MyQDragLeaveEvent() : QDragLeaveEvent() {};
};
void* QDragLeaveEvent_NewQDragLeaveEvent()
{
return new MyQDragLeaveEvent();
}
class MyQDragMoveEvent: public QDragMoveEvent
{
public:
MyQDragMoveEvent(const QPoint &pos, Qt::DropActions actions, const QMimeData *data, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, QEvent::Type ty = DragMove) : QDragMoveEvent(pos, actions, data, buttons, modifiers, ty) {};
~MyQDragMoveEvent() { callbackQDragMoveEvent_DestroyQDragMoveEvent(this); };
};
void* QDragMoveEvent_NewQDragMoveEvent(void* pos, long long actions, void* data, long long buttons, long long modifiers, long long ty)
{
return new MyQDragMoveEvent(*static_cast<QPoint*>(pos), static_cast<Qt::DropAction>(actions), static_cast<QMimeData*>(data), static_cast<Qt::MouseButton>(buttons), static_cast<Qt::KeyboardModifier>(modifiers), static_cast<QEvent::Type>(ty));
}
void QDragMoveEvent_Accept(void* ptr, void* rectangle)
{
static_cast<QDragMoveEvent*>(ptr)->accept(*static_cast<QRect*>(rectangle));
}
void QDragMoveEvent_Ignore(void* ptr, void* rectangle)
{
static_cast<QDragMoveEvent*>(ptr)->ignore(*static_cast<QRect*>(rectangle));
}
void QDragMoveEvent_DestroyQDragMoveEvent(void* ptr)
{
static_cast<QDragMoveEvent*>(ptr)->~QDragMoveEvent();
}
void QDragMoveEvent_DestroyQDragMoveEventDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QDragMoveEvent_AnswerRect(void* ptr)
{
return ({ QRect tmpValue = static_cast<QDragMoveEvent*>(ptr)->answerRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QDragMoveEvent_Rect(void* ptr)
{
return ({ QRect tmpValue = static_cast<QDragMoveEvent*>(ptr)->rect; new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void QDragMoveEvent_SetRect(void* ptr, void* vqr)
{
static_cast<QDragMoveEvent*>(ptr)->rect = *static_cast<QRect*>(vqr);
}
class MyQDropEvent: public QDropEvent
{
public:
MyQDropEvent(const QPointF &pos, Qt::DropActions actions, const QMimeData *data, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, QEvent::Type ty = Drop) : QDropEvent(pos, actions, data, buttons, modifiers, ty) {};
};
void* QDropEvent_NewQDropEvent(void* pos, long long actions, void* data, long long buttons, long long modifiers, long long ty)
{
return new MyQDropEvent(*static_cast<QPointF*>(pos), static_cast<Qt::DropAction>(actions), static_cast<QMimeData*>(data), static_cast<Qt::MouseButton>(buttons), static_cast<Qt::KeyboardModifier>(modifiers), static_cast<QEvent::Type>(ty));
}
void QDropEvent_AcceptProposedAction(void* ptr)
{
static_cast<QDropEvent*>(ptr)->acceptProposedAction();
}
void QDropEvent_SetDropAction(void* ptr, long long action)
{
static_cast<QDropEvent*>(ptr)->setDropAction(static_cast<Qt::DropAction>(action));
}
void* QDropEvent_Source(void* ptr)
{
return static_cast<QDropEvent*>(ptr)->source();
}
void* QDropEvent_Pos(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QDropEvent*>(ptr)->pos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
long long QDropEvent_DropAction(void* ptr)
{
return static_cast<QDropEvent*>(ptr)->dropAction();
}
long long QDropEvent_ProposedAction(void* ptr)
{
return static_cast<QDropEvent*>(ptr)->proposedAction();
}
long long QDropEvent_PossibleActions(void* ptr)
{
return static_cast<QDropEvent*>(ptr)->possibleActions();
}
long long QDropEvent_KeyboardModifiers(void* ptr)
{
return static_cast<QDropEvent*>(ptr)->keyboardModifiers();
}
long long QDropEvent_MouseButtons(void* ptr)
{
return static_cast<QDropEvent*>(ptr)->mouseButtons();
}
void* QDropEvent_MimeData(void* ptr)
{
return const_cast<QMimeData*>(static_cast<QDropEvent*>(ptr)->mimeData());
}
void* QDropEvent_PosF(void* ptr)
{
return const_cast<QPointF*>(&static_cast<QDropEvent*>(ptr)->posF());
}
long long QDropEvent_Act(void* ptr)
{
return static_cast<QDropEvent*>(ptr)->act;
}
void QDropEvent_SetAct(void* ptr, long long vqt)
{
static_cast<QDropEvent*>(ptr)->act = static_cast<Qt::DropAction>(vqt);
}
long long QDropEvent_Default_action(void* ptr)
{
return static_cast<QDropEvent*>(ptr)->default_action;
}
void QDropEvent_SetDefault_action(void* ptr, long long vqt)
{
static_cast<QDropEvent*>(ptr)->default_action = static_cast<Qt::DropAction>(vqt);
}
long long QDropEvent_Drop_action(void* ptr)
{
return static_cast<QDropEvent*>(ptr)->drop_action;
}
void QDropEvent_SetDrop_action(void* ptr, long long vqt)
{
static_cast<QDropEvent*>(ptr)->drop_action = static_cast<Qt::DropAction>(vqt);
}
void* QDropEvent_Mdata(void* ptr)
{
return const_cast<QMimeData*>(static_cast<QDropEvent*>(ptr)->mdata);
}
long long QDropEvent_ModState(void* ptr)
{
return static_cast<QDropEvent*>(ptr)->modState;
}
void QDropEvent_SetModState(void* ptr, long long vqt)
{
static_cast<QDropEvent*>(ptr)->modState = static_cast<Qt::KeyboardModifier>(vqt);
}
long long QDropEvent_MouseState(void* ptr)
{
return static_cast<QDropEvent*>(ptr)->mouseState;
}
void QDropEvent_SetMouseState(void* ptr, long long vqt)
{
static_cast<QDropEvent*>(ptr)->mouseState = static_cast<Qt::MouseButton>(vqt);
}
void* QDropEvent_P(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QDropEvent*>(ptr)->p; new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QDropEvent_SetP(void* ptr, void* vqp)
{
static_cast<QDropEvent*>(ptr)->p = *static_cast<QPointF*>(vqp);
}
class MyQEnterEvent: public QEnterEvent
{
public:
MyQEnterEvent(const QPointF &localPos, const QPointF &windowPos, const QPointF &screenPos) : QEnterEvent(localPos, windowPos, screenPos) {};
};
void* QEnterEvent_NewQEnterEvent(void* localPos, void* windowPos, void* screenPos)
{
return new MyQEnterEvent(*static_cast<QPointF*>(localPos), *static_cast<QPointF*>(windowPos), *static_cast<QPointF*>(screenPos));
}
void* QEnterEvent_GlobalPos(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QEnterEvent*>(ptr)->globalPos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QEnterEvent_Pos(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QEnterEvent*>(ptr)->pos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QEnterEvent_LocalPos(void* ptr)
{
return const_cast<QPointF*>(&static_cast<QEnterEvent*>(ptr)->localPos());
}
void* QEnterEvent_ScreenPos(void* ptr)
{
return const_cast<QPointF*>(&static_cast<QEnterEvent*>(ptr)->screenPos());
}
void* QEnterEvent_WindowPos(void* ptr)
{
return const_cast<QPointF*>(&static_cast<QEnterEvent*>(ptr)->windowPos());
}
int QEnterEvent_GlobalX(void* ptr)
{
return static_cast<QEnterEvent*>(ptr)->globalX();
}
int QEnterEvent_GlobalY(void* ptr)
{
return static_cast<QEnterEvent*>(ptr)->globalY();
}
int QEnterEvent_X(void* ptr)
{
return static_cast<QEnterEvent*>(ptr)->x();
}
int QEnterEvent_Y(void* ptr)
{
return static_cast<QEnterEvent*>(ptr)->y();
}
void* QEnterEvent_L(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QEnterEvent*>(ptr)->l; new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QEnterEvent_SetL(void* ptr, void* vqp)
{
static_cast<QEnterEvent*>(ptr)->l = *static_cast<QPointF*>(vqp);
}
void* QEnterEvent_S(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QEnterEvent*>(ptr)->s; new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QEnterEvent_SetS(void* ptr, void* vqp)
{
static_cast<QEnterEvent*>(ptr)->s = *static_cast<QPointF*>(vqp);
}
void* QEnterEvent_W(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QEnterEvent*>(ptr)->w; new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QEnterEvent_SetW(void* ptr, void* vqp)
{
static_cast<QEnterEvent*>(ptr)->w = *static_cast<QPointF*>(vqp);
}
class MyQExposeEvent: public QExposeEvent
{
public:
MyQExposeEvent(const QRegion &exposeRegion) : QExposeEvent(exposeRegion) {};
};
void* QExposeEvent_NewQExposeEvent(void* exposeRegion)
{
return new MyQExposeEvent(*static_cast<QRegion*>(exposeRegion));
}
void* QExposeEvent_Region(void* ptr)
{
return const_cast<QRegion*>(&static_cast<QExposeEvent*>(ptr)->region());
}
void* QExposeEvent_Rgn(void* ptr)
{
return new QRegion(static_cast<QExposeEvent*>(ptr)->rgn);
}
void QExposeEvent_SetRgn(void* ptr, void* vqr)
{
static_cast<QExposeEvent*>(ptr)->rgn = *static_cast<QRegion*>(vqr);
}
class MyQFileOpenEvent: public QFileOpenEvent
{
public:
};
struct QtGui_PackedString QFileOpenEvent_File(void* ptr)
{
return ({ QByteArray t25f76f = static_cast<QFileOpenEvent*>(ptr)->file().toUtf8(); QtGui_PackedString { const_cast<char*>(t25f76f.prepend("WHITESPACE").constData()+10), t25f76f.size()-10 }; });
}
void* QFileOpenEvent_Url(void* ptr)
{
return new QUrl(static_cast<QFileOpenEvent*>(ptr)->url());
}
char QFileOpenEvent_OpenFile(void* ptr, void* file, long long flags)
{
return static_cast<QFileOpenEvent*>(ptr)->openFile(*static_cast<QFile*>(file), static_cast<QIODevice::OpenModeFlag>(flags));
}
class MyQFocusEvent: public QFocusEvent
{
public:
MyQFocusEvent(QEvent::Type ty, Qt::FocusReason reason = Qt::OtherFocusReason) : QFocusEvent(ty, reason) {};
};
void* QFocusEvent_NewQFocusEvent(long long ty, long long reason)
{
return new MyQFocusEvent(static_cast<QEvent::Type>(ty), static_cast<Qt::FocusReason>(reason));
}
long long QFocusEvent_Reason(void* ptr)
{
return static_cast<QFocusEvent*>(ptr)->reason();
}
char QFocusEvent_GotFocus(void* ptr)
{
return static_cast<QFocusEvent*>(ptr)->gotFocus();
}
char QFocusEvent_LostFocus(void* ptr)
{
return static_cast<QFocusEvent*>(ptr)->lostFocus();
}
void* QFont_NewQFont()
{
return new QFont();
}
void* QFont_NewQFont4(void* font)
{
return new QFont(*static_cast<QFont*>(font));
}
void* QFont_NewQFont3(void* font, void* pd)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(pd))) {
return new QFont(*static_cast<QFont*>(font), static_cast<QPaintDeviceWindow*>(pd));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(pd))) {
return new QFont(*static_cast<QFont*>(font), static_cast<QPdfWriter*>(pd));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(pd))) {
return new QFont(*static_cast<QFont*>(font), static_cast<QWidget*>(pd));
} else {
return new QFont(*static_cast<QFont*>(font), static_cast<QPaintDevice*>(pd));
}
}
void* QFont_NewQFont2(struct QtGui_PackedString family, int pointSize, int weight, char italic)
{
return new QFont(QString::fromUtf8(family.data, family.len), pointSize, weight, italic != 0);
}
struct QtGui_PackedString QFont_QFont_Substitute(struct QtGui_PackedString familyName)
{
return ({ QByteArray tf3cb14 = QFont::substitute(QString::fromUtf8(familyName.data, familyName.len)).toUtf8(); QtGui_PackedString { const_cast<char*>(tf3cb14.prepend("WHITESPACE").constData()+10), tf3cb14.size()-10 }; });
}
struct QtGui_PackedString QFont_QFont_Substitutes(struct QtGui_PackedString familyName)
{
return ({ QByteArray t1934ac = QFont::substitutes(QString::fromUtf8(familyName.data, familyName.len)).join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t1934ac.prepend("WHITESPACE").constData()+10), t1934ac.size()-10 }; });
}
struct QtGui_PackedString QFont_QFont_Substitutions()
{
return ({ QByteArray t300c5a = QFont::substitutions().join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t300c5a.prepend("WHITESPACE").constData()+10), t300c5a.size()-10 }; });
}
char QFont_FromString(void* ptr, struct QtGui_PackedString descrip)
{
return static_cast<QFont*>(ptr)->fromString(QString::fromUtf8(descrip.data, descrip.len));
}
void QFont_QFont_InsertSubstitution(struct QtGui_PackedString familyName, struct QtGui_PackedString substituteName)
{
QFont::insertSubstitution(QString::fromUtf8(familyName.data, familyName.len), QString::fromUtf8(substituteName.data, substituteName.len));
}
void QFont_QFont_InsertSubstitutions(struct QtGui_PackedString familyName, struct QtGui_PackedString substituteNames)
{
QFont::insertSubstitutions(QString::fromUtf8(familyName.data, familyName.len), QString::fromUtf8(substituteNames.data, substituteNames.len).split("|", QString::SkipEmptyParts));
}
void QFont_QFont_RemoveSubstitutions(struct QtGui_PackedString familyName)
{
QFont::removeSubstitutions(QString::fromUtf8(familyName.data, familyName.len));
}
void QFont_SetBold(void* ptr, char enable)
{
static_cast<QFont*>(ptr)->setBold(enable != 0);
}
void QFont_SetCapitalization(void* ptr, long long caps)
{
static_cast<QFont*>(ptr)->setCapitalization(static_cast<QFont::Capitalization>(caps));
}
void QFont_SetFamily(void* ptr, struct QtGui_PackedString family)
{
static_cast<QFont*>(ptr)->setFamily(QString::fromUtf8(family.data, family.len));
}
void QFont_SetFixedPitch(void* ptr, char enable)
{
static_cast<QFont*>(ptr)->setFixedPitch(enable != 0);
}
void QFont_SetHintingPreference(void* ptr, long long hintingPreference)
{
static_cast<QFont*>(ptr)->setHintingPreference(static_cast<QFont::HintingPreference>(hintingPreference));
}
void QFont_SetItalic(void* ptr, char enable)
{
static_cast<QFont*>(ptr)->setItalic(enable != 0);
}
void QFont_SetKerning(void* ptr, char enable)
{
static_cast<QFont*>(ptr)->setKerning(enable != 0);
}
void QFont_SetLetterSpacing(void* ptr, long long ty, double spacing)
{
static_cast<QFont*>(ptr)->setLetterSpacing(static_cast<QFont::SpacingType>(ty), spacing);
}
void QFont_SetOverline(void* ptr, char enable)
{
static_cast<QFont*>(ptr)->setOverline(enable != 0);
}
void QFont_SetPixelSize(void* ptr, int pixelSize)
{
static_cast<QFont*>(ptr)->setPixelSize(pixelSize);
}
void QFont_SetPointSize(void* ptr, int pointSize)
{
static_cast<QFont*>(ptr)->setPointSize(pointSize);
}
void QFont_SetPointSizeF(void* ptr, double pointSize)
{
static_cast<QFont*>(ptr)->setPointSizeF(pointSize);
}
void QFont_SetStretch(void* ptr, int factor)
{
static_cast<QFont*>(ptr)->setStretch(factor);
}
void QFont_SetStrikeOut(void* ptr, char enable)
{
static_cast<QFont*>(ptr)->setStrikeOut(enable != 0);
}
void QFont_SetStyle(void* ptr, long long style)
{
static_cast<QFont*>(ptr)->setStyle(static_cast<QFont::Style>(style));
}
void QFont_SetStyleHint(void* ptr, long long hint, long long strategy)
{
static_cast<QFont*>(ptr)->setStyleHint(static_cast<QFont::StyleHint>(hint), static_cast<QFont::StyleStrategy>(strategy));
}
void QFont_SetStyleName(void* ptr, struct QtGui_PackedString styleName)
{
static_cast<QFont*>(ptr)->setStyleName(QString::fromUtf8(styleName.data, styleName.len));
}
void QFont_SetStyleStrategy(void* ptr, long long s)
{
static_cast<QFont*>(ptr)->setStyleStrategy(static_cast<QFont::StyleStrategy>(s));
}
void QFont_SetUnderline(void* ptr, char enable)
{
static_cast<QFont*>(ptr)->setUnderline(enable != 0);
}
void QFont_SetWeight(void* ptr, int weight)
{
static_cast<QFont*>(ptr)->setWeight(weight);
}
void QFont_SetWordSpacing(void* ptr, double spacing)
{
static_cast<QFont*>(ptr)->setWordSpacing(spacing);
}
void QFont_Swap(void* ptr, void* other)
{
static_cast<QFont*>(ptr)->swap(*static_cast<QFont*>(other));
}
void QFont_DestroyQFont(void* ptr)
{
static_cast<QFont*>(ptr)->~QFont();
}
void* QFont_Resolve(void* ptr, void* other)
{
return new QFont(static_cast<QFont*>(ptr)->resolve(*static_cast<QFont*>(other)));
}
long long QFont_Capitalization(void* ptr)
{
return static_cast<QFont*>(ptr)->capitalization();
}
long long QFont_HintingPreference(void* ptr)
{
return static_cast<QFont*>(ptr)->hintingPreference();
}
long long QFont_LetterSpacingType(void* ptr)
{
return static_cast<QFont*>(ptr)->letterSpacingType();
}
long long QFont_Style(void* ptr)
{
return static_cast<QFont*>(ptr)->style();
}
long long QFont_StyleHint(void* ptr)
{
return static_cast<QFont*>(ptr)->styleHint();
}
long long QFont_StyleStrategy(void* ptr)
{
return static_cast<QFont*>(ptr)->styleStrategy();
}
struct QtGui_PackedString QFont_DefaultFamily(void* ptr)
{
return ({ QByteArray t141ea0 = static_cast<QFont*>(ptr)->defaultFamily().toUtf8(); QtGui_PackedString { const_cast<char*>(t141ea0.prepend("WHITESPACE").constData()+10), t141ea0.size()-10 }; });
}
struct QtGui_PackedString QFont_Family(void* ptr)
{
return ({ QByteArray t52247e = static_cast<QFont*>(ptr)->family().toUtf8(); QtGui_PackedString { const_cast<char*>(t52247e.prepend("WHITESPACE").constData()+10), t52247e.size()-10 }; });
}
struct QtGui_PackedString QFont_Key(void* ptr)
{
return ({ QByteArray t9324a4 = static_cast<QFont*>(ptr)->key().toUtf8(); QtGui_PackedString { const_cast<char*>(t9324a4.prepend("WHITESPACE").constData()+10), t9324a4.size()-10 }; });
}
struct QtGui_PackedString QFont_LastResortFamily(void* ptr)
{
return ({ QByteArray t483f1f = static_cast<QFont*>(ptr)->lastResortFamily().toUtf8(); QtGui_PackedString { const_cast<char*>(t483f1f.prepend("WHITESPACE").constData()+10), t483f1f.size()-10 }; });
}
struct QtGui_PackedString QFont_LastResortFont(void* ptr)
{
return ({ QByteArray td93362 = static_cast<QFont*>(ptr)->lastResortFont().toUtf8(); QtGui_PackedString { const_cast<char*>(td93362.prepend("WHITESPACE").constData()+10), td93362.size()-10 }; });
}
struct QtGui_PackedString QFont_StyleName(void* ptr)
{
return ({ QByteArray t8d3474 = static_cast<QFont*>(ptr)->styleName().toUtf8(); QtGui_PackedString { const_cast<char*>(t8d3474.prepend("WHITESPACE").constData()+10), t8d3474.size()-10 }; });
}
struct QtGui_PackedString QFont_ToString(void* ptr)
{
return ({ QByteArray t32ab86 = static_cast<QFont*>(ptr)->toString().toUtf8(); QtGui_PackedString { const_cast<char*>(t32ab86.prepend("WHITESPACE").constData()+10), t32ab86.size()-10 }; });
}
char QFont_Bold(void* ptr)
{
return static_cast<QFont*>(ptr)->bold();
}
char QFont_ExactMatch(void* ptr)
{
return static_cast<QFont*>(ptr)->exactMatch();
}
char QFont_FixedPitch(void* ptr)
{
return static_cast<QFont*>(ptr)->fixedPitch();
}
char QFont_IsCopyOf(void* ptr, void* fo)
{
return static_cast<QFont*>(ptr)->isCopyOf(*static_cast<QFont*>(fo));
}
char QFont_Italic(void* ptr)
{
return static_cast<QFont*>(ptr)->italic();
}
char QFont_Kerning(void* ptr)
{
return static_cast<QFont*>(ptr)->kerning();
}
char QFont_Overline(void* ptr)
{
return static_cast<QFont*>(ptr)->overline();
}
char QFont_StrikeOut(void* ptr)
{
return static_cast<QFont*>(ptr)->strikeOut();
}
char QFont_Underline(void* ptr)
{
return static_cast<QFont*>(ptr)->underline();
}
int QFont_PixelSize(void* ptr)
{
return static_cast<QFont*>(ptr)->pixelSize();
}
int QFont_PointSize(void* ptr)
{
return static_cast<QFont*>(ptr)->pointSize();
}
int QFont_Stretch(void* ptr)
{
return static_cast<QFont*>(ptr)->stretch();
}
int QFont_Weight(void* ptr)
{
return static_cast<QFont*>(ptr)->weight();
}
double QFont_LetterSpacing(void* ptr)
{
return static_cast<QFont*>(ptr)->letterSpacing();
}
double QFont_PointSizeF(void* ptr)
{
return static_cast<QFont*>(ptr)->pointSizeF();
}
double QFont_WordSpacing(void* ptr)
{
return static_cast<QFont*>(ptr)->wordSpacing();
}
void* QFont_ToVariant(void* ptr)
{
return new QVariant(*static_cast<QFont*>(ptr));
}
void* QFontDatabase_QFontDatabase_SystemFont(long long ty)
{
return new QFont(QFontDatabase::systemFont(static_cast<QFontDatabase::SystemFont>(ty)));
}
void* QFontDatabase_NewQFontDatabase()
{
return new QFontDatabase();
}
struct QtGui_PackedList QFontDatabase_PointSizes(void* ptr, struct QtGui_PackedString family, struct QtGui_PackedString styleName)
{
return ({ QList<int>* tmpValue = new QList<int>(static_cast<QFontDatabase*>(ptr)->pointSizes(QString::fromUtf8(family.data, family.len), QString::fromUtf8(styleName.data, styleName.len))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedList QFontDatabase_SmoothSizes(void* ptr, struct QtGui_PackedString family, struct QtGui_PackedString styleName)
{
return ({ QList<int>* tmpValue = new QList<int>(static_cast<QFontDatabase*>(ptr)->smoothSizes(QString::fromUtf8(family.data, family.len), QString::fromUtf8(styleName.data, styleName.len))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedList QFontDatabase_QFontDatabase_StandardSizes()
{
return ({ QList<int>* tmpValue = new QList<int>(QFontDatabase::standardSizes()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedString QFontDatabase_StyleString(void* ptr, void* font)
{
return ({ QByteArray tdc7da2 = static_cast<QFontDatabase*>(ptr)->styleString(*static_cast<QFont*>(font)).toUtf8(); QtGui_PackedString { const_cast<char*>(tdc7da2.prepend("WHITESPACE").constData()+10), tdc7da2.size()-10 }; });
}
struct QtGui_PackedString QFontDatabase_StyleString2(void* ptr, void* fontInfo)
{
return ({ QByteArray t17e039 = static_cast<QFontDatabase*>(ptr)->styleString(*static_cast<QFontInfo*>(fontInfo)).toUtf8(); QtGui_PackedString { const_cast<char*>(t17e039.prepend("WHITESPACE").constData()+10), t17e039.size()-10 }; });
}
struct QtGui_PackedString QFontDatabase_QFontDatabase_ApplicationFontFamilies(int id)
{
return ({ QByteArray tf75c72 = QFontDatabase::applicationFontFamilies(id).join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(tf75c72.prepend("WHITESPACE").constData()+10), tf75c72.size()-10 }; });
}
char QFontDatabase_QFontDatabase_RemoveAllApplicationFonts()
{
return QFontDatabase::removeAllApplicationFonts();
}
char QFontDatabase_QFontDatabase_RemoveApplicationFont(int id)
{
return QFontDatabase::removeApplicationFont(id);
}
int QFontDatabase_QFontDatabase_AddApplicationFont(struct QtGui_PackedString fileName)
{
return QFontDatabase::addApplicationFont(QString::fromUtf8(fileName.data, fileName.len));
}
int QFontDatabase_QFontDatabase_AddApplicationFontFromData(void* fontData)
{
return QFontDatabase::addApplicationFontFromData(*static_cast<QByteArray*>(fontData));
}
void* QFontDatabase_Font(void* ptr, struct QtGui_PackedString family, struct QtGui_PackedString style, int pointSize)
{
return new QFont(static_cast<QFontDatabase*>(ptr)->font(QString::fromUtf8(family.data, family.len), QString::fromUtf8(style.data, style.len), pointSize));
}
struct QtGui_PackedString QFontDatabase_Families(void* ptr, long long writingSystem)
{
return ({ QByteArray t8f80b0 = static_cast<QFontDatabase*>(ptr)->families(static_cast<QFontDatabase::WritingSystem>(writingSystem)).join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t8f80b0.prepend("WHITESPACE").constData()+10), t8f80b0.size()-10 }; });
}
struct QtGui_PackedString QFontDatabase_Styles(void* ptr, struct QtGui_PackedString family)
{
return ({ QByteArray ta1e1bf = static_cast<QFontDatabase*>(ptr)->styles(QString::fromUtf8(family.data, family.len)).join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(ta1e1bf.prepend("WHITESPACE").constData()+10), ta1e1bf.size()-10 }; });
}
char QFontDatabase_Bold(void* ptr, struct QtGui_PackedString family, struct QtGui_PackedString style)
{
return static_cast<QFontDatabase*>(ptr)->bold(QString::fromUtf8(family.data, family.len), QString::fromUtf8(style.data, style.len));
}
char QFontDatabase_IsBitmapScalable(void* ptr, struct QtGui_PackedString family, struct QtGui_PackedString style)
{
return static_cast<QFontDatabase*>(ptr)->isBitmapScalable(QString::fromUtf8(family.data, family.len), QString::fromUtf8(style.data, style.len));
}
char QFontDatabase_IsFixedPitch(void* ptr, struct QtGui_PackedString family, struct QtGui_PackedString style)
{
return static_cast<QFontDatabase*>(ptr)->isFixedPitch(QString::fromUtf8(family.data, family.len), QString::fromUtf8(style.data, style.len));
}
char QFontDatabase_IsPrivateFamily(void* ptr, struct QtGui_PackedString family)
{
return static_cast<QFontDatabase*>(ptr)->isPrivateFamily(QString::fromUtf8(family.data, family.len));
}
char QFontDatabase_IsScalable(void* ptr, struct QtGui_PackedString family, struct QtGui_PackedString style)
{
return static_cast<QFontDatabase*>(ptr)->isScalable(QString::fromUtf8(family.data, family.len), QString::fromUtf8(style.data, style.len));
}
char QFontDatabase_IsSmoothlyScalable(void* ptr, struct QtGui_PackedString family, struct QtGui_PackedString style)
{
return static_cast<QFontDatabase*>(ptr)->isSmoothlyScalable(QString::fromUtf8(family.data, family.len), QString::fromUtf8(style.data, style.len));
}
char QFontDatabase_Italic(void* ptr, struct QtGui_PackedString family, struct QtGui_PackedString style)
{
return static_cast<QFontDatabase*>(ptr)->italic(QString::fromUtf8(family.data, family.len), QString::fromUtf8(style.data, style.len));
}
int QFontDatabase_Weight(void* ptr, struct QtGui_PackedString family, struct QtGui_PackedString style)
{
return static_cast<QFontDatabase*>(ptr)->weight(QString::fromUtf8(family.data, family.len), QString::fromUtf8(style.data, style.len));
}
int QFontDatabase___pointSizes_atList(void* ptr, int i)
{
return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QFontDatabase___pointSizes_setList(void* ptr, int i)
{
static_cast<QList<int>*>(ptr)->append(i);
}
void* QFontDatabase___pointSizes_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<int>();
}
int QFontDatabase___smoothSizes_atList(void* ptr, int i)
{
return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QFontDatabase___smoothSizes_setList(void* ptr, int i)
{
static_cast<QList<int>*>(ptr)->append(i);
}
void* QFontDatabase___smoothSizes_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<int>();
}
int QFontDatabase___standardSizes_atList(void* ptr, int i)
{
return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QFontDatabase___standardSizes_setList(void* ptr, int i)
{
static_cast<QList<int>*>(ptr)->append(i);
}
void* QFontDatabase___standardSizes_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<int>();
}
void* QFontInfo_NewQFontInfo(void* font)
{
return new QFontInfo(*static_cast<QFont*>(font));
}
void* QFontInfo_NewQFontInfo2(void* fi)
{
return new QFontInfo(*static_cast<QFontInfo*>(fi));
}
void QFontInfo_Swap(void* ptr, void* other)
{
static_cast<QFontInfo*>(ptr)->swap(*static_cast<QFontInfo*>(other));
}
void QFontInfo_DestroyQFontInfo(void* ptr)
{
static_cast<QFontInfo*>(ptr)->~QFontInfo();
}
long long QFontInfo_Style(void* ptr)
{
return static_cast<QFontInfo*>(ptr)->style();
}
long long QFontInfo_StyleHint(void* ptr)
{
return static_cast<QFontInfo*>(ptr)->styleHint();
}
struct QtGui_PackedString QFontInfo_Family(void* ptr)
{
return ({ QByteArray t7b458f = static_cast<QFontInfo*>(ptr)->family().toUtf8(); QtGui_PackedString { const_cast<char*>(t7b458f.prepend("WHITESPACE").constData()+10), t7b458f.size()-10 }; });
}
struct QtGui_PackedString QFontInfo_StyleName(void* ptr)
{
return ({ QByteArray t231b30 = static_cast<QFontInfo*>(ptr)->styleName().toUtf8(); QtGui_PackedString { const_cast<char*>(t231b30.prepend("WHITESPACE").constData()+10), t231b30.size()-10 }; });
}
char QFontInfo_Bold(void* ptr)
{
return static_cast<QFontInfo*>(ptr)->bold();
}
char QFontInfo_ExactMatch(void* ptr)
{
return static_cast<QFontInfo*>(ptr)->exactMatch();
}
char QFontInfo_FixedPitch(void* ptr)
{
return static_cast<QFontInfo*>(ptr)->fixedPitch();
}
char QFontInfo_Italic(void* ptr)
{
return static_cast<QFontInfo*>(ptr)->italic();
}
int QFontInfo_PixelSize(void* ptr)
{
return static_cast<QFontInfo*>(ptr)->pixelSize();
}
int QFontInfo_PointSize(void* ptr)
{
return static_cast<QFontInfo*>(ptr)->pointSize();
}
int QFontInfo_Weight(void* ptr)
{
return static_cast<QFontInfo*>(ptr)->weight();
}
double QFontInfo_PointSizeF(void* ptr)
{
return static_cast<QFontInfo*>(ptr)->pointSizeF();
}
void* QFontMetrics_NewQFontMetrics(void* font)
{
return new QFontMetrics(*static_cast<QFont*>(font));
}
void* QFontMetrics_NewQFontMetrics2(void* font, void* paintdevice)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(paintdevice))) {
return new QFontMetrics(*static_cast<QFont*>(font), static_cast<QPaintDeviceWindow*>(paintdevice));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(paintdevice))) {
return new QFontMetrics(*static_cast<QFont*>(font), static_cast<QPdfWriter*>(paintdevice));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(paintdevice))) {
return new QFontMetrics(*static_cast<QFont*>(font), static_cast<QWidget*>(paintdevice));
} else {
return new QFontMetrics(*static_cast<QFont*>(font), static_cast<QPaintDevice*>(paintdevice));
}
}
void* QFontMetrics_NewQFontMetrics3(void* fm)
{
return new QFontMetrics(*static_cast<QFontMetrics*>(fm));
}
void QFontMetrics_Swap(void* ptr, void* other)
{
static_cast<QFontMetrics*>(ptr)->swap(*static_cast<QFontMetrics*>(other));
}
void QFontMetrics_DestroyQFontMetrics(void* ptr)
{
static_cast<QFontMetrics*>(ptr)->~QFontMetrics();
}
void* QFontMetrics_BoundingRect(void* ptr, void* ch)
{
return ({ QRect tmpValue = static_cast<QFontMetrics*>(ptr)->boundingRect(*static_cast<QChar*>(ch)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QFontMetrics_BoundingRect3(void* ptr, void* rect, int flags, struct QtGui_PackedString text, int tabStops, int tabArray)
{
return ({ QRect tmpValue = static_cast<QFontMetrics*>(ptr)->boundingRect(*static_cast<QRect*>(rect), flags, QString::fromUtf8(text.data, text.len), tabStops, &tabArray); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QFontMetrics_BoundingRect2(void* ptr, struct QtGui_PackedString text)
{
return ({ QRect tmpValue = static_cast<QFontMetrics*>(ptr)->boundingRect(QString::fromUtf8(text.data, text.len)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QFontMetrics_BoundingRect4(void* ptr, int x, int y, int width, int height, int flags, struct QtGui_PackedString text, int tabStops, int tabArray)
{
return ({ QRect tmpValue = static_cast<QFontMetrics*>(ptr)->boundingRect(x, y, width, height, flags, QString::fromUtf8(text.data, text.len), tabStops, &tabArray); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QFontMetrics_TightBoundingRect(void* ptr, struct QtGui_PackedString text)
{
return ({ QRect tmpValue = static_cast<QFontMetrics*>(ptr)->tightBoundingRect(QString::fromUtf8(text.data, text.len)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QFontMetrics_Size(void* ptr, int flags, struct QtGui_PackedString text, int tabStops, int tabArray)
{
return ({ QSize tmpValue = static_cast<QFontMetrics*>(ptr)->size(flags, QString::fromUtf8(text.data, text.len), tabStops, &tabArray); new QSize(tmpValue.width(), tmpValue.height()); });
}
struct QtGui_PackedString QFontMetrics_ElidedText(void* ptr, struct QtGui_PackedString text, long long mode, int width, int flags)
{
return ({ QByteArray tff5810 = static_cast<QFontMetrics*>(ptr)->elidedText(QString::fromUtf8(text.data, text.len), static_cast<Qt::TextElideMode>(mode), width, flags).toUtf8(); QtGui_PackedString { const_cast<char*>(tff5810.prepend("WHITESPACE").constData()+10), tff5810.size()-10 }; });
}
char QFontMetrics_InFont(void* ptr, void* ch)
{
return static_cast<QFontMetrics*>(ptr)->inFont(*static_cast<QChar*>(ch));
}
char QFontMetrics_InFontUcs4(void* ptr, unsigned int ucs4)
{
return static_cast<QFontMetrics*>(ptr)->inFontUcs4(ucs4);
}
int QFontMetrics_Ascent(void* ptr)
{
return static_cast<QFontMetrics*>(ptr)->ascent();
}
int QFontMetrics_AverageCharWidth(void* ptr)
{
return static_cast<QFontMetrics*>(ptr)->averageCharWidth();
}
int QFontMetrics_CapHeight(void* ptr)
{
return static_cast<QFontMetrics*>(ptr)->capHeight();
}
int QFontMetrics_Descent(void* ptr)
{
return static_cast<QFontMetrics*>(ptr)->descent();
}
int QFontMetrics_Height(void* ptr)
{
return static_cast<QFontMetrics*>(ptr)->height();
}
int QFontMetrics_HorizontalAdvance2(void* ptr, void* ch)
{
return static_cast<QFontMetrics*>(ptr)->horizontalAdvance(*static_cast<QChar*>(ch));
}
int QFontMetrics_HorizontalAdvance(void* ptr, struct QtGui_PackedString text, int l)
{
return static_cast<QFontMetrics*>(ptr)->horizontalAdvance(QString::fromUtf8(text.data, text.len), l);
}
int QFontMetrics_Leading(void* ptr)
{
return static_cast<QFontMetrics*>(ptr)->leading();
}
int QFontMetrics_LeftBearing(void* ptr, void* ch)
{
return static_cast<QFontMetrics*>(ptr)->leftBearing(*static_cast<QChar*>(ch));
}
int QFontMetrics_LineSpacing(void* ptr)
{
return static_cast<QFontMetrics*>(ptr)->lineSpacing();
}
int QFontMetrics_LineWidth(void* ptr)
{
return static_cast<QFontMetrics*>(ptr)->lineWidth();
}
int QFontMetrics_MaxWidth(void* ptr)
{
return static_cast<QFontMetrics*>(ptr)->maxWidth();
}
int QFontMetrics_MinLeftBearing(void* ptr)
{
return static_cast<QFontMetrics*>(ptr)->minLeftBearing();
}
int QFontMetrics_MinRightBearing(void* ptr)
{
return static_cast<QFontMetrics*>(ptr)->minRightBearing();
}
int QFontMetrics_OverlinePos(void* ptr)
{
return static_cast<QFontMetrics*>(ptr)->overlinePos();
}
int QFontMetrics_RightBearing(void* ptr, void* ch)
{
return static_cast<QFontMetrics*>(ptr)->rightBearing(*static_cast<QChar*>(ch));
}
int QFontMetrics_StrikeOutPos(void* ptr)
{
return static_cast<QFontMetrics*>(ptr)->strikeOutPos();
}
int QFontMetrics_UnderlinePos(void* ptr)
{
return static_cast<QFontMetrics*>(ptr)->underlinePos();
}
int QFontMetrics_XHeight(void* ptr)
{
return static_cast<QFontMetrics*>(ptr)->xHeight();
}
void* QFontMetricsF_NewQFontMetricsF(void* font)
{
return new QFontMetricsF(*static_cast<QFont*>(font));
}
void* QFontMetricsF_NewQFontMetricsF2(void* font, void* paintdevice)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(paintdevice))) {
return new QFontMetricsF(*static_cast<QFont*>(font), static_cast<QPaintDeviceWindow*>(paintdevice));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(paintdevice))) {
return new QFontMetricsF(*static_cast<QFont*>(font), static_cast<QPdfWriter*>(paintdevice));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(paintdevice))) {
return new QFontMetricsF(*static_cast<QFont*>(font), static_cast<QWidget*>(paintdevice));
} else {
return new QFontMetricsF(*static_cast<QFont*>(font), static_cast<QPaintDevice*>(paintdevice));
}
}
void* QFontMetricsF_NewQFontMetricsF3(void* fontMetrics)
{
return new QFontMetricsF(*static_cast<QFontMetrics*>(fontMetrics));
}
void* QFontMetricsF_NewQFontMetricsF4(void* fm)
{
return new QFontMetricsF(*static_cast<QFontMetricsF*>(fm));
}
void QFontMetricsF_Swap(void* ptr, void* other)
{
static_cast<QFontMetricsF*>(ptr)->swap(*static_cast<QFontMetricsF*>(other));
}
void QFontMetricsF_DestroyQFontMetricsF(void* ptr)
{
static_cast<QFontMetricsF*>(ptr)->~QFontMetricsF();
}
void* QFontMetricsF_BoundingRect2(void* ptr, void* ch)
{
return ({ QRectF tmpValue = static_cast<QFontMetricsF*>(ptr)->boundingRect(*static_cast<QChar*>(ch)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QFontMetricsF_BoundingRect3(void* ptr, void* rect, int flags, struct QtGui_PackedString text, int tabStops, int tabArray)
{
return ({ QRectF tmpValue = static_cast<QFontMetricsF*>(ptr)->boundingRect(*static_cast<QRectF*>(rect), flags, QString::fromUtf8(text.data, text.len), tabStops, &tabArray); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QFontMetricsF_BoundingRect(void* ptr, struct QtGui_PackedString text)
{
return ({ QRectF tmpValue = static_cast<QFontMetricsF*>(ptr)->boundingRect(QString::fromUtf8(text.data, text.len)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QFontMetricsF_TightBoundingRect(void* ptr, struct QtGui_PackedString text)
{
return ({ QRectF tmpValue = static_cast<QFontMetricsF*>(ptr)->tightBoundingRect(QString::fromUtf8(text.data, text.len)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QFontMetricsF_Size(void* ptr, int flags, struct QtGui_PackedString text, int tabStops, int tabArray)
{
return ({ QSizeF tmpValue = static_cast<QFontMetricsF*>(ptr)->size(flags, QString::fromUtf8(text.data, text.len), tabStops, &tabArray); new QSizeF(tmpValue.width(), tmpValue.height()); });
}
struct QtGui_PackedString QFontMetricsF_ElidedText(void* ptr, struct QtGui_PackedString text, long long mode, double width, int flags)
{
return ({ QByteArray teb7a10 = static_cast<QFontMetricsF*>(ptr)->elidedText(QString::fromUtf8(text.data, text.len), static_cast<Qt::TextElideMode>(mode), width, flags).toUtf8(); QtGui_PackedString { const_cast<char*>(teb7a10.prepend("WHITESPACE").constData()+10), teb7a10.size()-10 }; });
}
char QFontMetricsF_InFont(void* ptr, void* ch)
{
return static_cast<QFontMetricsF*>(ptr)->inFont(*static_cast<QChar*>(ch));
}
char QFontMetricsF_InFontUcs4(void* ptr, unsigned int ch)
{
return static_cast<QFontMetricsF*>(ptr)->inFontUcs4(ch);
}
double QFontMetricsF_Ascent(void* ptr)
{
return static_cast<QFontMetricsF*>(ptr)->ascent();
}
double QFontMetricsF_AverageCharWidth(void* ptr)
{
return static_cast<QFontMetricsF*>(ptr)->averageCharWidth();
}
double QFontMetricsF_CapHeight(void* ptr)
{
return static_cast<QFontMetricsF*>(ptr)->capHeight();
}
double QFontMetricsF_Descent(void* ptr)
{
return static_cast<QFontMetricsF*>(ptr)->descent();
}
double QFontMetricsF_Height(void* ptr)
{
return static_cast<QFontMetricsF*>(ptr)->height();
}
double QFontMetricsF_HorizontalAdvance2(void* ptr, void* ch)
{
return static_cast<QFontMetricsF*>(ptr)->horizontalAdvance(*static_cast<QChar*>(ch));
}
double QFontMetricsF_HorizontalAdvance(void* ptr, struct QtGui_PackedString text, int length)
{
return static_cast<QFontMetricsF*>(ptr)->horizontalAdvance(QString::fromUtf8(text.data, text.len), length);
}
double QFontMetricsF_Leading(void* ptr)
{
return static_cast<QFontMetricsF*>(ptr)->leading();
}
double QFontMetricsF_LeftBearing(void* ptr, void* ch)
{
return static_cast<QFontMetricsF*>(ptr)->leftBearing(*static_cast<QChar*>(ch));
}
double QFontMetricsF_LineSpacing(void* ptr)
{
return static_cast<QFontMetricsF*>(ptr)->lineSpacing();
}
double QFontMetricsF_LineWidth(void* ptr)
{
return static_cast<QFontMetricsF*>(ptr)->lineWidth();
}
double QFontMetricsF_MaxWidth(void* ptr)
{
return static_cast<QFontMetricsF*>(ptr)->maxWidth();
}
double QFontMetricsF_MinLeftBearing(void* ptr)
{
return static_cast<QFontMetricsF*>(ptr)->minLeftBearing();
}
double QFontMetricsF_MinRightBearing(void* ptr)
{
return static_cast<QFontMetricsF*>(ptr)->minRightBearing();
}
double QFontMetricsF_OverlinePos(void* ptr)
{
return static_cast<QFontMetricsF*>(ptr)->overlinePos();
}
double QFontMetricsF_RightBearing(void* ptr, void* ch)
{
return static_cast<QFontMetricsF*>(ptr)->rightBearing(*static_cast<QChar*>(ch));
}
double QFontMetricsF_StrikeOutPos(void* ptr)
{
return static_cast<QFontMetricsF*>(ptr)->strikeOutPos();
}
double QFontMetricsF_UnderlinePos(void* ptr)
{
return static_cast<QFontMetricsF*>(ptr)->underlinePos();
}
double QFontMetricsF_XHeight(void* ptr)
{
return static_cast<QFontMetricsF*>(ptr)->xHeight();
}
class MyQGenericPlugin: public QGenericPlugin
{
public:
MyQGenericPlugin(QObject *parent = Q_NULLPTR) : QGenericPlugin(parent) {QGenericPlugin_QGenericPlugin_QRegisterMetaType();};
QObject * create(const QString & key, const QString & specification) { QByteArray ta62f22 = key.toUtf8(); QtGui_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };QByteArray t03d6a1 = specification.toUtf8(); QtGui_PackedString specificationPacked = { const_cast<char*>(t03d6a1.prepend("WHITESPACE").constData()+10), t03d6a1.size()-10 };return static_cast<QObject*>(callbackQGenericPlugin_Create(this, keyPacked, specificationPacked)); };
~MyQGenericPlugin() { callbackQGenericPlugin_DestroyQGenericPlugin(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGenericPlugin_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQGenericPlugin_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQGenericPlugin_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQGenericPlugin_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQGenericPlugin_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQGenericPlugin_CustomEvent(this, event); };
void deleteLater() { callbackQGenericPlugin_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQGenericPlugin_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQGenericPlugin_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQGenericPlugin_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQGenericPlugin_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQGenericPlugin*)
int QGenericPlugin_QGenericPlugin_QRegisterMetaType(){qRegisterMetaType<QGenericPlugin*>(); return qRegisterMetaType<MyQGenericPlugin*>();}
void* QGenericPlugin_NewQGenericPlugin(void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQGenericPlugin(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQGenericPlugin(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQGenericPlugin(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQGenericPlugin(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQGenericPlugin(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQGenericPlugin(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQGenericPlugin(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQGenericPlugin(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQGenericPlugin(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQGenericPlugin(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQGenericPlugin(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQGenericPlugin(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQGenericPlugin(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQGenericPlugin(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQGenericPlugin(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQGenericPlugin(static_cast<QWindow*>(parent));
} else {
return new MyQGenericPlugin(static_cast<QObject*>(parent));
}
}
void* QGenericPlugin_Create(void* ptr, struct QtGui_PackedString key, struct QtGui_PackedString specification)
{
return static_cast<QGenericPlugin*>(ptr)->create(QString::fromUtf8(key.data, key.len), QString::fromUtf8(specification.data, specification.len));
}
struct QtGui_PackedString QGenericPlugin_QGenericPlugin_Tr(char* s, char* c, int n)
{
return ({ QByteArray tc6abe3 = QGenericPlugin::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(tc6abe3.prepend("WHITESPACE").constData()+10), tc6abe3.size()-10 }; });
}
struct QtGui_PackedString QGenericPlugin_QGenericPlugin_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray t55297b = QGenericPlugin::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t55297b.prepend("WHITESPACE").constData()+10), t55297b.size()-10 }; });
}
void QGenericPlugin_DestroyQGenericPlugin(void* ptr)
{
static_cast<QGenericPlugin*>(ptr)->~QGenericPlugin();
}
void QGenericPlugin_DestroyQGenericPluginDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QGenericPlugin_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::metaObject());
}
void* QGenericPlugin___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QGenericPlugin___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QGenericPlugin___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QGenericPlugin___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QGenericPlugin___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QGenericPlugin___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QGenericPlugin___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QGenericPlugin___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QGenericPlugin___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QGenericPlugin___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QGenericPlugin___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QGenericPlugin___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QGenericPlugin___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QGenericPlugin___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QGenericPlugin___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QGenericPlugin_EventDefault(void* ptr, void* e)
{
return static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::event(static_cast<QEvent*>(e));
}
char QGenericPlugin_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QGenericPlugin_ChildEventDefault(void* ptr, void* event)
{
static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::childEvent(static_cast<QChildEvent*>(event));
}
void QGenericPlugin_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QGenericPlugin_CustomEventDefault(void* ptr, void* event)
{
static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::customEvent(static_cast<QEvent*>(event));
}
void QGenericPlugin_DeleteLaterDefault(void* ptr)
{
static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::deleteLater();
}
void QGenericPlugin_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QGenericPlugin_TimerEventDefault(void* ptr, void* event)
{
static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::timerEvent(static_cast<QTimerEvent*>(event));
}
void* QGenericPluginFactory_QGenericPluginFactory_Create(struct QtGui_PackedString key, struct QtGui_PackedString specification)
{
return QGenericPluginFactory::create(QString::fromUtf8(key.data, key.len), QString::fromUtf8(specification.data, specification.len));
}
struct QtGui_PackedString QGenericPluginFactory_QGenericPluginFactory_Keys()
{
return ({ QByteArray t692cb7 = QGenericPluginFactory::keys().join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t692cb7.prepend("WHITESPACE").constData()+10), t692cb7.size()-10 }; });
}
void* QGlyphRun_NewQGlyphRun()
{
return new QGlyphRun();
}
void* QGlyphRun_NewQGlyphRun2(void* other)
{
return new QGlyphRun(*static_cast<QGlyphRun*>(other));
}
void QGlyphRun_Clear(void* ptr)
{
static_cast<QGlyphRun*>(ptr)->clear();
}
void QGlyphRun_SetBoundingRect(void* ptr, void* boundingRect)
{
static_cast<QGlyphRun*>(ptr)->setBoundingRect(*static_cast<QRectF*>(boundingRect));
}
void QGlyphRun_SetFlag(void* ptr, long long flag, char enabled)
{
static_cast<QGlyphRun*>(ptr)->setFlag(static_cast<QGlyphRun::GlyphRunFlag>(flag), enabled != 0);
}
void QGlyphRun_SetFlags(void* ptr, long long flags)
{
static_cast<QGlyphRun*>(ptr)->setFlags(static_cast<QGlyphRun::GlyphRunFlag>(flags));
}
void QGlyphRun_SetGlyphIndexes(void* ptr, void* glyphIndexes)
{
static_cast<QGlyphRun*>(ptr)->setGlyphIndexes(*static_cast<QVector<quint32>*>(glyphIndexes));
}
void QGlyphRun_SetOverline(void* ptr, char overline)
{
static_cast<QGlyphRun*>(ptr)->setOverline(overline != 0);
}
void QGlyphRun_SetPositions(void* ptr, void* positions)
{
static_cast<QGlyphRun*>(ptr)->setPositions(*static_cast<QVector<QPointF>*>(positions));
}
void QGlyphRun_SetRawData(void* ptr, unsigned int glyphIndexArray, void* glyphPositionArray, int size)
{
static_cast<QGlyphRun*>(ptr)->setRawData(const_cast<const quint32*>(&glyphIndexArray), static_cast<QPointF*>(glyphPositionArray), size);
}
void QGlyphRun_SetRawFont(void* ptr, void* rawFont)
{
static_cast<QGlyphRun*>(ptr)->setRawFont(*static_cast<QRawFont*>(rawFont));
}
void QGlyphRun_SetRightToLeft(void* ptr, char rightToLeft)
{
static_cast<QGlyphRun*>(ptr)->setRightToLeft(rightToLeft != 0);
}
void QGlyphRun_SetStrikeOut(void* ptr, char strikeOut)
{
static_cast<QGlyphRun*>(ptr)->setStrikeOut(strikeOut != 0);
}
void QGlyphRun_SetUnderline(void* ptr, char underline)
{
static_cast<QGlyphRun*>(ptr)->setUnderline(underline != 0);
}
void QGlyphRun_Swap(void* ptr, void* other)
{
static_cast<QGlyphRun*>(ptr)->swap(*static_cast<QGlyphRun*>(other));
}
void QGlyphRun_DestroyQGlyphRun(void* ptr)
{
static_cast<QGlyphRun*>(ptr)->~QGlyphRun();
}
long long QGlyphRun_Flags(void* ptr)
{
return static_cast<QGlyphRun*>(ptr)->flags();
}
void* QGlyphRun_RawFont(void* ptr)
{
return new QRawFont(static_cast<QGlyphRun*>(ptr)->rawFont());
}
void* QGlyphRun_BoundingRect(void* ptr)
{
return ({ QRectF tmpValue = static_cast<QGlyphRun*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
struct QtGui_PackedList QGlyphRun_Positions(void* ptr)
{
return ({ QVector<QPointF>* tmpValue = new QVector<QPointF>(static_cast<QGlyphRun*>(ptr)->positions()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedList QGlyphRun_GlyphIndexes(void* ptr)
{
return ({ QVector<quint32>* tmpValue = new QVector<quint32>(static_cast<QGlyphRun*>(ptr)->glyphIndexes()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
char QGlyphRun_IsEmpty(void* ptr)
{
return static_cast<QGlyphRun*>(ptr)->isEmpty();
}
char QGlyphRun_IsRightToLeft(void* ptr)
{
return static_cast<QGlyphRun*>(ptr)->isRightToLeft();
}
char QGlyphRun_Overline(void* ptr)
{
return static_cast<QGlyphRun*>(ptr)->overline();
}
char QGlyphRun_StrikeOut(void* ptr)
{
return static_cast<QGlyphRun*>(ptr)->strikeOut();
}
char QGlyphRun_Underline(void* ptr)
{
return static_cast<QGlyphRun*>(ptr)->underline();
}
unsigned int QGlyphRun___setGlyphIndexes_glyphIndexes_atList(void* ptr, int i)
{
return ({quint32 tmp = static_cast<QVector<quint32>*>(ptr)->at(i); if (i == static_cast<QVector<quint32>*>(ptr)->size()-1) { static_cast<QVector<quint32>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QGlyphRun___setGlyphIndexes_glyphIndexes_setList(void* ptr, unsigned int i)
{
static_cast<QVector<quint32>*>(ptr)->append(i);
}
void* QGlyphRun___setGlyphIndexes_glyphIndexes_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<quint32>();
}
void* QGlyphRun___setPositions_positions_atList(void* ptr, int i)
{
return ({ QPointF tmpValue = ({QPointF tmp = static_cast<QVector<QPointF>*>(ptr)->at(i); if (i == static_cast<QVector<QPointF>*>(ptr)->size()-1) { static_cast<QVector<QPointF>*>(ptr)->~QVector(); free(ptr); }; tmp; }); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QGlyphRun___setPositions_positions_setList(void* ptr, void* i)
{
static_cast<QVector<QPointF>*>(ptr)->append(*static_cast<QPointF*>(i));
}
void* QGlyphRun___setPositions_positions_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QPointF>();
}
void* QGlyphRun___positions_atList(void* ptr, int i)
{
return ({ QPointF tmpValue = ({QPointF tmp = static_cast<QVector<QPointF>*>(ptr)->at(i); if (i == static_cast<QVector<QPointF>*>(ptr)->size()-1) { static_cast<QVector<QPointF>*>(ptr)->~QVector(); free(ptr); }; tmp; }); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QGlyphRun___positions_setList(void* ptr, void* i)
{
static_cast<QVector<QPointF>*>(ptr)->append(*static_cast<QPointF*>(i));
}
void* QGlyphRun___positions_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QPointF>();
}
unsigned int QGlyphRun___glyphIndexes_atList(void* ptr, int i)
{
return ({quint32 tmp = static_cast<QVector<quint32>*>(ptr)->at(i); if (i == static_cast<QVector<quint32>*>(ptr)->size()-1) { static_cast<QVector<quint32>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QGlyphRun___glyphIndexes_setList(void* ptr, unsigned int i)
{
static_cast<QVector<quint32>*>(ptr)->append(i);
}
void* QGlyphRun___glyphIndexes_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<quint32>();
}
void QGradient_SetColorAt(void* ptr, double position, void* color)
{
static_cast<QGradient*>(ptr)->setColorAt(position, *static_cast<QColor*>(color));
}
void QGradient_SetCoordinateMode(void* ptr, long long mode)
{
static_cast<QGradient*>(ptr)->setCoordinateMode(static_cast<QGradient::CoordinateMode>(mode));
}
void QGradient_SetSpread(void* ptr, long long method)
{
static_cast<QGradient*>(ptr)->setSpread(static_cast<QGradient::Spread>(method));
}
long long QGradient_CoordinateMode(void* ptr)
{
return static_cast<QGradient*>(ptr)->coordinateMode();
}
long long QGradient_Spread(void* ptr)
{
return static_cast<QGradient*>(ptr)->spread();
}
long long QGradient_Type(void* ptr)
{
return static_cast<QGradient*>(ptr)->type();
}
class MyQGuiApplication: public QGuiApplication
{
public:
MyQGuiApplication(int &argc, char **argv) : QGuiApplication(argc, argv) {QGuiApplication_QGuiApplication_QRegisterMetaType();};
bool event(QEvent * e) { return callbackQGuiApplication_Event(this, e) != 0; };
void Signal_ApplicationDisplayNameChanged() { callbackQGuiApplication_ApplicationDisplayNameChanged(this); };
void Signal_ApplicationStateChanged(Qt::ApplicationState state) { callbackQGuiApplication_ApplicationStateChanged(this, state); };
void Signal_CommitDataRequest(QSessionManager & manager) { callbackQGuiApplication_CommitDataRequest(this, static_cast<QSessionManager*>(&manager)); };
void Signal_FocusObjectChanged(QObject * focusObject) { callbackQGuiApplication_FocusObjectChanged(this, focusObject); };
void Signal_FocusWindowChanged(QWindow * focusWindow) { callbackQGuiApplication_FocusWindowChanged(this, focusWindow); };
void Signal_FontChanged(const QFont & font) { callbackQGuiApplication_FontChanged(this, const_cast<QFont*>(&font)); };
void Signal_FontDatabaseChanged() { callbackQGuiApplication_FontDatabaseChanged(this); };
void Signal_LastWindowClosed() { callbackQGuiApplication_LastWindowClosed(this); };
void Signal_LayoutDirectionChanged(Qt::LayoutDirection direction) { callbackQGuiApplication_LayoutDirectionChanged(this, direction); };
void Signal_PaletteChanged(const QPalette & palette) { callbackQGuiApplication_PaletteChanged(this, const_cast<QPalette*>(&palette)); };
void Signal_PrimaryScreenChanged(QScreen * screen) { callbackQGuiApplication_PrimaryScreenChanged(this, screen); };
void Signal_SaveStateRequest(QSessionManager & manager) { callbackQGuiApplication_SaveStateRequest(this, static_cast<QSessionManager*>(&manager)); };
void Signal_ScreenAdded(QScreen * screen) { callbackQGuiApplication_ScreenAdded(this, screen); };
void Signal_ScreenRemoved(QScreen * screen) { callbackQGuiApplication_ScreenRemoved(this, screen); };
~MyQGuiApplication() { callbackQGuiApplication_DestroyQGuiApplication(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGuiApplication_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_AboutToQuit() { callbackQGuiApplication_AboutToQuit(this); };
void quit() { callbackQGuiApplication_Quit(this); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQGuiApplication_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQGuiApplication_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQGuiApplication_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQGuiApplication_CustomEvent(this, event); };
void deleteLater() { callbackQGuiApplication_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQGuiApplication_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQGuiApplication_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQGuiApplication_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQGuiApplication_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQGuiApplication*)
int QGuiApplication_QGuiApplication_QRegisterMetaType(){qRegisterMetaType<QGuiApplication*>(); return qRegisterMetaType<MyQGuiApplication*>();}
void* QGuiApplication_QGuiApplication_Clipboard()
{
return QGuiApplication::clipboard();
}
void* QGuiApplication_QGuiApplication_OverrideCursor()
{
return QGuiApplication::overrideCursor();
}
void* QGuiApplication_QGuiApplication_Font()
{
return new QFont(QGuiApplication::font());
}
void* QGuiApplication_NewQGuiApplication(int argc, char* argv)
{
static int argcs = argc;
static char** argvs = static_cast<char**>(malloc(argcs * sizeof(char*)));
QList<QByteArray> aList = QByteArray(argv).split('|');
for (int i = 0; i < argcs; i++)
argvs[i] = (new QByteArray(aList.at(i)))->data();
return new MyQGuiApplication(argcs, argvs);
}
void* QGuiApplication_QGuiApplication_WindowIcon()
{
return new QIcon(QGuiApplication::windowIcon());
}
void* QGuiApplication_QGuiApplication_InputMethod()
{
return QGuiApplication::inputMethod();
}
struct QtGui_PackedList QGuiApplication_QGuiApplication_Screens()
{
return ({ QList<QScreen *>* tmpValue = new QList<QScreen *>(QGuiApplication::screens()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QGuiApplication_QGuiApplication_FocusObject()
{
return QGuiApplication::focusObject();
}
void* QGuiApplication_QGuiApplication_Palette()
{
return new QPalette(QGuiApplication::palette());
}
void* QGuiApplication_QGuiApplication_PrimaryScreen()
{
return QGuiApplication::primaryScreen();
}
void* QGuiApplication_QGuiApplication_ScreenAt(void* point)
{
return QGuiApplication::screenAt(*static_cast<QPoint*>(point));
}
struct QtGui_PackedString QGuiApplication_QGuiApplication_ApplicationDisplayName()
{
return ({ QByteArray tb2b492 = QGuiApplication::applicationDisplayName().toUtf8(); QtGui_PackedString { const_cast<char*>(tb2b492.prepend("WHITESPACE").constData()+10), tb2b492.size()-10 }; });
}
struct QtGui_PackedString QGuiApplication_QGuiApplication_DesktopFileName()
{
return ({ QByteArray t174649 = QGuiApplication::desktopFileName().toUtf8(); QtGui_PackedString { const_cast<char*>(t174649.prepend("WHITESPACE").constData()+10), t174649.size()-10 }; });
}
struct QtGui_PackedString QGuiApplication_QGuiApplication_PlatformName()
{
return ({ QByteArray t498934 = QGuiApplication::platformName().toUtf8(); QtGui_PackedString { const_cast<char*>(t498934.prepend("WHITESPACE").constData()+10), t498934.size()-10 }; });
}
struct QtGui_PackedString QGuiApplication_QGuiApplication_Tr(char* s, char* c, int n)
{
return ({ QByteArray t2b085a = QGuiApplication::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t2b085a.prepend("WHITESPACE").constData()+10), t2b085a.size()-10 }; });
}
struct QtGui_PackedString QGuiApplication_QGuiApplication_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray t735009 = QGuiApplication::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t735009.prepend("WHITESPACE").constData()+10), t735009.size()-10 }; });
}
void* QGuiApplication_QGuiApplication_StyleHints()
{
return QGuiApplication::styleHints();
}
void* QGuiApplication_QGuiApplication_FocusWindow()
{
return QGuiApplication::focusWindow();
}
void* QGuiApplication_QGuiApplication_ModalWindow()
{
return QGuiApplication::modalWindow();
}
void* QGuiApplication_QGuiApplication_TopLevelAt(void* pos)
{
return QGuiApplication::topLevelAt(*static_cast<QPoint*>(pos));
}
long long QGuiApplication_QGuiApplication_ApplicationState()
{
return QGuiApplication::applicationState();
}
long long QGuiApplication_QGuiApplication_KeyboardModifiers()
{
return QGuiApplication::keyboardModifiers();
}
long long QGuiApplication_QGuiApplication_QueryKeyboardModifiers()
{
return QGuiApplication::queryKeyboardModifiers();
}
long long QGuiApplication_QGuiApplication_LayoutDirection()
{
return QGuiApplication::layoutDirection();
}
long long QGuiApplication_QGuiApplication_MouseButtons()
{
return QGuiApplication::mouseButtons();
}
char QGuiApplication_QGuiApplication_DesktopSettingsAware()
{
return QGuiApplication::desktopSettingsAware();
}
char QGuiApplication_EventDefault(void* ptr, void* e)
{
return static_cast<QGuiApplication*>(ptr)->QGuiApplication::event(static_cast<QEvent*>(e));
}
char QGuiApplication_QGuiApplication_IsFallbackSessionManagementEnabled()
{
return QGuiApplication::isFallbackSessionManagementEnabled();
}
char QGuiApplication_QGuiApplication_IsLeftToRight()
{
return QGuiApplication::isLeftToRight();
}
char QGuiApplication_QGuiApplication_IsRightToLeft()
{
return QGuiApplication::isRightToLeft();
}
char QGuiApplication_QGuiApplication_QuitOnLastWindowClosed()
{
return QGuiApplication::quitOnLastWindowClosed();
}
int QGuiApplication_QGuiApplication_Exec()
{
return QGuiApplication::exec();
}
void QGuiApplication_ConnectApplicationDisplayNameChanged(void* ptr)
{
QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)()>(&QGuiApplication::applicationDisplayNameChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)()>(&MyQGuiApplication::Signal_ApplicationDisplayNameChanged));
}
void QGuiApplication_DisconnectApplicationDisplayNameChanged(void* ptr)
{
QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)()>(&QGuiApplication::applicationDisplayNameChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)()>(&MyQGuiApplication::Signal_ApplicationDisplayNameChanged));
}
void QGuiApplication_ApplicationDisplayNameChanged(void* ptr)
{
static_cast<QGuiApplication*>(ptr)->applicationDisplayNameChanged();
}
void QGuiApplication_ConnectApplicationStateChanged(void* ptr)
{
qRegisterMetaType<Qt::ApplicationState>();
QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(Qt::ApplicationState)>(&QGuiApplication::applicationStateChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(Qt::ApplicationState)>(&MyQGuiApplication::Signal_ApplicationStateChanged));
}
void QGuiApplication_DisconnectApplicationStateChanged(void* ptr)
{
QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(Qt::ApplicationState)>(&QGuiApplication::applicationStateChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(Qt::ApplicationState)>(&MyQGuiApplication::Signal_ApplicationStateChanged));
}
void QGuiApplication_ApplicationStateChanged(void* ptr, long long state)
{
static_cast<QGuiApplication*>(ptr)->applicationStateChanged(static_cast<Qt::ApplicationState>(state));
}
void QGuiApplication_QGuiApplication_ChangeOverrideCursor(void* cursor)
{
QGuiApplication::changeOverrideCursor(*static_cast<QCursor*>(cursor));
}
void QGuiApplication_ConnectCommitDataRequest(void* ptr)
{
QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QSessionManager &)>(&QGuiApplication::commitDataRequest), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QSessionManager &)>(&MyQGuiApplication::Signal_CommitDataRequest));
}
void QGuiApplication_DisconnectCommitDataRequest(void* ptr)
{
QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QSessionManager &)>(&QGuiApplication::commitDataRequest), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QSessionManager &)>(&MyQGuiApplication::Signal_CommitDataRequest));
}
void QGuiApplication_CommitDataRequest(void* ptr, void* manager)
{
static_cast<QGuiApplication*>(ptr)->commitDataRequest(*static_cast<QSessionManager*>(manager));
}
void QGuiApplication_ConnectFocusObjectChanged(void* ptr)
{
QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QObject *)>(&QGuiApplication::focusObjectChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QObject *)>(&MyQGuiApplication::Signal_FocusObjectChanged));
}
void QGuiApplication_DisconnectFocusObjectChanged(void* ptr)
{
QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QObject *)>(&QGuiApplication::focusObjectChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QObject *)>(&MyQGuiApplication::Signal_FocusObjectChanged));
}
void QGuiApplication_FocusObjectChanged(void* ptr, void* focusObject)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(focusObject))) {
static_cast<QGuiApplication*>(ptr)->focusObjectChanged(static_cast<QOffscreenSurface*>(focusObject));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(focusObject))) {
static_cast<QGuiApplication*>(ptr)->focusObjectChanged(static_cast<QPaintDeviceWindow*>(focusObject));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(focusObject))) {
static_cast<QGuiApplication*>(ptr)->focusObjectChanged(static_cast<QPdfWriter*>(focusObject));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(focusObject))) {
static_cast<QGuiApplication*>(ptr)->focusObjectChanged(static_cast<QWindow*>(focusObject));
} else {
static_cast<QGuiApplication*>(ptr)->focusObjectChanged(static_cast<QObject*>(focusObject));
}
}
void QGuiApplication_ConnectFocusWindowChanged(void* ptr)
{
QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QWindow *)>(&QGuiApplication::focusWindowChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QWindow *)>(&MyQGuiApplication::Signal_FocusWindowChanged));
}
void QGuiApplication_DisconnectFocusWindowChanged(void* ptr)
{
QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QWindow *)>(&QGuiApplication::focusWindowChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QWindow *)>(&MyQGuiApplication::Signal_FocusWindowChanged));
}
void QGuiApplication_FocusWindowChanged(void* ptr, void* focusWindow)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(focusWindow))) {
static_cast<QGuiApplication*>(ptr)->focusWindowChanged(static_cast<QPaintDeviceWindow*>(focusWindow));
} else {
static_cast<QGuiApplication*>(ptr)->focusWindowChanged(static_cast<QWindow*>(focusWindow));
}
}
void QGuiApplication_ConnectFontChanged(void* ptr)
{
QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(const QFont &)>(&QGuiApplication::fontChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(const QFont &)>(&MyQGuiApplication::Signal_FontChanged));
}
void QGuiApplication_DisconnectFontChanged(void* ptr)
{
QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(const QFont &)>(&QGuiApplication::fontChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(const QFont &)>(&MyQGuiApplication::Signal_FontChanged));
}
void QGuiApplication_FontChanged(void* ptr, void* font)
{
static_cast<QGuiApplication*>(ptr)->fontChanged(*static_cast<QFont*>(font));
}
void QGuiApplication_ConnectFontDatabaseChanged(void* ptr)
{
QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)()>(&QGuiApplication::fontDatabaseChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)()>(&MyQGuiApplication::Signal_FontDatabaseChanged));
}
void QGuiApplication_DisconnectFontDatabaseChanged(void* ptr)
{
QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)()>(&QGuiApplication::fontDatabaseChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)()>(&MyQGuiApplication::Signal_FontDatabaseChanged));
}
void QGuiApplication_FontDatabaseChanged(void* ptr)
{
static_cast<QGuiApplication*>(ptr)->fontDatabaseChanged();
}
void QGuiApplication_ConnectLastWindowClosed(void* ptr)
{
QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)()>(&QGuiApplication::lastWindowClosed), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)()>(&MyQGuiApplication::Signal_LastWindowClosed));
}
void QGuiApplication_DisconnectLastWindowClosed(void* ptr)
{
QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)()>(&QGuiApplication::lastWindowClosed), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)()>(&MyQGuiApplication::Signal_LastWindowClosed));
}
void QGuiApplication_LastWindowClosed(void* ptr)
{
static_cast<QGuiApplication*>(ptr)->lastWindowClosed();
}
void QGuiApplication_ConnectLayoutDirectionChanged(void* ptr)
{
qRegisterMetaType<Qt::LayoutDirection>();
QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(Qt::LayoutDirection)>(&QGuiApplication::layoutDirectionChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(Qt::LayoutDirection)>(&MyQGuiApplication::Signal_LayoutDirectionChanged));
}
void QGuiApplication_DisconnectLayoutDirectionChanged(void* ptr)
{
QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(Qt::LayoutDirection)>(&QGuiApplication::layoutDirectionChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(Qt::LayoutDirection)>(&MyQGuiApplication::Signal_LayoutDirectionChanged));
}
void QGuiApplication_LayoutDirectionChanged(void* ptr, long long direction)
{
static_cast<QGuiApplication*>(ptr)->layoutDirectionChanged(static_cast<Qt::LayoutDirection>(direction));
}
void QGuiApplication_ConnectPaletteChanged(void* ptr)
{
QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(const QPalette &)>(&QGuiApplication::paletteChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(const QPalette &)>(&MyQGuiApplication::Signal_PaletteChanged));
}
void QGuiApplication_DisconnectPaletteChanged(void* ptr)
{
QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(const QPalette &)>(&QGuiApplication::paletteChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(const QPalette &)>(&MyQGuiApplication::Signal_PaletteChanged));
}
void QGuiApplication_PaletteChanged(void* ptr, void* palette)
{
static_cast<QGuiApplication*>(ptr)->paletteChanged(*static_cast<QPalette*>(palette));
}
void QGuiApplication_ConnectPrimaryScreenChanged(void* ptr)
{
QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QScreen *)>(&QGuiApplication::primaryScreenChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QScreen *)>(&MyQGuiApplication::Signal_PrimaryScreenChanged));
}
void QGuiApplication_DisconnectPrimaryScreenChanged(void* ptr)
{
QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QScreen *)>(&QGuiApplication::primaryScreenChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QScreen *)>(&MyQGuiApplication::Signal_PrimaryScreenChanged));
}
void QGuiApplication_PrimaryScreenChanged(void* ptr, void* screen)
{
static_cast<QGuiApplication*>(ptr)->primaryScreenChanged(static_cast<QScreen*>(screen));
}
void QGuiApplication_QGuiApplication_RestoreOverrideCursor()
{
QGuiApplication::restoreOverrideCursor();
}
void QGuiApplication_ConnectSaveStateRequest(void* ptr)
{
QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QSessionManager &)>(&QGuiApplication::saveStateRequest), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QSessionManager &)>(&MyQGuiApplication::Signal_SaveStateRequest));
}
void QGuiApplication_DisconnectSaveStateRequest(void* ptr)
{
QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QSessionManager &)>(&QGuiApplication::saveStateRequest), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QSessionManager &)>(&MyQGuiApplication::Signal_SaveStateRequest));
}
void QGuiApplication_SaveStateRequest(void* ptr, void* manager)
{
static_cast<QGuiApplication*>(ptr)->saveStateRequest(*static_cast<QSessionManager*>(manager));
}
void QGuiApplication_ConnectScreenAdded(void* ptr)
{
QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QScreen *)>(&QGuiApplication::screenAdded), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QScreen *)>(&MyQGuiApplication::Signal_ScreenAdded));
}
void QGuiApplication_DisconnectScreenAdded(void* ptr)
{
QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QScreen *)>(&QGuiApplication::screenAdded), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QScreen *)>(&MyQGuiApplication::Signal_ScreenAdded));
}
void QGuiApplication_ScreenAdded(void* ptr, void* screen)
{
static_cast<QGuiApplication*>(ptr)->screenAdded(static_cast<QScreen*>(screen));
}
void QGuiApplication_ConnectScreenRemoved(void* ptr)
{
QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QScreen *)>(&QGuiApplication::screenRemoved), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QScreen *)>(&MyQGuiApplication::Signal_ScreenRemoved));
}
void QGuiApplication_DisconnectScreenRemoved(void* ptr)
{
QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QScreen *)>(&QGuiApplication::screenRemoved), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QScreen *)>(&MyQGuiApplication::Signal_ScreenRemoved));
}
void QGuiApplication_ScreenRemoved(void* ptr, void* screen)
{
static_cast<QGuiApplication*>(ptr)->screenRemoved(static_cast<QScreen*>(screen));
}
void QGuiApplication_QGuiApplication_SetApplicationDisplayName(struct QtGui_PackedString name)
{
QGuiApplication::setApplicationDisplayName(QString::fromUtf8(name.data, name.len));
}
void QGuiApplication_QGuiApplication_SetDesktopFileName(struct QtGui_PackedString name)
{
QGuiApplication::setDesktopFileName(QString::fromUtf8(name.data, name.len));
}
void QGuiApplication_QGuiApplication_SetDesktopSettingsAware(char on)
{
QGuiApplication::setDesktopSettingsAware(on != 0);
}
void QGuiApplication_QGuiApplication_SetFallbackSessionManagementEnabled(char enabled)
{
QGuiApplication::setFallbackSessionManagementEnabled(enabled != 0);
}
void QGuiApplication_QGuiApplication_SetFont(void* font)
{
QGuiApplication::setFont(*static_cast<QFont*>(font));
}
void QGuiApplication_QGuiApplication_SetLayoutDirection(long long direction)
{
QGuiApplication::setLayoutDirection(static_cast<Qt::LayoutDirection>(direction));
}
void QGuiApplication_QGuiApplication_SetOverrideCursor(void* cursor)
{
QGuiApplication::setOverrideCursor(*static_cast<QCursor*>(cursor));
}
void QGuiApplication_QGuiApplication_SetPalette(void* pal)
{
QGuiApplication::setPalette(*static_cast<QPalette*>(pal));
}
void QGuiApplication_QGuiApplication_SetQuitOnLastWindowClosed(char quit)
{
QGuiApplication::setQuitOnLastWindowClosed(quit != 0);
}
void QGuiApplication_QGuiApplication_SetWindowIcon(void* icon)
{
QGuiApplication::setWindowIcon(*static_cast<QIcon*>(icon));
}
void QGuiApplication_QGuiApplication_Sync()
{
QGuiApplication::sync();
}
void QGuiApplication_DestroyQGuiApplication(void* ptr)
{
static_cast<QGuiApplication*>(ptr)->~QGuiApplication();
}
void QGuiApplication_DestroyQGuiApplicationDefault(void* ptr)
{
Q_UNUSED(ptr);
}
struct QtGui_PackedString QGuiApplication_SessionId(void* ptr)
{
return ({ QByteArray td2baef = static_cast<QGuiApplication*>(ptr)->sessionId().toUtf8(); QtGui_PackedString { const_cast<char*>(td2baef.prepend("WHITESPACE").constData()+10), td2baef.size()-10 }; });
}
struct QtGui_PackedString QGuiApplication_SessionKey(void* ptr)
{
return ({ QByteArray t076332 = static_cast<QGuiApplication*>(ptr)->sessionKey().toUtf8(); QtGui_PackedString { const_cast<char*>(t076332.prepend("WHITESPACE").constData()+10), t076332.size()-10 }; });
}
char QGuiApplication_IsSavingSession(void* ptr)
{
return static_cast<QGuiApplication*>(ptr)->isSavingSession();
}
char QGuiApplication_IsSessionRestored(void* ptr)
{
return static_cast<QGuiApplication*>(ptr)->isSessionRestored();
}
void* QGuiApplication_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QGuiApplication*>(ptr)->QGuiApplication::metaObject());
}
double QGuiApplication_DevicePixelRatio(void* ptr)
{
return static_cast<QGuiApplication*>(ptr)->devicePixelRatio();
}
void* QGuiApplication___screens_atList(void* ptr, int i)
{
return ({QScreen * tmp = static_cast<QList<QScreen *>*>(ptr)->at(i); if (i == static_cast<QList<QScreen *>*>(ptr)->size()-1) { static_cast<QList<QScreen *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QGuiApplication___screens_setList(void* ptr, void* i)
{
static_cast<QList<QScreen *>*>(ptr)->append(static_cast<QScreen*>(i));
}
void* QGuiApplication___screens_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QScreen *>();
}
void* QGuiApplication___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QGuiApplication___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QGuiApplication___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QGuiApplication___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QGuiApplication___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QGuiApplication___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QGuiApplication___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QGuiApplication___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QGuiApplication___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QGuiApplication___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QGuiApplication___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QGuiApplication___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QGuiApplication___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QGuiApplication___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QGuiApplication___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
void QGuiApplication_QuitDefault(void* ptr)
{
static_cast<QGuiApplication*>(ptr)->QGuiApplication::quit();
}
char QGuiApplication_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QGuiApplication*>(ptr)->QGuiApplication::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QGuiApplication*>(ptr)->QGuiApplication::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QGuiApplication*>(ptr)->QGuiApplication::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QGuiApplication*>(ptr)->QGuiApplication::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QGuiApplication*>(ptr)->QGuiApplication::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QGuiApplication_ChildEventDefault(void* ptr, void* event)
{
static_cast<QGuiApplication*>(ptr)->QGuiApplication::childEvent(static_cast<QChildEvent*>(event));
}
void QGuiApplication_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QGuiApplication*>(ptr)->QGuiApplication::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QGuiApplication_CustomEventDefault(void* ptr, void* event)
{
static_cast<QGuiApplication*>(ptr)->QGuiApplication::customEvent(static_cast<QEvent*>(event));
}
void QGuiApplication_DeleteLaterDefault(void* ptr)
{
static_cast<QGuiApplication*>(ptr)->QGuiApplication::deleteLater();
}
void QGuiApplication_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QGuiApplication*>(ptr)->QGuiApplication::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QGuiApplication_TimerEventDefault(void* ptr, void* event)
{
static_cast<QGuiApplication*>(ptr)->QGuiApplication::timerEvent(static_cast<QTimerEvent*>(event));
}
class MyQHelpEvent: public QHelpEvent
{
public:
MyQHelpEvent(QEvent::Type ty, const QPoint &pos, const QPoint &globalPos) : QHelpEvent(ty, pos, globalPos) {};
};
void* QHelpEvent_NewQHelpEvent(long long ty, void* pos, void* globalPos)
{
return new MyQHelpEvent(static_cast<QEvent::Type>(ty), *static_cast<QPoint*>(pos), *static_cast<QPoint*>(globalPos));
}
void* QHelpEvent_GlobalPos(void* ptr)
{
return const_cast<QPoint*>(&static_cast<QHelpEvent*>(ptr)->globalPos());
}
void* QHelpEvent_Pos(void* ptr)
{
return const_cast<QPoint*>(&static_cast<QHelpEvent*>(ptr)->pos());
}
int QHelpEvent_GlobalX(void* ptr)
{
return static_cast<QHelpEvent*>(ptr)->globalX();
}
int QHelpEvent_GlobalY(void* ptr)
{
return static_cast<QHelpEvent*>(ptr)->globalY();
}
int QHelpEvent_X(void* ptr)
{
return static_cast<QHelpEvent*>(ptr)->x();
}
int QHelpEvent_Y(void* ptr)
{
return static_cast<QHelpEvent*>(ptr)->y();
}
class MyQHideEvent: public QHideEvent
{
public:
MyQHideEvent() : QHideEvent() {};
};
void* QHideEvent_NewQHideEvent()
{
return new MyQHideEvent();
}
class MyQHoverEvent: public QHoverEvent
{
public:
MyQHoverEvent(QEvent::Type ty, const QPointF &pos, const QPointF &oldPos, Qt::KeyboardModifiers modifiers = Qt::NoModifier) : QHoverEvent(ty, pos, oldPos, modifiers) {};
};
void* QHoverEvent_NewQHoverEvent(long long ty, void* pos, void* oldPos, long long modifiers)
{
return new MyQHoverEvent(static_cast<QEvent::Type>(ty), *static_cast<QPointF*>(pos), *static_cast<QPointF*>(oldPos), static_cast<Qt::KeyboardModifier>(modifiers));
}
void* QHoverEvent_OldPos(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QHoverEvent*>(ptr)->oldPos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QHoverEvent_Pos(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QHoverEvent*>(ptr)->pos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QHoverEvent_OldPosF(void* ptr)
{
return const_cast<QPointF*>(&static_cast<QHoverEvent*>(ptr)->oldPosF());
}
void* QHoverEvent_PosF(void* ptr)
{
return const_cast<QPointF*>(&static_cast<QHoverEvent*>(ptr)->posF());
}
void* QHoverEvent_Op(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QHoverEvent*>(ptr)->op; new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QHoverEvent_SetOp(void* ptr, void* vqp)
{
static_cast<QHoverEvent*>(ptr)->op = *static_cast<QPointF*>(vqp);
}
void* QHoverEvent_P(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QHoverEvent*>(ptr)->p; new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QHoverEvent_SetP(void* ptr, void* vqp)
{
static_cast<QHoverEvent*>(ptr)->p = *static_cast<QPointF*>(vqp);
}
void* QIcon_QIcon_FromTheme(struct QtGui_PackedString name)
{
return new QIcon(QIcon::fromTheme(QString::fromUtf8(name.data, name.len)));
}
void* QIcon_QIcon_FromTheme2(struct QtGui_PackedString name, void* fallback)
{
return new QIcon(QIcon::fromTheme(QString::fromUtf8(name.data, name.len), *static_cast<QIcon*>(fallback)));
}
void* QIcon_NewQIcon()
{
return new QIcon();
}
void* QIcon_NewQIcon4(void* other)
{
return new QIcon(*static_cast<QIcon*>(other));
}
void* QIcon_NewQIcon6(void* engine)
{
return new QIcon(static_cast<QIconEngine*>(engine));
}
void* QIcon_NewQIcon3(void* other)
{
return new QIcon(*static_cast<QIcon*>(other));
}
void* QIcon_NewQIcon2(void* pixmap)
{
return new QIcon(*static_cast<QPixmap*>(pixmap));
}
void* QIcon_NewQIcon5(struct QtGui_PackedString fileName)
{
return new QIcon(QString::fromUtf8(fileName.data, fileName.len));
}
struct QtGui_PackedString QIcon_QIcon_ThemeName()
{
return ({ QByteArray tf4fe63 = QIcon::themeName().toUtf8(); QtGui_PackedString { const_cast<char*>(tf4fe63.prepend("WHITESPACE").constData()+10), tf4fe63.size()-10 }; });
}
struct QtGui_PackedString QIcon_QIcon_FallbackSearchPaths()
{
return ({ QByteArray t74e953 = QIcon::fallbackSearchPaths().join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t74e953.prepend("WHITESPACE").constData()+10), t74e953.size()-10 }; });
}
struct QtGui_PackedString QIcon_QIcon_ThemeSearchPaths()
{
return ({ QByteArray t9c13b7 = QIcon::themeSearchPaths().join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t9c13b7.prepend("WHITESPACE").constData()+10), t9c13b7.size()-10 }; });
}
char QIcon_QIcon_HasThemeIcon(struct QtGui_PackedString name)
{
return QIcon::hasThemeIcon(QString::fromUtf8(name.data, name.len));
}
void QIcon_AddFile(void* ptr, struct QtGui_PackedString fileName, void* size, long long mode, long long state)
{
static_cast<QIcon*>(ptr)->addFile(QString::fromUtf8(fileName.data, fileName.len), *static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
}
void QIcon_AddPixmap(void* ptr, void* pixmap, long long mode, long long state)
{
static_cast<QIcon*>(ptr)->addPixmap(*static_cast<QPixmap*>(pixmap), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
}
void QIcon_QIcon_SetFallbackSearchPaths(struct QtGui_PackedString paths)
{
QIcon::setFallbackSearchPaths(QString::fromUtf8(paths.data, paths.len).split("|", QString::SkipEmptyParts));
}
void QIcon_SetIsMask(void* ptr, char isMask)
{
static_cast<QIcon*>(ptr)->setIsMask(isMask != 0);
}
void QIcon_QIcon_SetThemeName(struct QtGui_PackedString name)
{
QIcon::setThemeName(QString::fromUtf8(name.data, name.len));
}
void QIcon_QIcon_SetThemeSearchPaths(struct QtGui_PackedString paths)
{
QIcon::setThemeSearchPaths(QString::fromUtf8(paths.data, paths.len).split("|", QString::SkipEmptyParts));
}
void QIcon_Swap(void* ptr, void* other)
{
static_cast<QIcon*>(ptr)->swap(*static_cast<QIcon*>(other));
}
void QIcon_DestroyQIcon(void* ptr)
{
static_cast<QIcon*>(ptr)->~QIcon();
}
struct QtGui_PackedList QIcon_AvailableSizes(void* ptr, long long mode, long long state)
{
return ({ QList<QSize>* tmpValue = new QList<QSize>(static_cast<QIcon*>(ptr)->availableSizes(static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QIcon_Pixmap4(void* ptr, void* window, void* size, long long mode, long long state)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(window))) {
return new QPixmap(static_cast<QIcon*>(ptr)->pixmap(static_cast<QPaintDeviceWindow*>(window), *static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state)));
} else {
return new QPixmap(static_cast<QIcon*>(ptr)->pixmap(static_cast<QWindow*>(window), *static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state)));
}
}
void* QIcon_Pixmap(void* ptr, void* size, long long mode, long long state)
{
return new QPixmap(static_cast<QIcon*>(ptr)->pixmap(*static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state)));
}
void* QIcon_Pixmap3(void* ptr, int extent, long long mode, long long state)
{
return new QPixmap(static_cast<QIcon*>(ptr)->pixmap(extent, static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state)));
}
void* QIcon_Pixmap2(void* ptr, int w, int h, long long mode, long long state)
{
return new QPixmap(static_cast<QIcon*>(ptr)->pixmap(w, h, static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state)));
}
void* QIcon_ActualSize2(void* ptr, void* window, void* size, long long mode, long long state)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(window))) {
return ({ QSize tmpValue = static_cast<QIcon*>(ptr)->actualSize(static_cast<QPaintDeviceWindow*>(window), *static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state)); new QSize(tmpValue.width(), tmpValue.height()); });
} else {
return ({ QSize tmpValue = static_cast<QIcon*>(ptr)->actualSize(static_cast<QWindow*>(window), *static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state)); new QSize(tmpValue.width(), tmpValue.height()); });
}
}
void* QIcon_ActualSize(void* ptr, void* size, long long mode, long long state)
{
return ({ QSize tmpValue = static_cast<QIcon*>(ptr)->actualSize(*static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state)); new QSize(tmpValue.width(), tmpValue.height()); });
}
struct QtGui_PackedString QIcon_Name(void* ptr)
{
return ({ QByteArray t03700a = static_cast<QIcon*>(ptr)->name().toUtf8(); QtGui_PackedString { const_cast<char*>(t03700a.prepend("WHITESPACE").constData()+10), t03700a.size()-10 }; });
}
char QIcon_IsMask(void* ptr)
{
return static_cast<QIcon*>(ptr)->isMask();
}
char QIcon_IsNull(void* ptr)
{
return static_cast<QIcon*>(ptr)->isNull();
}
long long QIcon_CacheKey(void* ptr)
{
return static_cast<QIcon*>(ptr)->cacheKey();
}
void QIcon_Paint(void* ptr, void* painter, void* rect, long long alignment, long long mode, long long state)
{
static_cast<QIcon*>(ptr)->paint(static_cast<QPainter*>(painter), *static_cast<QRect*>(rect), static_cast<Qt::AlignmentFlag>(alignment), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
}
void QIcon_Paint2(void* ptr, void* painter, int x, int y, int w, int h, long long alignment, long long mode, long long state)
{
static_cast<QIcon*>(ptr)->paint(static_cast<QPainter*>(painter), x, y, w, h, static_cast<Qt::AlignmentFlag>(alignment), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
}
void* QIcon_ToVariant(void* ptr)
{
return new QVariant(*static_cast<QIcon*>(ptr));
}
void* QIcon___availableSizes_atList(void* ptr, int i)
{
return ({ QSize tmpValue = ({QSize tmp = static_cast<QList<QSize>*>(ptr)->at(i); if (i == static_cast<QList<QSize>*>(ptr)->size()-1) { static_cast<QList<QSize>*>(ptr)->~QList(); free(ptr); }; tmp; }); new QSize(tmpValue.width(), tmpValue.height()); });
}
void QIcon___availableSizes_setList(void* ptr, void* i)
{
static_cast<QList<QSize>*>(ptr)->append(*static_cast<QSize*>(i));
}
void* QIcon___availableSizes_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QSize>();
}
class MyQIconDragEvent: public QIconDragEvent
{
public:
MyQIconDragEvent() : QIconDragEvent() {};
};
void* QIconDragEvent_NewQIconDragEvent()
{
return new MyQIconDragEvent();
}
class MyQIconEngine: public QIconEngine
{
public:
MyQIconEngine() : QIconEngine() {};
QPixmap pixmap(const QSize & size, QIcon::Mode mode, QIcon::State state) { return *static_cast<QPixmap*>(callbackQIconEngine_Pixmap(this, const_cast<QSize*>(&size), mode, state)); };
QSize actualSize(const QSize & size, QIcon::Mode mode, QIcon::State state) { return *static_cast<QSize*>(callbackQIconEngine_ActualSize(this, const_cast<QSize*>(&size), mode, state)); };
bool read(QDataStream & in) { return callbackQIconEngine_Read(this, static_cast<QDataStream*>(&in)) != 0; };
void addFile(const QString & fileName, const QSize & size, QIcon::Mode mode, QIcon::State state) { QByteArray td83e09 = fileName.toUtf8(); QtGui_PackedString fileNamePacked = { const_cast<char*>(td83e09.prepend("WHITESPACE").constData()+10), td83e09.size()-10 };callbackQIconEngine_AddFile(this, fileNamePacked, const_cast<QSize*>(&size), mode, state); };
void addPixmap(const QPixmap & pixmap, QIcon::Mode mode, QIcon::State state) { callbackQIconEngine_AddPixmap(this, const_cast<QPixmap*>(&pixmap), mode, state); };
void paint(QPainter * painter, const QRect & rect, QIcon::Mode mode, QIcon::State state) { callbackQIconEngine_Paint(this, painter, const_cast<QRect*>(&rect), mode, state); };
void virtual_hook(int id, void * data) { callbackQIconEngine_Virtual_hook(this, id, data); };
~MyQIconEngine() { callbackQIconEngine_DestroyQIconEngine(this); };
QIconEngine * clone() const { return static_cast<QIconEngine*>(callbackQIconEngine_Clone(const_cast<void*>(static_cast<const void*>(this)))); };
QList<QSize> availableSizes(QIcon::Mode mode, QIcon::State state) const { return ({ QList<QSize>* tmpP = static_cast<QList<QSize>*>(callbackQIconEngine_AvailableSizes(const_cast<void*>(static_cast<const void*>(this)), mode, state)); QList<QSize> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
QString iconName() const { return ({ QtGui_PackedString tempVal = callbackQIconEngine_IconName(const_cast<void*>(static_cast<const void*>(this))); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
QString key() const { return ({ QtGui_PackedString tempVal = callbackQIconEngine_Key(const_cast<void*>(static_cast<const void*>(this))); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
bool write(QDataStream & out) const { return callbackQIconEngine_Write(const_cast<void*>(static_cast<const void*>(this)), static_cast<QDataStream*>(&out)) != 0; };
};
void* QIconEngine_NewQIconEngine()
{
return new MyQIconEngine();
}
void* QIconEngine_Pixmap(void* ptr, void* size, long long mode, long long state)
{
return new QPixmap(static_cast<QIconEngine*>(ptr)->pixmap(*static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state)));
}
void* QIconEngine_PixmapDefault(void* ptr, void* size, long long mode, long long state)
{
return new QPixmap(static_cast<QIconEngine*>(ptr)->QIconEngine::pixmap(*static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state)));
}
void* QIconEngine_ScaledPixmap(void* ptr, void* size, long long mode, long long state, double scale)
{
return new QPixmap(static_cast<QIconEngine*>(ptr)->scaledPixmap(*static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state), scale));
}
void* QIconEngine_ActualSize(void* ptr, void* size, long long mode, long long state)
{
return ({ QSize tmpValue = static_cast<QIconEngine*>(ptr)->actualSize(*static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state)); new QSize(tmpValue.width(), tmpValue.height()); });
}
void* QIconEngine_ActualSizeDefault(void* ptr, void* size, long long mode, long long state)
{
return ({ QSize tmpValue = static_cast<QIconEngine*>(ptr)->QIconEngine::actualSize(*static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state)); new QSize(tmpValue.width(), tmpValue.height()); });
}
char QIconEngine_Read(void* ptr, void* in)
{
return static_cast<QIconEngine*>(ptr)->read(*static_cast<QDataStream*>(in));
}
char QIconEngine_ReadDefault(void* ptr, void* in)
{
return static_cast<QIconEngine*>(ptr)->QIconEngine::read(*static_cast<QDataStream*>(in));
}
void QIconEngine_AddFile(void* ptr, struct QtGui_PackedString fileName, void* size, long long mode, long long state)
{
static_cast<QIconEngine*>(ptr)->addFile(QString::fromUtf8(fileName.data, fileName.len), *static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
}
void QIconEngine_AddFileDefault(void* ptr, struct QtGui_PackedString fileName, void* size, long long mode, long long state)
{
static_cast<QIconEngine*>(ptr)->QIconEngine::addFile(QString::fromUtf8(fileName.data, fileName.len), *static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
}
void QIconEngine_AddPixmap(void* ptr, void* pixmap, long long mode, long long state)
{
static_cast<QIconEngine*>(ptr)->addPixmap(*static_cast<QPixmap*>(pixmap), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
}
void QIconEngine_AddPixmapDefault(void* ptr, void* pixmap, long long mode, long long state)
{
static_cast<QIconEngine*>(ptr)->QIconEngine::addPixmap(*static_cast<QPixmap*>(pixmap), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
}
void QIconEngine_Paint(void* ptr, void* painter, void* rect, long long mode, long long state)
{
static_cast<QIconEngine*>(ptr)->paint(static_cast<QPainter*>(painter), *static_cast<QRect*>(rect), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
}
void QIconEngine_Virtual_hook(void* ptr, int id, void* data)
{
static_cast<QIconEngine*>(ptr)->virtual_hook(id, data);
}
void QIconEngine_Virtual_hookDefault(void* ptr, int id, void* data)
{
static_cast<QIconEngine*>(ptr)->QIconEngine::virtual_hook(id, data);
}
void QIconEngine_DestroyQIconEngine(void* ptr)
{
static_cast<QIconEngine*>(ptr)->~QIconEngine();
}
void QIconEngine_DestroyQIconEngineDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QIconEngine_Clone(void* ptr)
{
return static_cast<QIconEngine*>(ptr)->clone();
}
struct QtGui_PackedList QIconEngine_AvailableSizes(void* ptr, long long mode, long long state)
{
return ({ QList<QSize>* tmpValue = new QList<QSize>(static_cast<QIconEngine*>(ptr)->availableSizes(static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedList QIconEngine_AvailableSizesDefault(void* ptr, long long mode, long long state)
{
return ({ QList<QSize>* tmpValue = new QList<QSize>(static_cast<QIconEngine*>(ptr)->QIconEngine::availableSizes(static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedString QIconEngine_IconName(void* ptr)
{
return ({ QByteArray te81faa = static_cast<QIconEngine*>(ptr)->iconName().toUtf8(); QtGui_PackedString { const_cast<char*>(te81faa.prepend("WHITESPACE").constData()+10), te81faa.size()-10 }; });
}
struct QtGui_PackedString QIconEngine_IconNameDefault(void* ptr)
{
return ({ QByteArray t0024e2 = static_cast<QIconEngine*>(ptr)->QIconEngine::iconName().toUtf8(); QtGui_PackedString { const_cast<char*>(t0024e2.prepend("WHITESPACE").constData()+10), t0024e2.size()-10 }; });
}
struct QtGui_PackedString QIconEngine_Key(void* ptr)
{
return ({ QByteArray tfa2543 = static_cast<QIconEngine*>(ptr)->key().toUtf8(); QtGui_PackedString { const_cast<char*>(tfa2543.prepend("WHITESPACE").constData()+10), tfa2543.size()-10 }; });
}
struct QtGui_PackedString QIconEngine_KeyDefault(void* ptr)
{
return ({ QByteArray t9979b6 = static_cast<QIconEngine*>(ptr)->QIconEngine::key().toUtf8(); QtGui_PackedString { const_cast<char*>(t9979b6.prepend("WHITESPACE").constData()+10), t9979b6.size()-10 }; });
}
char QIconEngine_IsNull(void* ptr)
{
return static_cast<QIconEngine*>(ptr)->isNull();
}
char QIconEngine_Write(void* ptr, void* out)
{
return static_cast<QIconEngine*>(ptr)->write(*static_cast<QDataStream*>(out));
}
char QIconEngine_WriteDefault(void* ptr, void* out)
{
return static_cast<QIconEngine*>(ptr)->QIconEngine::write(*static_cast<QDataStream*>(out));
}
void* QIconEngine___availableSizes_atList(void* ptr, int i)
{
return ({ QSize tmpValue = ({QSize tmp = static_cast<QList<QSize>*>(ptr)->at(i); if (i == static_cast<QList<QSize>*>(ptr)->size()-1) { static_cast<QList<QSize>*>(ptr)->~QList(); free(ptr); }; tmp; }); new QSize(tmpValue.width(), tmpValue.height()); });
}
void QIconEngine___availableSizes_setList(void* ptr, void* i)
{
static_cast<QList<QSize>*>(ptr)->append(*static_cast<QSize*>(i));
}
void* QIconEngine___availableSizes_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QSize>();
}
class MyQIconEnginePlugin: public QIconEnginePlugin
{
public:
MyQIconEnginePlugin(QObject *parent = Q_NULLPTR) : QIconEnginePlugin(parent) {QIconEnginePlugin_QIconEnginePlugin_QRegisterMetaType();};
QIconEngine * create(const QString & filename) { QByteArray t08deae = filename.toUtf8(); QtGui_PackedString filenamePacked = { const_cast<char*>(t08deae.prepend("WHITESPACE").constData()+10), t08deae.size()-10 };return static_cast<QIconEngine*>(callbackQIconEnginePlugin_Create(this, filenamePacked)); };
~MyQIconEnginePlugin() { callbackQIconEnginePlugin_DestroyQIconEnginePlugin(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQIconEnginePlugin_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQIconEnginePlugin_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQIconEnginePlugin_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQIconEnginePlugin_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQIconEnginePlugin_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQIconEnginePlugin_CustomEvent(this, event); };
void deleteLater() { callbackQIconEnginePlugin_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQIconEnginePlugin_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQIconEnginePlugin_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQIconEnginePlugin_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQIconEnginePlugin_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQIconEnginePlugin*)
int QIconEnginePlugin_QIconEnginePlugin_QRegisterMetaType(){qRegisterMetaType<QIconEnginePlugin*>(); return qRegisterMetaType<MyQIconEnginePlugin*>();}
void* QIconEnginePlugin_Create(void* ptr, struct QtGui_PackedString filename)
{
return static_cast<QIconEnginePlugin*>(ptr)->create(QString::fromUtf8(filename.data, filename.len));
}
void* QIconEnginePlugin_NewQIconEnginePlugin(void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQIconEnginePlugin(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQIconEnginePlugin(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQIconEnginePlugin(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQIconEnginePlugin(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQIconEnginePlugin(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQIconEnginePlugin(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQIconEnginePlugin(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQIconEnginePlugin(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQIconEnginePlugin(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQIconEnginePlugin(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQIconEnginePlugin(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQIconEnginePlugin(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQIconEnginePlugin(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQIconEnginePlugin(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQIconEnginePlugin(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQIconEnginePlugin(static_cast<QWindow*>(parent));
} else {
return new MyQIconEnginePlugin(static_cast<QObject*>(parent));
}
}
struct QtGui_PackedString QIconEnginePlugin_QIconEnginePlugin_Tr(char* s, char* c, int n)
{
return ({ QByteArray t5dd8f4 = QIconEnginePlugin::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t5dd8f4.prepend("WHITESPACE").constData()+10), t5dd8f4.size()-10 }; });
}
struct QtGui_PackedString QIconEnginePlugin_QIconEnginePlugin_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray tc85ff8 = QIconEnginePlugin::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(tc85ff8.prepend("WHITESPACE").constData()+10), tc85ff8.size()-10 }; });
}
void QIconEnginePlugin_DestroyQIconEnginePlugin(void* ptr)
{
static_cast<QIconEnginePlugin*>(ptr)->~QIconEnginePlugin();
}
void QIconEnginePlugin_DestroyQIconEnginePluginDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QIconEnginePlugin_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::metaObject());
}
void* QIconEnginePlugin___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QIconEnginePlugin___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QIconEnginePlugin___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QIconEnginePlugin___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QIconEnginePlugin___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QIconEnginePlugin___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QIconEnginePlugin___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QIconEnginePlugin___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QIconEnginePlugin___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QIconEnginePlugin___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QIconEnginePlugin___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QIconEnginePlugin___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QIconEnginePlugin___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QIconEnginePlugin___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QIconEnginePlugin___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QIconEnginePlugin_EventDefault(void* ptr, void* e)
{
return static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::event(static_cast<QEvent*>(e));
}
char QIconEnginePlugin_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QIconEnginePlugin_ChildEventDefault(void* ptr, void* event)
{
static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::childEvent(static_cast<QChildEvent*>(event));
}
void QIconEnginePlugin_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QIconEnginePlugin_CustomEventDefault(void* ptr, void* event)
{
static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::customEvent(static_cast<QEvent*>(event));
}
void QIconEnginePlugin_DeleteLaterDefault(void* ptr)
{
static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::deleteLater();
}
void QIconEnginePlugin_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QIconEnginePlugin_TimerEventDefault(void* ptr, void* event)
{
static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::timerEvent(static_cast<QTimerEvent*>(event));
}
class MyQImage: public QImage
{
public:
MyQImage() : QImage() {};
MyQImage(QImage &&other) : QImage(other) {};
MyQImage(const QImage &image) : QImage(image) {};
MyQImage(const QSize &size, QImage::Format format) : QImage(size, format) {};
MyQImage(const QString &fileName, const char *format = Q_NULLPTR) : QImage(fileName, format) {};
MyQImage(const uchar *data, int width, int height, QImage::Format format) : QImage(data, width, height, format) {};
MyQImage(const uchar *data, int width, int height, int bytesPerLine, QImage::Format format) : QImage(data, width, height, bytesPerLine, format) {};
MyQImage(int width, int height, QImage::Format format) : QImage(width, height, format) {};
MyQImage(uchar *data, int width, int height, QImage::Format format) : QImage(data, width, height, format) {};
MyQImage(uchar *data, int width, int height, int bytesPerLine, QImage::Format format) : QImage(data, width, height, bytesPerLine, format) {};
~MyQImage() { callbackQImage_DestroyQImage(this); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQImage_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPaintDevice_Metric(const_cast<void*>(static_cast<const void*>(this)), metric); };
};
void* QImage_Mirrored2(void* ptr, char horizontal, char vertical)
{
return new QImage(static_cast<QImage*>(ptr)->mirrored(horizontal != 0, vertical != 0));
}
void* QImage_RgbSwapped2(void* ptr)
{
return new QImage(static_cast<QImage*>(ptr)->rgbSwapped());
}
void* QImage_ConvertToFormat2(void* ptr, long long format, long long flags)
{
return new QImage(static_cast<QImage*>(ptr)->convertToFormat(static_cast<QImage::Format>(format), static_cast<Qt::ImageConversionFlag>(flags)));
}
void* QImage_QImage_FromData2(void* data, char* format)
{
return new QImage(QImage::fromData(*static_cast<QByteArray*>(data), const_cast<const char*>(format)));
}
void* QImage_QImage_FromData(char* data, int size, char* format)
{
return new QImage(QImage::fromData(const_cast<const uchar*>(static_cast<uchar*>(static_cast<void*>(data))), size, const_cast<const char*>(format)));
}
void* QImage_NewQImage()
{
return new MyQImage();
}
void* QImage_NewQImage11(void* other)
{
return new MyQImage(*static_cast<QImage*>(other));
}
void* QImage_NewQImage10(void* image)
{
return new MyQImage(*static_cast<QImage*>(image));
}
void* QImage_NewQImage2(void* size, long long format)
{
return new MyQImage(*static_cast<QSize*>(size), static_cast<QImage::Format>(format));
}
void* QImage_NewQImage9(struct QtGui_PackedString fileName, char* format)
{
return new MyQImage(QString::fromUtf8(fileName.data, fileName.len), const_cast<const char*>(format));
}
void* QImage_NewQImage5(char* data, int width, int height, long long format)
{
return new MyQImage(const_cast<const uchar*>(static_cast<uchar*>(static_cast<void*>(data))), width, height, static_cast<QImage::Format>(format));
}
void* QImage_NewQImage7(char* data, int width, int height, int bytesPerLine, long long format)
{
return new MyQImage(const_cast<const uchar*>(static_cast<uchar*>(static_cast<void*>(data))), width, height, bytesPerLine, static_cast<QImage::Format>(format));
}
void* QImage_NewQImage3(int width, int height, long long format)
{
return new MyQImage(width, height, static_cast<QImage::Format>(format));
}
void* QImage_NewQImage4(char* data, int width, int height, long long format)
{
return new MyQImage(static_cast<uchar*>(static_cast<void*>(data)), width, height, static_cast<QImage::Format>(format));
}
void* QImage_NewQImage6(char* data, int width, int height, int bytesPerLine, long long format)
{
return new MyQImage(static_cast<uchar*>(static_cast<void*>(data)), width, height, bytesPerLine, static_cast<QImage::Format>(format));
}
long long QImage_QImage_ToImageFormat(void* format)
{
return QImage::toImageFormat(*static_cast<QPixelFormat*>(format));
}
void* QImage_QImage_TrueMatrix(void* matrix, int width, int height)
{
return new QMatrix(QImage::trueMatrix(*static_cast<QMatrix*>(matrix), width, height));
}
void* QImage_QImage_ToPixelFormat(long long format)
{
return new QPixelFormat(QImage::toPixelFormat(static_cast<QImage::Format>(format)));
}
void* QImage_QImage_TrueMatrix2(void* matrix, int width, int height)
{
return new QTransform(QImage::trueMatrix(*static_cast<QTransform*>(matrix), width, height));
}
char QImage_Load2(void* ptr, void* device, char* format)
{
return static_cast<QImage*>(ptr)->load(static_cast<QIODevice*>(device), const_cast<const char*>(format));
}
char QImage_Load(void* ptr, struct QtGui_PackedString fileName, char* format)
{
return static_cast<QImage*>(ptr)->load(QString::fromUtf8(fileName.data, fileName.len), const_cast<const char*>(format));
}
char QImage_LoadFromData2(void* ptr, void* data, char* format)
{
return static_cast<QImage*>(ptr)->loadFromData(*static_cast<QByteArray*>(data), const_cast<const char*>(format));
}
char QImage_LoadFromData(void* ptr, char* data, int l, char* format)
{
return static_cast<QImage*>(ptr)->loadFromData(const_cast<const uchar*>(static_cast<uchar*>(static_cast<void*>(data))), l, const_cast<const char*>(format));
}
char QImage_ReinterpretAsFormat(void* ptr, long long format)
{
return static_cast<QImage*>(ptr)->reinterpretAsFormat(static_cast<QImage::Format>(format));
}
struct QtGui_PackedString QImage_Bits(void* ptr)
{
return ({ char* te11021 = static_cast<char*>(static_cast<void*>(static_cast<QImage*>(ptr)->bits())); QtGui_PackedString { te11021, -1 }; });
}
struct QtGui_PackedString QImage_ScanLine(void* ptr, int i)
{
return ({ char* t3248e5 = static_cast<char*>(static_cast<void*>(static_cast<QImage*>(ptr)->scanLine(i))); QtGui_PackedString { t3248e5, -1 }; });
}
void QImage_Fill3(void* ptr, long long color)
{
static_cast<QImage*>(ptr)->fill(static_cast<Qt::GlobalColor>(color));
}
void QImage_Fill2(void* ptr, void* color)
{
static_cast<QImage*>(ptr)->fill(*static_cast<QColor*>(color));
}
void QImage_Fill(void* ptr, unsigned int pixelValue)
{
static_cast<QImage*>(ptr)->fill(pixelValue);
}
void QImage_InvertPixels(void* ptr, long long mode)
{
static_cast<QImage*>(ptr)->invertPixels(static_cast<QImage::InvertMode>(mode));
}
void QImage_SetColorCount(void* ptr, int colorCount)
{
static_cast<QImage*>(ptr)->setColorCount(colorCount);
}
void QImage_SetDevicePixelRatio(void* ptr, double scaleFactor)
{
static_cast<QImage*>(ptr)->setDevicePixelRatio(scaleFactor);
}
void QImage_SetDotsPerMeterX(void* ptr, int x)
{
static_cast<QImage*>(ptr)->setDotsPerMeterX(x);
}
void QImage_SetDotsPerMeterY(void* ptr, int y)
{
static_cast<QImage*>(ptr)->setDotsPerMeterY(y);
}
void QImage_SetOffset(void* ptr, void* offset)
{
static_cast<QImage*>(ptr)->setOffset(*static_cast<QPoint*>(offset));
}
void QImage_SetPixel(void* ptr, void* position, unsigned int index_or_rgb)
{
static_cast<QImage*>(ptr)->setPixel(*static_cast<QPoint*>(position), index_or_rgb);
}
void QImage_SetPixel2(void* ptr, int x, int y, unsigned int index_or_rgb)
{
static_cast<QImage*>(ptr)->setPixel(x, y, index_or_rgb);
}
void QImage_SetPixelColor(void* ptr, void* position, void* color)
{
static_cast<QImage*>(ptr)->setPixelColor(*static_cast<QPoint*>(position), *static_cast<QColor*>(color));
}
void QImage_SetPixelColor2(void* ptr, int x, int y, void* color)
{
static_cast<QImage*>(ptr)->setPixelColor(x, y, *static_cast<QColor*>(color));
}
void QImage_SetText(void* ptr, struct QtGui_PackedString key, struct QtGui_PackedString text)
{
static_cast<QImage*>(ptr)->setText(QString::fromUtf8(key.data, key.len), QString::fromUtf8(text.data, text.len));
}
void QImage_Swap(void* ptr, void* other)
{
static_cast<QImage*>(ptr)->swap(*static_cast<QImage*>(other));
}
void QImage_DestroyQImage(void* ptr)
{
static_cast<QImage*>(ptr)->~QImage();
}
void QImage_DestroyQImageDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QImage_PixelColor(void* ptr, void* position)
{
return new QColor(static_cast<QImage*>(ptr)->pixelColor(*static_cast<QPoint*>(position)));
}
void* QImage_PixelColor2(void* ptr, int x, int y)
{
return new QColor(static_cast<QImage*>(ptr)->pixelColor(x, y));
}
void* QImage_ConvertToFormat(void* ptr, long long format, long long flags)
{
return new QImage(static_cast<QImage*>(ptr)->convertToFormat(static_cast<QImage::Format>(format), static_cast<Qt::ImageConversionFlag>(flags)));
}
void* QImage_Copy(void* ptr, void* rectangle)
{
return new QImage(static_cast<QImage*>(ptr)->copy(*static_cast<QRect*>(rectangle)));
}
void* QImage_Copy2(void* ptr, int x, int y, int width, int height)
{
return new QImage(static_cast<QImage*>(ptr)->copy(x, y, width, height));
}
void* QImage_CreateAlphaMask(void* ptr, long long flags)
{
return new QImage(static_cast<QImage*>(ptr)->createAlphaMask(static_cast<Qt::ImageConversionFlag>(flags)));
}
void* QImage_CreateHeuristicMask(void* ptr, char clipTight)
{
return new QImage(static_cast<QImage*>(ptr)->createHeuristicMask(clipTight != 0));
}
void* QImage_Mirrored(void* ptr, char horizontal, char vertical)
{
return new QImage(static_cast<QImage*>(ptr)->mirrored(horizontal != 0, vertical != 0));
}
void* QImage_RgbSwapped(void* ptr)
{
return new QImage(static_cast<QImage*>(ptr)->rgbSwapped());
}
void* QImage_Scaled(void* ptr, void* size, long long aspectRatioMode, long long transformMode)
{
return new QImage(static_cast<QImage*>(ptr)->scaled(*static_cast<QSize*>(size), static_cast<Qt::AspectRatioMode>(aspectRatioMode), static_cast<Qt::TransformationMode>(transformMode)));
}
void* QImage_Scaled2(void* ptr, int width, int height, long long aspectRatioMode, long long transformMode)
{
return new QImage(static_cast<QImage*>(ptr)->scaled(width, height, static_cast<Qt::AspectRatioMode>(aspectRatioMode), static_cast<Qt::TransformationMode>(transformMode)));
}
void* QImage_ScaledToHeight(void* ptr, int height, long long mode)
{
return new QImage(static_cast<QImage*>(ptr)->scaledToHeight(height, static_cast<Qt::TransformationMode>(mode)));
}
void* QImage_ScaledToWidth(void* ptr, int width, long long mode)
{
return new QImage(static_cast<QImage*>(ptr)->scaledToWidth(width, static_cast<Qt::TransformationMode>(mode)));
}
void* QImage_SmoothScaled(void* ptr, int w, int h)
{
return new QImage(static_cast<QImage*>(ptr)->smoothScaled(w, h));
}
void* QImage_Transformed(void* ptr, void* matrix, long long mode)
{
return new QImage(static_cast<QImage*>(ptr)->transformed(*static_cast<QMatrix*>(matrix), static_cast<Qt::TransformationMode>(mode)));
}
void* QImage_Transformed2(void* ptr, void* matrix, long long mode)
{
return new QImage(static_cast<QImage*>(ptr)->transformed(*static_cast<QTransform*>(matrix), static_cast<Qt::TransformationMode>(mode)));
}
long long QImage_Format(void* ptr)
{
return static_cast<QImage*>(ptr)->format();
}
void* QImage_PixelFormat(void* ptr)
{
return new QPixelFormat(static_cast<QImage*>(ptr)->pixelFormat());
}
void* QImage_Offset(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QImage*>(ptr)->offset(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QImage_Rect(void* ptr)
{
return ({ QRect tmpValue = static_cast<QImage*>(ptr)->rect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QImage_Size(void* ptr)
{
return ({ QSize tmpValue = static_cast<QImage*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
}
struct QtGui_PackedString QImage_Text(void* ptr, struct QtGui_PackedString key)
{
return ({ QByteArray t3cc0e5 = static_cast<QImage*>(ptr)->text(QString::fromUtf8(key.data, key.len)).toUtf8(); QtGui_PackedString { const_cast<char*>(t3cc0e5.prepend("WHITESPACE").constData()+10), t3cc0e5.size()-10 }; });
}
struct QtGui_PackedString QImage_TextKeys(void* ptr)
{
return ({ QByteArray t71d2ff = static_cast<QImage*>(ptr)->textKeys().join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t71d2ff.prepend("WHITESPACE").constData()+10), t71d2ff.size()-10 }; });
}
char QImage_AllGray(void* ptr)
{
return static_cast<QImage*>(ptr)->allGray();
}
char QImage_HasAlphaChannel(void* ptr)
{
return static_cast<QImage*>(ptr)->hasAlphaChannel();
}
char QImage_IsGrayscale(void* ptr)
{
return static_cast<QImage*>(ptr)->isGrayscale();
}
char QImage_IsNull(void* ptr)
{
return static_cast<QImage*>(ptr)->isNull();
}
char QImage_Save2(void* ptr, void* device, char* format, int quality)
{
return static_cast<QImage*>(ptr)->save(static_cast<QIODevice*>(device), const_cast<const char*>(format), quality);
}
char QImage_Save(void* ptr, struct QtGui_PackedString fileName, char* format, int quality)
{
return static_cast<QImage*>(ptr)->save(QString::fromUtf8(fileName.data, fileName.len), const_cast<const char*>(format), quality);
}
char QImage_Valid(void* ptr, void* pos)
{
return static_cast<QImage*>(ptr)->valid(*static_cast<QPoint*>(pos));
}
char QImage_Valid2(void* ptr, int x, int y)
{
return static_cast<QImage*>(ptr)->valid(x, y);
}
struct QtGui_PackedString QImage_Bits2(void* ptr)
{
return ({ char* te11021 = static_cast<char*>(static_cast<void*>(const_cast<uchar*>(static_cast<QImage*>(ptr)->bits()))); QtGui_PackedString { te11021, -1 }; });
}
struct QtGui_PackedString QImage_ConstBits(void* ptr)
{
return ({ char* t467df0 = static_cast<char*>(static_cast<void*>(const_cast<uchar*>(static_cast<QImage*>(ptr)->constBits()))); QtGui_PackedString { t467df0, -1 }; });
}
struct QtGui_PackedString QImage_ConstScanLine(void* ptr, int i)
{
return ({ char* t2457d1 = static_cast<char*>(static_cast<void*>(const_cast<uchar*>(static_cast<QImage*>(ptr)->constScanLine(i)))); QtGui_PackedString { t2457d1, -1 }; });
}
struct QtGui_PackedString QImage_ScanLine2(void* ptr, int i)
{
return ({ char* t3248e5 = static_cast<char*>(static_cast<void*>(const_cast<uchar*>(static_cast<QImage*>(ptr)->scanLine(i)))); QtGui_PackedString { t3248e5, -1 }; });
}
int QImage_BitPlaneCount(void* ptr)
{
return static_cast<QImage*>(ptr)->bitPlaneCount();
}
int QImage_BytesPerLine(void* ptr)
{
return static_cast<QImage*>(ptr)->bytesPerLine();
}
int QImage_DotsPerMeterX(void* ptr)
{
return static_cast<QImage*>(ptr)->dotsPerMeterX();
}
int QImage_DotsPerMeterY(void* ptr)
{
return static_cast<QImage*>(ptr)->dotsPerMeterY();
}
int QImage_PixelIndex(void* ptr, void* position)
{
return static_cast<QImage*>(ptr)->pixelIndex(*static_cast<QPoint*>(position));
}
int QImage_PixelIndex2(void* ptr, int x, int y)
{
return static_cast<QImage*>(ptr)->pixelIndex(x, y);
}
long long QImage_CacheKey(void* ptr)
{
return static_cast<QImage*>(ptr)->cacheKey();
}
double QImage_DevicePixelRatio(void* ptr)
{
return static_cast<QImage*>(ptr)->devicePixelRatio();
}
void* QImage_ToVariant(void* ptr)
{
return new QVariant(*static_cast<QImage*>(ptr));
}
void* QImage___setColorTable_colors_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QRgb>();
}
void* QImage___convertToFormat_colorTable_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QRgb>();
}
void* QImage___colorTable_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QRgb>();
}
void* QImage_PaintEngine(void* ptr)
{
return static_cast<QImage*>(ptr)->paintEngine();
}
void* QImage_PaintEngineDefault(void* ptr)
{
return static_cast<QImage*>(ptr)->QImage::paintEngine();
}
class MyQImageIOHandler: public QImageIOHandler
{
public:
MyQImageIOHandler() : QImageIOHandler() {};
bool jumpToImage(int imageNumber) { return callbackQImageIOHandler_JumpToImage(this, imageNumber) != 0; };
bool jumpToNextImage() { return callbackQImageIOHandler_JumpToNextImage(this) != 0; };
bool read(QImage * image) { return callbackQImageIOHandler_Read(this, image) != 0; };
bool write(const QImage & image) { return callbackQImageIOHandler_Write(this, const_cast<QImage*>(&image)) != 0; };
void setOption(QImageIOHandler::ImageOption option, const QVariant & value) { callbackQImageIOHandler_SetOption(this, option, const_cast<QVariant*>(&value)); };
~MyQImageIOHandler() { callbackQImageIOHandler_DestroyQImageIOHandler(this); };
QRect currentImageRect() const { return *static_cast<QRect*>(callbackQImageIOHandler_CurrentImageRect(const_cast<void*>(static_cast<const void*>(this)))); };
QVariant option(QImageIOHandler::ImageOption option) const { return *static_cast<QVariant*>(callbackQImageIOHandler_Option(const_cast<void*>(static_cast<const void*>(this)), option)); };
bool canRead() const { return callbackQImageIOHandler_CanRead(const_cast<void*>(static_cast<const void*>(this))) != 0; };
bool supportsOption(QImageIOHandler::ImageOption option) const { return callbackQImageIOHandler_SupportsOption(const_cast<void*>(static_cast<const void*>(this)), option) != 0; };
int currentImageNumber() const { return callbackQImageIOHandler_CurrentImageNumber(const_cast<void*>(static_cast<const void*>(this))); };
int imageCount() const { return callbackQImageIOHandler_ImageCount(const_cast<void*>(static_cast<const void*>(this))); };
int loopCount() const { return callbackQImageIOHandler_LoopCount(const_cast<void*>(static_cast<const void*>(this))); };
int nextImageDelay() const { return callbackQImageIOHandler_NextImageDelay(const_cast<void*>(static_cast<const void*>(this))); };
};
void* QImageIOHandler_NewQImageIOHandler()
{
return new MyQImageIOHandler();
}
char QImageIOHandler_JumpToImage(void* ptr, int imageNumber)
{
return static_cast<QImageIOHandler*>(ptr)->jumpToImage(imageNumber);
}
char QImageIOHandler_JumpToImageDefault(void* ptr, int imageNumber)
{
return static_cast<QImageIOHandler*>(ptr)->QImageIOHandler::jumpToImage(imageNumber);
}
char QImageIOHandler_JumpToNextImage(void* ptr)
{
return static_cast<QImageIOHandler*>(ptr)->jumpToNextImage();
}
char QImageIOHandler_JumpToNextImageDefault(void* ptr)
{
return static_cast<QImageIOHandler*>(ptr)->QImageIOHandler::jumpToNextImage();
}
char QImageIOHandler_Read(void* ptr, void* image)
{
return static_cast<QImageIOHandler*>(ptr)->read(static_cast<QImage*>(image));
}
char QImageIOHandler_Write(void* ptr, void* image)
{
return static_cast<QImageIOHandler*>(ptr)->write(*static_cast<QImage*>(image));
}
char QImageIOHandler_WriteDefault(void* ptr, void* image)
{
return static_cast<QImageIOHandler*>(ptr)->QImageIOHandler::write(*static_cast<QImage*>(image));
}
void QImageIOHandler_SetDevice(void* ptr, void* device)
{
static_cast<QImageIOHandler*>(ptr)->setDevice(static_cast<QIODevice*>(device));
}
void QImageIOHandler_SetFormat(void* ptr, void* format)
{
static_cast<QImageIOHandler*>(ptr)->setFormat(*static_cast<QByteArray*>(format));
}
void QImageIOHandler_SetOption(void* ptr, long long option, void* value)
{
static_cast<QImageIOHandler*>(ptr)->setOption(static_cast<QImageIOHandler::ImageOption>(option), *static_cast<QVariant*>(value));
}
void QImageIOHandler_SetOptionDefault(void* ptr, long long option, void* value)
{
static_cast<QImageIOHandler*>(ptr)->QImageIOHandler::setOption(static_cast<QImageIOHandler::ImageOption>(option), *static_cast<QVariant*>(value));
}
void QImageIOHandler_DestroyQImageIOHandler(void* ptr)
{
static_cast<QImageIOHandler*>(ptr)->~QImageIOHandler();
}
void QImageIOHandler_DestroyQImageIOHandlerDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QImageIOHandler_Format(void* ptr)
{
return new QByteArray(static_cast<QImageIOHandler*>(ptr)->format());
}
void* QImageIOHandler_Device(void* ptr)
{
return static_cast<QImageIOHandler*>(ptr)->device();
}
void* QImageIOHandler_CurrentImageRect(void* ptr)
{
return ({ QRect tmpValue = static_cast<QImageIOHandler*>(ptr)->currentImageRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QImageIOHandler_CurrentImageRectDefault(void* ptr)
{
return ({ QRect tmpValue = static_cast<QImageIOHandler*>(ptr)->QImageIOHandler::currentImageRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QImageIOHandler_Option(void* ptr, long long option)
{
return new QVariant(static_cast<QImageIOHandler*>(ptr)->option(static_cast<QImageIOHandler::ImageOption>(option)));
}
void* QImageIOHandler_OptionDefault(void* ptr, long long option)
{
return new QVariant(static_cast<QImageIOHandler*>(ptr)->QImageIOHandler::option(static_cast<QImageIOHandler::ImageOption>(option)));
}
char QImageIOHandler_CanRead(void* ptr)
{
return static_cast<QImageIOHandler*>(ptr)->canRead();
}
char QImageIOHandler_SupportsOption(void* ptr, long long option)
{
return static_cast<QImageIOHandler*>(ptr)->supportsOption(static_cast<QImageIOHandler::ImageOption>(option));
}
char QImageIOHandler_SupportsOptionDefault(void* ptr, long long option)
{
return static_cast<QImageIOHandler*>(ptr)->QImageIOHandler::supportsOption(static_cast<QImageIOHandler::ImageOption>(option));
}
int QImageIOHandler_CurrentImageNumber(void* ptr)
{
return static_cast<QImageIOHandler*>(ptr)->currentImageNumber();
}
int QImageIOHandler_CurrentImageNumberDefault(void* ptr)
{
return static_cast<QImageIOHandler*>(ptr)->QImageIOHandler::currentImageNumber();
}
int QImageIOHandler_ImageCount(void* ptr)
{
return static_cast<QImageIOHandler*>(ptr)->imageCount();
}
int QImageIOHandler_ImageCountDefault(void* ptr)
{
return static_cast<QImageIOHandler*>(ptr)->QImageIOHandler::imageCount();
}
int QImageIOHandler_LoopCount(void* ptr)
{
return static_cast<QImageIOHandler*>(ptr)->loopCount();
}
int QImageIOHandler_LoopCountDefault(void* ptr)
{
return static_cast<QImageIOHandler*>(ptr)->QImageIOHandler::loopCount();
}
int QImageIOHandler_NextImageDelay(void* ptr)
{
return static_cast<QImageIOHandler*>(ptr)->nextImageDelay();
}
int QImageIOHandler_NextImageDelayDefault(void* ptr)
{
return static_cast<QImageIOHandler*>(ptr)->QImageIOHandler::nextImageDelay();
}
void QImageIOHandler_SetFormat2(void* ptr, void* format)
{
static_cast<QImageIOHandler*>(ptr)->setFormat(*static_cast<QByteArray*>(format));
}
class MyQImageIOPlugin: public QImageIOPlugin
{
public:
MyQImageIOPlugin(QObject *parent = Q_NULLPTR) : QImageIOPlugin(parent) {QImageIOPlugin_QImageIOPlugin_QRegisterMetaType();};
~MyQImageIOPlugin() { callbackQImageIOPlugin_DestroyQImageIOPlugin(this); };
QImageIOHandler * create(QIODevice * device, const QByteArray & format) const { return static_cast<QImageIOHandler*>(callbackQImageIOPlugin_Create(const_cast<void*>(static_cast<const void*>(this)), device, const_cast<QByteArray*>(&format))); };
QImageIOPlugin::Capabilities capabilities(QIODevice * device, const QByteArray & format) const { return static_cast<QImageIOPlugin::Capability>(callbackQImageIOPlugin_Capabilities(const_cast<void*>(static_cast<const void*>(this)), device, const_cast<QByteArray*>(&format))); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQImageIOPlugin_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQImageIOPlugin_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQImageIOPlugin_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQImageIOPlugin_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQImageIOPlugin_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQImageIOPlugin_CustomEvent(this, event); };
void deleteLater() { callbackQImageIOPlugin_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQImageIOPlugin_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQImageIOPlugin_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQImageIOPlugin_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQImageIOPlugin_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQImageIOPlugin*)
int QImageIOPlugin_QImageIOPlugin_QRegisterMetaType(){qRegisterMetaType<QImageIOPlugin*>(); return qRegisterMetaType<MyQImageIOPlugin*>();}
void* QImageIOPlugin_NewQImageIOPlugin(void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQImageIOPlugin(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQImageIOPlugin(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQImageIOPlugin(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQImageIOPlugin(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQImageIOPlugin(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQImageIOPlugin(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQImageIOPlugin(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQImageIOPlugin(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQImageIOPlugin(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQImageIOPlugin(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQImageIOPlugin(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQImageIOPlugin(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQImageIOPlugin(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQImageIOPlugin(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQImageIOPlugin(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQImageIOPlugin(static_cast<QWindow*>(parent));
} else {
return new MyQImageIOPlugin(static_cast<QObject*>(parent));
}
}
struct QtGui_PackedString QImageIOPlugin_QImageIOPlugin_Tr(char* s, char* c, int n)
{
return ({ QByteArray t879a9d = QImageIOPlugin::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t879a9d.prepend("WHITESPACE").constData()+10), t879a9d.size()-10 }; });
}
struct QtGui_PackedString QImageIOPlugin_QImageIOPlugin_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray t655f48 = QImageIOPlugin::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t655f48.prepend("WHITESPACE").constData()+10), t655f48.size()-10 }; });
}
void QImageIOPlugin_DestroyQImageIOPlugin(void* ptr)
{
static_cast<QImageIOPlugin*>(ptr)->~QImageIOPlugin();
}
void QImageIOPlugin_DestroyQImageIOPluginDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QImageIOPlugin_Create(void* ptr, void* device, void* format)
{
return static_cast<QImageIOPlugin*>(ptr)->create(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format));
}
long long QImageIOPlugin_Capabilities(void* ptr, void* device, void* format)
{
return static_cast<QImageIOPlugin*>(ptr)->capabilities(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format));
}
void* QImageIOPlugin_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::metaObject());
}
void* QImageIOPlugin___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QImageIOPlugin___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QImageIOPlugin___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QImageIOPlugin___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QImageIOPlugin___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QImageIOPlugin___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QImageIOPlugin___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QImageIOPlugin___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QImageIOPlugin___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QImageIOPlugin___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QImageIOPlugin___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QImageIOPlugin___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QImageIOPlugin___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QImageIOPlugin___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QImageIOPlugin___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QImageIOPlugin_EventDefault(void* ptr, void* e)
{
return static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::event(static_cast<QEvent*>(e));
}
char QImageIOPlugin_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QImageIOPlugin_ChildEventDefault(void* ptr, void* event)
{
static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::childEvent(static_cast<QChildEvent*>(event));
}
void QImageIOPlugin_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QImageIOPlugin_CustomEventDefault(void* ptr, void* event)
{
static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::customEvent(static_cast<QEvent*>(event));
}
void QImageIOPlugin_DeleteLaterDefault(void* ptr)
{
static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::deleteLater();
}
void QImageIOPlugin_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QImageIOPlugin_TimerEventDefault(void* ptr, void* event)
{
static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::timerEvent(static_cast<QTimerEvent*>(event));
}
void* QImageReader_QImageReader_ImageFormat3(void* device)
{
return new QByteArray(QImageReader::imageFormat(static_cast<QIODevice*>(device)));
}
void* QImageReader_QImageReader_ImageFormat2(struct QtGui_PackedString fileName)
{
return new QByteArray(QImageReader::imageFormat(QString::fromUtf8(fileName.data, fileName.len)));
}
void* QImageReader_Read(void* ptr)
{
return new QImage(static_cast<QImageReader*>(ptr)->read());
}
void* QImageReader_NewQImageReader()
{
return new QImageReader();
}
void* QImageReader_NewQImageReader2(void* device, void* format)
{
return new QImageReader(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format));
}
void* QImageReader_NewQImageReader3(struct QtGui_PackedString fileName, void* format)
{
return new QImageReader(QString::fromUtf8(fileName.data, fileName.len), *static_cast<QByteArray*>(format));
}
struct QtGui_PackedList QImageReader_QImageReader_SupportedImageFormats()
{
return ({ QList<QByteArray>* tmpValue = new QList<QByteArray>(QImageReader::supportedImageFormats()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedList QImageReader_QImageReader_SupportedMimeTypes()
{
return ({ QList<QByteArray>* tmpValue = new QList<QByteArray>(QImageReader::supportedMimeTypes()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedString QImageReader_QImageReader_Tr(char* sourceText, char* disambiguation, int n)
{
return ({ QByteArray t5d3881 = QImageReader::tr(const_cast<const char*>(sourceText), const_cast<const char*>(disambiguation), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t5d3881.prepend("WHITESPACE").constData()+10), t5d3881.size()-10 }; });
}
struct QtGui_PackedString QImageReader_QImageReader_TrUtf8(char* sourceText, char* disambiguation, int n)
{
return ({ QByteArray t4648a6 = QImageReader::trUtf8(const_cast<const char*>(sourceText), const_cast<const char*>(disambiguation), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t4648a6.prepend("WHITESPACE").constData()+10), t4648a6.size()-10 }; });
}
char QImageReader_JumpToImage(void* ptr, int imageNumber)
{
return static_cast<QImageReader*>(ptr)->jumpToImage(imageNumber);
}
char QImageReader_JumpToNextImage(void* ptr)
{
return static_cast<QImageReader*>(ptr)->jumpToNextImage();
}
char QImageReader_Read2(void* ptr, void* image)
{
return static_cast<QImageReader*>(ptr)->read(static_cast<QImage*>(image));
}
void QImageReader_SetAutoDetectImageFormat(void* ptr, char enabled)
{
static_cast<QImageReader*>(ptr)->setAutoDetectImageFormat(enabled != 0);
}
void QImageReader_SetAutoTransform(void* ptr, char enabled)
{
static_cast<QImageReader*>(ptr)->setAutoTransform(enabled != 0);
}
void QImageReader_SetBackgroundColor(void* ptr, void* color)
{
static_cast<QImageReader*>(ptr)->setBackgroundColor(*static_cast<QColor*>(color));
}
void QImageReader_SetClipRect(void* ptr, void* rect)
{
static_cast<QImageReader*>(ptr)->setClipRect(*static_cast<QRect*>(rect));
}
void QImageReader_SetDecideFormatFromContent(void* ptr, char ignored)
{
static_cast<QImageReader*>(ptr)->setDecideFormatFromContent(ignored != 0);
}
void QImageReader_SetDevice(void* ptr, void* device)
{
static_cast<QImageReader*>(ptr)->setDevice(static_cast<QIODevice*>(device));
}
void QImageReader_SetFileName(void* ptr, struct QtGui_PackedString fileName)
{
static_cast<QImageReader*>(ptr)->setFileName(QString::fromUtf8(fileName.data, fileName.len));
}
void QImageReader_SetFormat(void* ptr, void* format)
{
static_cast<QImageReader*>(ptr)->setFormat(*static_cast<QByteArray*>(format));
}
void QImageReader_SetGamma(void* ptr, float gamma)
{
static_cast<QImageReader*>(ptr)->setGamma(gamma);
}
void QImageReader_SetQuality(void* ptr, int quality)
{
static_cast<QImageReader*>(ptr)->setQuality(quality);
}
void QImageReader_SetScaledClipRect(void* ptr, void* rect)
{
static_cast<QImageReader*>(ptr)->setScaledClipRect(*static_cast<QRect*>(rect));
}
void QImageReader_SetScaledSize(void* ptr, void* size)
{
static_cast<QImageReader*>(ptr)->setScaledSize(*static_cast<QSize*>(size));
}
void QImageReader_DestroyQImageReader(void* ptr)
{
static_cast<QImageReader*>(ptr)->~QImageReader();
}
void* QImageReader_Format(void* ptr)
{
return new QByteArray(static_cast<QImageReader*>(ptr)->format());
}
void* QImageReader_SubType(void* ptr)
{
return new QByteArray(static_cast<QImageReader*>(ptr)->subType());
}
void* QImageReader_BackgroundColor(void* ptr)
{
return new QColor(static_cast<QImageReader*>(ptr)->backgroundColor());
}
void* QImageReader_Device(void* ptr)
{
return static_cast<QImageReader*>(ptr)->device();
}
long long QImageReader_ImageFormat(void* ptr)
{
return static_cast<QImageReader*>(ptr)->imageFormat();
}
long long QImageReader_Transformation(void* ptr)
{
return static_cast<QImageReader*>(ptr)->transformation();
}
long long QImageReader_Error(void* ptr)
{
return static_cast<QImageReader*>(ptr)->error();
}
struct QtGui_PackedList QImageReader_SupportedSubTypes(void* ptr)
{
return ({ QList<QByteArray>* tmpValue = new QList<QByteArray>(static_cast<QImageReader*>(ptr)->supportedSubTypes()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QImageReader_ClipRect(void* ptr)
{
return ({ QRect tmpValue = static_cast<QImageReader*>(ptr)->clipRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QImageReader_CurrentImageRect(void* ptr)
{
return ({ QRect tmpValue = static_cast<QImageReader*>(ptr)->currentImageRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QImageReader_ScaledClipRect(void* ptr)
{
return ({ QRect tmpValue = static_cast<QImageReader*>(ptr)->scaledClipRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QImageReader_ScaledSize(void* ptr)
{
return ({ QSize tmpValue = static_cast<QImageReader*>(ptr)->scaledSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}
void* QImageReader_Size(void* ptr)
{
return ({ QSize tmpValue = static_cast<QImageReader*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
}
struct QtGui_PackedString QImageReader_ErrorString(void* ptr)
{
return ({ QByteArray t444465 = static_cast<QImageReader*>(ptr)->errorString().toUtf8(); QtGui_PackedString { const_cast<char*>(t444465.prepend("WHITESPACE").constData()+10), t444465.size()-10 }; });
}
struct QtGui_PackedString QImageReader_FileName(void* ptr)
{
return ({ QByteArray t78ed9f = static_cast<QImageReader*>(ptr)->fileName().toUtf8(); QtGui_PackedString { const_cast<char*>(t78ed9f.prepend("WHITESPACE").constData()+10), t78ed9f.size()-10 }; });
}
struct QtGui_PackedString QImageReader_Text(void* ptr, struct QtGui_PackedString key)
{
return ({ QByteArray t392633 = static_cast<QImageReader*>(ptr)->text(QString::fromUtf8(key.data, key.len)).toUtf8(); QtGui_PackedString { const_cast<char*>(t392633.prepend("WHITESPACE").constData()+10), t392633.size()-10 }; });
}
struct QtGui_PackedString QImageReader_TextKeys(void* ptr)
{
return ({ QByteArray t436ca8 = static_cast<QImageReader*>(ptr)->textKeys().join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t436ca8.prepend("WHITESPACE").constData()+10), t436ca8.size()-10 }; });
}
char QImageReader_AutoDetectImageFormat(void* ptr)
{
return static_cast<QImageReader*>(ptr)->autoDetectImageFormat();
}
char QImageReader_AutoTransform(void* ptr)
{
return static_cast<QImageReader*>(ptr)->autoTransform();
}
char QImageReader_CanRead(void* ptr)
{
return static_cast<QImageReader*>(ptr)->canRead();
}
char QImageReader_DecideFormatFromContent(void* ptr)
{
return static_cast<QImageReader*>(ptr)->decideFormatFromContent();
}
char QImageReader_SupportsAnimation(void* ptr)
{
return static_cast<QImageReader*>(ptr)->supportsAnimation();
}
char QImageReader_SupportsOption(void* ptr, long long option)
{
return static_cast<QImageReader*>(ptr)->supportsOption(static_cast<QImageIOHandler::ImageOption>(option));
}
float QImageReader_Gamma(void* ptr)
{
return static_cast<QImageReader*>(ptr)->gamma();
}
int QImageReader_CurrentImageNumber(void* ptr)
{
return static_cast<QImageReader*>(ptr)->currentImageNumber();
}
int QImageReader_ImageCount(void* ptr)
{
return static_cast<QImageReader*>(ptr)->imageCount();
}
int QImageReader_LoopCount(void* ptr)
{
return static_cast<QImageReader*>(ptr)->loopCount();
}
int QImageReader_NextImageDelay(void* ptr)
{
return static_cast<QImageReader*>(ptr)->nextImageDelay();
}
int QImageReader_Quality(void* ptr)
{
return static_cast<QImageReader*>(ptr)->quality();
}
void* QImageReader___supportedImageFormats_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QImageReader___supportedImageFormats_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QImageReader___supportedImageFormats_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QImageReader___supportedMimeTypes_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QImageReader___supportedMimeTypes_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QImageReader___supportedMimeTypes_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QImageReader___supportedSubTypes_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QImageReader___supportedSubTypes_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QImageReader___supportedSubTypes_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QImageWriter_NewQImageWriter()
{
return new QImageWriter();
}
void* QImageWriter_NewQImageWriter2(void* device, void* format)
{
return new QImageWriter(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format));
}
void* QImageWriter_NewQImageWriter3(struct QtGui_PackedString fileName, void* format)
{
return new QImageWriter(QString::fromUtf8(fileName.data, fileName.len), *static_cast<QByteArray*>(format));
}
struct QtGui_PackedList QImageWriter_QImageWriter_SupportedImageFormats()
{
return ({ QList<QByteArray>* tmpValue = new QList<QByteArray>(QImageWriter::supportedImageFormats()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedList QImageWriter_QImageWriter_SupportedMimeTypes()
{
return ({ QList<QByteArray>* tmpValue = new QList<QByteArray>(QImageWriter::supportedMimeTypes()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedString QImageWriter_QImageWriter_Tr(char* sourceText, char* disambiguation, int n)
{
return ({ QByteArray tacd619 = QImageWriter::tr(const_cast<const char*>(sourceText), const_cast<const char*>(disambiguation), n).toUtf8(); QtGui_PackedString { const_cast<char*>(tacd619.prepend("WHITESPACE").constData()+10), tacd619.size()-10 }; });
}
struct QtGui_PackedString QImageWriter_QImageWriter_TrUtf8(char* sourceText, char* disambiguation, int n)
{
return ({ QByteArray t55d8ed = QImageWriter::trUtf8(const_cast<const char*>(sourceText), const_cast<const char*>(disambiguation), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t55d8ed.prepend("WHITESPACE").constData()+10), t55d8ed.size()-10 }; });
}
char QImageWriter_Write(void* ptr, void* image)
{
return static_cast<QImageWriter*>(ptr)->write(*static_cast<QImage*>(image));
}
void QImageWriter_SetCompression(void* ptr, int compression)
{
static_cast<QImageWriter*>(ptr)->setCompression(compression);
}
void QImageWriter_SetDevice(void* ptr, void* device)
{
static_cast<QImageWriter*>(ptr)->setDevice(static_cast<QIODevice*>(device));
}
void QImageWriter_SetFileName(void* ptr, struct QtGui_PackedString fileName)
{
static_cast<QImageWriter*>(ptr)->setFileName(QString::fromUtf8(fileName.data, fileName.len));
}
void QImageWriter_SetFormat(void* ptr, void* format)
{
static_cast<QImageWriter*>(ptr)->setFormat(*static_cast<QByteArray*>(format));
}
void QImageWriter_SetGamma(void* ptr, float gamma)
{
static_cast<QImageWriter*>(ptr)->setGamma(gamma);
}
void QImageWriter_SetOptimizedWrite(void* ptr, char optimize)
{
static_cast<QImageWriter*>(ptr)->setOptimizedWrite(optimize != 0);
}
void QImageWriter_SetProgressiveScanWrite(void* ptr, char progressive)
{
static_cast<QImageWriter*>(ptr)->setProgressiveScanWrite(progressive != 0);
}
void QImageWriter_SetQuality(void* ptr, int quality)
{
static_cast<QImageWriter*>(ptr)->setQuality(quality);
}
void QImageWriter_SetSubType(void* ptr, void* ty)
{
static_cast<QImageWriter*>(ptr)->setSubType(*static_cast<QByteArray*>(ty));
}
void QImageWriter_SetText(void* ptr, struct QtGui_PackedString key, struct QtGui_PackedString text)
{
static_cast<QImageWriter*>(ptr)->setText(QString::fromUtf8(key.data, key.len), QString::fromUtf8(text.data, text.len));
}
void QImageWriter_SetTransformation(void* ptr, long long transform)
{
static_cast<QImageWriter*>(ptr)->setTransformation(static_cast<QImageIOHandler::Transformation>(transform));
}
void QImageWriter_DestroyQImageWriter(void* ptr)
{
static_cast<QImageWriter*>(ptr)->~QImageWriter();
}
void* QImageWriter_Format(void* ptr)
{
return new QByteArray(static_cast<QImageWriter*>(ptr)->format());
}
void* QImageWriter_SubType(void* ptr)
{
return new QByteArray(static_cast<QImageWriter*>(ptr)->subType());
}
void* QImageWriter_Device(void* ptr)
{
return static_cast<QImageWriter*>(ptr)->device();
}
long long QImageWriter_Transformation(void* ptr)
{
return static_cast<QImageWriter*>(ptr)->transformation();
}
long long QImageWriter_Error(void* ptr)
{
return static_cast<QImageWriter*>(ptr)->error();
}
struct QtGui_PackedList QImageWriter_SupportedSubTypes(void* ptr)
{
return ({ QList<QByteArray>* tmpValue = new QList<QByteArray>(static_cast<QImageWriter*>(ptr)->supportedSubTypes()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedString QImageWriter_ErrorString(void* ptr)
{
return ({ QByteArray t4f91d9 = static_cast<QImageWriter*>(ptr)->errorString().toUtf8(); QtGui_PackedString { const_cast<char*>(t4f91d9.prepend("WHITESPACE").constData()+10), t4f91d9.size()-10 }; });
}
struct QtGui_PackedString QImageWriter_FileName(void* ptr)
{
return ({ QByteArray tb587a3 = static_cast<QImageWriter*>(ptr)->fileName().toUtf8(); QtGui_PackedString { const_cast<char*>(tb587a3.prepend("WHITESPACE").constData()+10), tb587a3.size()-10 }; });
}
char QImageWriter_CanWrite(void* ptr)
{
return static_cast<QImageWriter*>(ptr)->canWrite();
}
char QImageWriter_OptimizedWrite(void* ptr)
{
return static_cast<QImageWriter*>(ptr)->optimizedWrite();
}
char QImageWriter_ProgressiveScanWrite(void* ptr)
{
return static_cast<QImageWriter*>(ptr)->progressiveScanWrite();
}
char QImageWriter_SupportsOption(void* ptr, long long option)
{
return static_cast<QImageWriter*>(ptr)->supportsOption(static_cast<QImageIOHandler::ImageOption>(option));
}
float QImageWriter_Gamma(void* ptr)
{
return static_cast<QImageWriter*>(ptr)->gamma();
}
int QImageWriter_Compression(void* ptr)
{
return static_cast<QImageWriter*>(ptr)->compression();
}
int QImageWriter_Quality(void* ptr)
{
return static_cast<QImageWriter*>(ptr)->quality();
}
void* QImageWriter___supportedImageFormats_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QImageWriter___supportedImageFormats_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QImageWriter___supportedImageFormats_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QImageWriter___supportedMimeTypes_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QImageWriter___supportedMimeTypes_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QImageWriter___supportedMimeTypes_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QImageWriter___supportedSubTypes_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QImageWriter___supportedSubTypes_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QImageWriter___supportedSubTypes_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
class MyQInputEvent: public QInputEvent
{
public:
};
long long QInputEvent_Modifiers(void* ptr)
{
return static_cast<QInputEvent*>(ptr)->modifiers();
}
unsigned long QInputEvent_Timestamp(void* ptr)
{
return static_cast<QInputEvent*>(ptr)->timestamp();
}
long long QInputEvent_ModState(void* ptr)
{
return static_cast<QInputEvent*>(ptr)->modState;
}
void QInputEvent_SetModState(void* ptr, long long vqt)
{
static_cast<QInputEvent*>(ptr)->modState = static_cast<Qt::KeyboardModifier>(vqt);
}
unsigned long QInputEvent_Ts(void* ptr)
{
return static_cast<QInputEvent*>(ptr)->ts;
}
void QInputEvent_SetTs(void* ptr, unsigned long vul)
{
static_cast<QInputEvent*>(ptr)->ts = vul;
}
class MyQInputMethod: public QInputMethod
{
public:
void Signal_AnchorRectangleChanged() { callbackQInputMethod_AnchorRectangleChanged(this); };
void Signal_AnimatingChanged() { callbackQInputMethod_AnimatingChanged(this); };
void commit() { callbackQInputMethod_Commit(this); };
void Signal_CursorRectangleChanged() { callbackQInputMethod_CursorRectangleChanged(this); };
void hide() { callbackQInputMethod_Hide(this); };
void Signal_InputDirectionChanged(Qt::LayoutDirection newDirection) { callbackQInputMethod_InputDirectionChanged(this, newDirection); };
void Signal_InputItemClipRectangleChanged() { callbackQInputMethod_InputItemClipRectangleChanged(this); };
void invokeAction(QInputMethod::Action a, int cursorPosition) { callbackQInputMethod_InvokeAction(this, a, cursorPosition); };
void Signal_KeyboardRectangleChanged() { callbackQInputMethod_KeyboardRectangleChanged(this); };
void Signal_LocaleChanged() { callbackQInputMethod_LocaleChanged(this); };
void reset() { callbackQInputMethod_Reset(this); };
void show() { callbackQInputMethod_Show(this); };
void update(Qt::InputMethodQueries queries) { callbackQInputMethod_Update(this, queries); };
void Signal_VisibleChanged() { callbackQInputMethod_VisibleChanged(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQInputMethod_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQInputMethod_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQInputMethod_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQInputMethod_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQInputMethod_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQInputMethod_CustomEvent(this, event); };
void deleteLater() { callbackQInputMethod_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQInputMethod_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQInputMethod_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQInputMethod_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQInputMethod_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQInputMethod*)
int QInputMethod_QInputMethod_QRegisterMetaType(){qRegisterMetaType<QInputMethod*>(); return qRegisterMetaType<MyQInputMethod*>();}
struct QtGui_PackedString QInputMethod_QInputMethod_Tr(char* s, char* c, int n)
{
return ({ QByteArray t9feb78 = QInputMethod::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t9feb78.prepend("WHITESPACE").constData()+10), t9feb78.size()-10 }; });
}
struct QtGui_PackedString QInputMethod_QInputMethod_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray t7ab78b = QInputMethod::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t7ab78b.prepend("WHITESPACE").constData()+10), t7ab78b.size()-10 }; });
}
void* QInputMethod_QInputMethod_QueryFocusObject(long long query, void* argument)
{
return new QVariant(QInputMethod::queryFocusObject(static_cast<Qt::InputMethodQuery>(query), *static_cast<QVariant*>(argument)));
}
void QInputMethod_ConnectAnchorRectangleChanged(void* ptr)
{
QObject::connect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::anchorRectangleChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_AnchorRectangleChanged));
}
void QInputMethod_DisconnectAnchorRectangleChanged(void* ptr)
{
QObject::disconnect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::anchorRectangleChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_AnchorRectangleChanged));
}
void QInputMethod_AnchorRectangleChanged(void* ptr)
{
static_cast<QInputMethod*>(ptr)->anchorRectangleChanged();
}
void QInputMethod_ConnectAnimatingChanged(void* ptr)
{
QObject::connect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::animatingChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_AnimatingChanged));
}
void QInputMethod_DisconnectAnimatingChanged(void* ptr)
{
QObject::disconnect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::animatingChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_AnimatingChanged));
}
void QInputMethod_AnimatingChanged(void* ptr)
{
static_cast<QInputMethod*>(ptr)->animatingChanged();
}
void QInputMethod_Commit(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QInputMethod*>(ptr), "commit");
}
void QInputMethod_CommitDefault(void* ptr)
{
static_cast<QInputMethod*>(ptr)->QInputMethod::commit();
}
void QInputMethod_ConnectCursorRectangleChanged(void* ptr)
{
QObject::connect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::cursorRectangleChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_CursorRectangleChanged));
}
void QInputMethod_DisconnectCursorRectangleChanged(void* ptr)
{
QObject::disconnect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::cursorRectangleChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_CursorRectangleChanged));
}
void QInputMethod_CursorRectangleChanged(void* ptr)
{
static_cast<QInputMethod*>(ptr)->cursorRectangleChanged();
}
void QInputMethod_Hide(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QInputMethod*>(ptr), "hide");
}
void QInputMethod_HideDefault(void* ptr)
{
static_cast<QInputMethod*>(ptr)->QInputMethod::hide();
}
void QInputMethod_ConnectInputDirectionChanged(void* ptr)
{
qRegisterMetaType<Qt::LayoutDirection>();
QObject::connect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)(Qt::LayoutDirection)>(&QInputMethod::inputDirectionChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)(Qt::LayoutDirection)>(&MyQInputMethod::Signal_InputDirectionChanged));
}
void QInputMethod_DisconnectInputDirectionChanged(void* ptr)
{
QObject::disconnect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)(Qt::LayoutDirection)>(&QInputMethod::inputDirectionChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)(Qt::LayoutDirection)>(&MyQInputMethod::Signal_InputDirectionChanged));
}
void QInputMethod_InputDirectionChanged(void* ptr, long long newDirection)
{
static_cast<QInputMethod*>(ptr)->inputDirectionChanged(static_cast<Qt::LayoutDirection>(newDirection));
}
void QInputMethod_ConnectInputItemClipRectangleChanged(void* ptr)
{
QObject::connect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::inputItemClipRectangleChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_InputItemClipRectangleChanged));
}
void QInputMethod_DisconnectInputItemClipRectangleChanged(void* ptr)
{
QObject::disconnect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::inputItemClipRectangleChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_InputItemClipRectangleChanged));
}
void QInputMethod_InputItemClipRectangleChanged(void* ptr)
{
static_cast<QInputMethod*>(ptr)->inputItemClipRectangleChanged();
}
void QInputMethod_InvokeAction(void* ptr, long long a, int cursorPosition)
{
qRegisterMetaType<QInputMethod::Action>();
QMetaObject::invokeMethod(static_cast<QInputMethod*>(ptr), "invokeAction", Q_ARG(QInputMethod::Action, static_cast<QInputMethod::Action>(a)), Q_ARG(int, cursorPosition));
}
void QInputMethod_InvokeActionDefault(void* ptr, long long a, int cursorPosition)
{
static_cast<QInputMethod*>(ptr)->QInputMethod::invokeAction(static_cast<QInputMethod::Action>(a), cursorPosition);
}
void QInputMethod_ConnectKeyboardRectangleChanged(void* ptr)
{
QObject::connect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::keyboardRectangleChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_KeyboardRectangleChanged));
}
void QInputMethod_DisconnectKeyboardRectangleChanged(void* ptr)
{
QObject::disconnect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::keyboardRectangleChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_KeyboardRectangleChanged));
}
void QInputMethod_KeyboardRectangleChanged(void* ptr)
{
static_cast<QInputMethod*>(ptr)->keyboardRectangleChanged();
}
void QInputMethod_ConnectLocaleChanged(void* ptr)
{
QObject::connect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::localeChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_LocaleChanged));
}
void QInputMethod_DisconnectLocaleChanged(void* ptr)
{
QObject::disconnect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::localeChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_LocaleChanged));
}
void QInputMethod_LocaleChanged(void* ptr)
{
static_cast<QInputMethod*>(ptr)->localeChanged();
}
void QInputMethod_Reset(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QInputMethod*>(ptr), "reset");
}
void QInputMethod_ResetDefault(void* ptr)
{
static_cast<QInputMethod*>(ptr)->QInputMethod::reset();
}
void QInputMethod_SetInputItemRectangle(void* ptr, void* rect)
{
static_cast<QInputMethod*>(ptr)->setInputItemRectangle(*static_cast<QRectF*>(rect));
}
void QInputMethod_SetInputItemTransform(void* ptr, void* transform)
{
static_cast<QInputMethod*>(ptr)->setInputItemTransform(*static_cast<QTransform*>(transform));
}
void QInputMethod_SetVisible(void* ptr, char visible)
{
static_cast<QInputMethod*>(ptr)->setVisible(visible != 0);
}
void QInputMethod_Show(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QInputMethod*>(ptr), "show");
}
void QInputMethod_ShowDefault(void* ptr)
{
static_cast<QInputMethod*>(ptr)->QInputMethod::show();
}
void QInputMethod_Update(void* ptr, long long queries)
{
qRegisterMetaType<Qt::InputMethodQueries>();
QMetaObject::invokeMethod(static_cast<QInputMethod*>(ptr), "update", Q_ARG(Qt::InputMethodQueries, static_cast<Qt::InputMethodQuery>(queries)));
}
void QInputMethod_UpdateDefault(void* ptr, long long queries)
{
static_cast<QInputMethod*>(ptr)->QInputMethod::update(static_cast<Qt::InputMethodQuery>(queries));
}
void QInputMethod_ConnectVisibleChanged(void* ptr)
{
QObject::connect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::visibleChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_VisibleChanged));
}
void QInputMethod_DisconnectVisibleChanged(void* ptr)
{
QObject::disconnect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::visibleChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_VisibleChanged));
}
void QInputMethod_VisibleChanged(void* ptr)
{
static_cast<QInputMethod*>(ptr)->visibleChanged();
}
void* QInputMethod_Locale(void* ptr)
{
return new QLocale(static_cast<QInputMethod*>(ptr)->locale());
}
void* QInputMethod_AnchorRectangle(void* ptr)
{
return ({ QRectF tmpValue = static_cast<QInputMethod*>(ptr)->anchorRectangle(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QInputMethod_CursorRectangle(void* ptr)
{
return ({ QRectF tmpValue = static_cast<QInputMethod*>(ptr)->cursorRectangle(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QInputMethod_InputItemClipRectangle(void* ptr)
{
return ({ QRectF tmpValue = static_cast<QInputMethod*>(ptr)->inputItemClipRectangle(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QInputMethod_InputItemRectangle(void* ptr)
{
return ({ QRectF tmpValue = static_cast<QInputMethod*>(ptr)->inputItemRectangle(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QInputMethod_KeyboardRectangle(void* ptr)
{
return ({ QRectF tmpValue = static_cast<QInputMethod*>(ptr)->keyboardRectangle(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QInputMethod_InputItemTransform(void* ptr)
{
return new QTransform(static_cast<QInputMethod*>(ptr)->inputItemTransform());
}
long long QInputMethod_InputDirection(void* ptr)
{
return static_cast<QInputMethod*>(ptr)->inputDirection();
}
char QInputMethod_IsAnimating(void* ptr)
{
return static_cast<QInputMethod*>(ptr)->isAnimating();
}
char QInputMethod_IsVisible(void* ptr)
{
return static_cast<QInputMethod*>(ptr)->isVisible();
}
void* QInputMethod_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QInputMethod*>(ptr)->QInputMethod::metaObject());
}
void* QInputMethod___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QInputMethod___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QInputMethod___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QInputMethod___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QInputMethod___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QInputMethod___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QInputMethod___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QInputMethod___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QInputMethod___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QInputMethod___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QInputMethod___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QInputMethod___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QInputMethod___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QInputMethod___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QInputMethod___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QInputMethod_EventDefault(void* ptr, void* e)
{
return static_cast<QInputMethod*>(ptr)->QInputMethod::event(static_cast<QEvent*>(e));
}
char QInputMethod_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QInputMethod*>(ptr)->QInputMethod::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QInputMethod*>(ptr)->QInputMethod::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QInputMethod*>(ptr)->QInputMethod::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QInputMethod*>(ptr)->QInputMethod::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QInputMethod*>(ptr)->QInputMethod::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QInputMethod_ChildEventDefault(void* ptr, void* event)
{
static_cast<QInputMethod*>(ptr)->QInputMethod::childEvent(static_cast<QChildEvent*>(event));
}
void QInputMethod_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QInputMethod*>(ptr)->QInputMethod::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QInputMethod_CustomEventDefault(void* ptr, void* event)
{
static_cast<QInputMethod*>(ptr)->QInputMethod::customEvent(static_cast<QEvent*>(event));
}
void QInputMethod_DeleteLaterDefault(void* ptr)
{
static_cast<QInputMethod*>(ptr)->QInputMethod::deleteLater();
}
void QInputMethod_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QInputMethod*>(ptr)->QInputMethod::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QInputMethod_TimerEventDefault(void* ptr, void* event)
{
static_cast<QInputMethod*>(ptr)->QInputMethod::timerEvent(static_cast<QTimerEvent*>(event));
}
class MyQInputMethodEvent: public QInputMethodEvent
{
public:
MyQInputMethodEvent() : QInputMethodEvent() {};
MyQInputMethodEvent(const QInputMethodEvent &other) : QInputMethodEvent(other) {};
~MyQInputMethodEvent() { callbackQInputMethodEvent_DestroyQInputMethodEvent(this); };
};
void* QInputMethodEvent_NewQInputMethodEvent()
{
return new MyQInputMethodEvent();
}
void* QInputMethodEvent_NewQInputMethodEvent3(void* other)
{
return new MyQInputMethodEvent(*static_cast<QInputMethodEvent*>(other));
}
void QInputMethodEvent_SetCommitString(void* ptr, struct QtGui_PackedString commitString, int replaceFrom, int replaceLength)
{
static_cast<QInputMethodEvent*>(ptr)->setCommitString(QString::fromUtf8(commitString.data, commitString.len), replaceFrom, replaceLength);
}
void QInputMethodEvent_DestroyQInputMethodEvent(void* ptr)
{
static_cast<QInputMethodEvent*>(ptr)->~QInputMethodEvent();
}
void QInputMethodEvent_DestroyQInputMethodEventDefault(void* ptr)
{
Q_UNUSED(ptr);
}
struct QtGui_PackedString QInputMethodEvent_CommitString(void* ptr)
{
return ({ QByteArray t69832e = static_cast<QInputMethodEvent*>(ptr)->commitString().toUtf8(); QtGui_PackedString { const_cast<char*>(t69832e.prepend("WHITESPACE").constData()+10), t69832e.size()-10 }; });
}
struct QtGui_PackedString QInputMethodEvent_PreeditString(void* ptr)
{
return ({ QByteArray t9860e5 = static_cast<QInputMethodEvent*>(ptr)->preeditString().toUtf8(); QtGui_PackedString { const_cast<char*>(t9860e5.prepend("WHITESPACE").constData()+10), t9860e5.size()-10 }; });
}
int QInputMethodEvent_ReplacementLength(void* ptr)
{
return static_cast<QInputMethodEvent*>(ptr)->replacementLength();
}
int QInputMethodEvent_ReplacementStart(void* ptr)
{
return static_cast<QInputMethodEvent*>(ptr)->replacementStart();
}
void* QInputMethodEvent___attrs_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QInputMethodEvent::Attribute>();
}
void* QInputMethodEvent___setAttrs__newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QInputMethodEvent::Attribute>();
}
class MyQInputMethodQueryEvent: public QInputMethodQueryEvent
{
public:
MyQInputMethodQueryEvent(Qt::InputMethodQueries queries) : QInputMethodQueryEvent(queries) {};
};
void* QInputMethodQueryEvent_NewQInputMethodQueryEvent(long long queries)
{
return new MyQInputMethodQueryEvent(static_cast<Qt::InputMethodQuery>(queries));
}
void QInputMethodQueryEvent_SetValue(void* ptr, long long query, void* value)
{
static_cast<QInputMethodQueryEvent*>(ptr)->setValue(static_cast<Qt::InputMethodQuery>(query), *static_cast<QVariant*>(value));
}
void* QInputMethodQueryEvent_Value(void* ptr, long long query)
{
return new QVariant(static_cast<QInputMethodQueryEvent*>(ptr)->value(static_cast<Qt::InputMethodQuery>(query)));
}
long long QInputMethodQueryEvent_Queries(void* ptr)
{
return static_cast<QInputMethodQueryEvent*>(ptr)->queries();
}
void* QInputMethodQueryEvent___m_values_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QInputMethodQueryEvent::QueryPair>();
}
void* QInputMethodQueryEvent___setM_values__newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QInputMethodQueryEvent::QueryPair>();
}
class MyQIntValidator: public QIntValidator
{
public:
MyQIntValidator(QObject *parent = Q_NULLPTR) : QIntValidator(parent) {QIntValidator_QIntValidator_QRegisterMetaType();};
MyQIntValidator(int minimum, int maximum, QObject *parent = Q_NULLPTR) : QIntValidator(minimum, maximum, parent) {QIntValidator_QIntValidator_QRegisterMetaType();};
void setRange(int bottom, int top) { callbackQIntValidator_SetRange(this, bottom, top); };
~MyQIntValidator() { callbackQIntValidator_DestroyQIntValidator(this); };
QValidator::State validate(QString & input, int & pos) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };return static_cast<QValidator::State>(callbackQIntValidator_Validate(const_cast<void*>(static_cast<const void*>(this)), inputPacked, pos)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQValidator_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void fixup(QString & input) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };callbackQValidator_Fixup(const_cast<void*>(static_cast<const void*>(this)), inputPacked); };
void Signal_Changed() { callbackQValidator_Changed(this); };
bool event(QEvent * e) { return callbackQValidator_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQValidator_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQValidator_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQValidator_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQValidator_CustomEvent(this, event); };
void deleteLater() { callbackQValidator_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQValidator_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQValidator_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQValidator_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQValidator_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQIntValidator*)
int QIntValidator_QIntValidator_QRegisterMetaType(){qRegisterMetaType<QIntValidator*>(); return qRegisterMetaType<MyQIntValidator*>();}
void* QIntValidator_NewQIntValidator(void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(static_cast<QWindow*>(parent));
} else {
return new MyQIntValidator(static_cast<QObject*>(parent));
}
}
void* QIntValidator_NewQIntValidator2(int minimum, int maximum, void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(minimum, maximum, static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(minimum, maximum, static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(minimum, maximum, static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(minimum, maximum, static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(minimum, maximum, static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(minimum, maximum, static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(minimum, maximum, static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(minimum, maximum, static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(minimum, maximum, static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(minimum, maximum, static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(minimum, maximum, static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(minimum, maximum, static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(minimum, maximum, static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(minimum, maximum, static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(minimum, maximum, static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQIntValidator(minimum, maximum, static_cast<QWindow*>(parent));
} else {
return new MyQIntValidator(minimum, maximum, static_cast<QObject*>(parent));
}
}
void QIntValidator_SetBottom(void* ptr, int vin)
{
static_cast<QIntValidator*>(ptr)->setBottom(vin);
}
void QIntValidator_SetRange(void* ptr, int bottom, int top)
{
static_cast<QIntValidator*>(ptr)->setRange(bottom, top);
}
void QIntValidator_SetRangeDefault(void* ptr, int bottom, int top)
{
static_cast<QIntValidator*>(ptr)->QIntValidator::setRange(bottom, top);
}
void QIntValidator_SetTop(void* ptr, int vin)
{
static_cast<QIntValidator*>(ptr)->setTop(vin);
}
void QIntValidator_DestroyQIntValidator(void* ptr)
{
static_cast<QIntValidator*>(ptr)->~QIntValidator();
}
void QIntValidator_DestroyQIntValidatorDefault(void* ptr)
{
Q_UNUSED(ptr);
}
long long QIntValidator_Validate(void* ptr, struct QtGui_PackedString input, int pos)
{
return static_cast<QIntValidator*>(ptr)->validate(*(new QString(QString::fromUtf8(input.data, input.len))), pos);
}
long long QIntValidator_ValidateDefault(void* ptr, struct QtGui_PackedString input, int pos)
{
return static_cast<QIntValidator*>(ptr)->QIntValidator::validate(*(new QString(QString::fromUtf8(input.data, input.len))), pos);
}
int QIntValidator_Bottom(void* ptr)
{
return static_cast<QIntValidator*>(ptr)->bottom();
}
int QIntValidator_Top(void* ptr)
{
return static_cast<QIntValidator*>(ptr)->top();
}
class MyQKeyEvent: public QKeyEvent
{
public:
MyQKeyEvent(QEvent::Type ty, int key, Qt::KeyboardModifiers modifiers, const QString &text = QString(), bool autorep = false, ushort count = 1) : QKeyEvent(ty, key, modifiers, text, autorep, count) {};
MyQKeyEvent(QEvent::Type ty, int key, Qt::KeyboardModifiers modifiers, quint32 nativeScanCode, quint32 nativeVirtualKey, quint32 nativeModifiers, const QString &text = QString(), bool autorep = false, ushort count = 1) : QKeyEvent(ty, key, modifiers, nativeScanCode, nativeVirtualKey, nativeModifiers, text, autorep, count) {};
};
void* QKeyEvent_NewQKeyEvent(long long ty, int key, long long modifiers, struct QtGui_PackedString text, char autorep, unsigned short count)
{
return new MyQKeyEvent(static_cast<QEvent::Type>(ty), key, static_cast<Qt::KeyboardModifier>(modifiers), QString::fromUtf8(text.data, text.len), autorep != 0, count);
}
void* QKeyEvent_NewQKeyEvent2(long long ty, int key, long long modifiers, unsigned int nativeScanCode, unsigned int nativeVirtualKey, unsigned int nativeModifiers, struct QtGui_PackedString text, char autorep, unsigned short count)
{
return new MyQKeyEvent(static_cast<QEvent::Type>(ty), key, static_cast<Qt::KeyboardModifier>(modifiers), nativeScanCode, nativeVirtualKey, nativeModifiers, QString::fromUtf8(text.data, text.len), autorep != 0, count);
}
struct QtGui_PackedString QKeyEvent_Text(void* ptr)
{
return ({ QByteArray tac962f = static_cast<QKeyEvent*>(ptr)->text().toUtf8(); QtGui_PackedString { const_cast<char*>(tac962f.prepend("WHITESPACE").constData()+10), tac962f.size()-10 }; });
}
char QKeyEvent_IsAutoRepeat(void* ptr)
{
return static_cast<QKeyEvent*>(ptr)->isAutoRepeat();
}
char QKeyEvent_Matches(void* ptr, long long key)
{
return static_cast<QKeyEvent*>(ptr)->matches(static_cast<QKeySequence::StandardKey>(key));
}
int QKeyEvent_Count(void* ptr)
{
return static_cast<QKeyEvent*>(ptr)->count();
}
int QKeyEvent_Key(void* ptr)
{
return static_cast<QKeyEvent*>(ptr)->key();
}
unsigned int QKeyEvent_NativeModifiers(void* ptr)
{
return static_cast<QKeyEvent*>(ptr)->nativeModifiers();
}
unsigned int QKeyEvent_NativeScanCode(void* ptr)
{
return static_cast<QKeyEvent*>(ptr)->nativeScanCode();
}
unsigned int QKeyEvent_NativeVirtualKey(void* ptr)
{
return static_cast<QKeyEvent*>(ptr)->nativeVirtualKey();
}
unsigned short QKeyEvent_Autor(void* ptr)
{
return static_cast<QKeyEvent*>(ptr)->autor;
}
void QKeyEvent_SetAutor(void* ptr, unsigned short vus)
{
static_cast<QKeyEvent*>(ptr)->autor = vus;
}
unsigned short QKeyEvent_C(void* ptr)
{
return static_cast<QKeyEvent*>(ptr)->c;
}
void QKeyEvent_SetC(void* ptr, unsigned short vus)
{
static_cast<QKeyEvent*>(ptr)->c = vus;
}
int QKeyEvent_K(void* ptr)
{
return static_cast<QKeyEvent*>(ptr)->k;
}
void QKeyEvent_SetK(void* ptr, int vin)
{
static_cast<QKeyEvent*>(ptr)->k = vin;
}
unsigned int QKeyEvent_NModifiers(void* ptr)
{
return static_cast<QKeyEvent*>(ptr)->nModifiers;
}
void QKeyEvent_SetNModifiers(void* ptr, unsigned int vqu)
{
static_cast<QKeyEvent*>(ptr)->nModifiers = vqu;
}
unsigned int QKeyEvent_NScanCode(void* ptr)
{
return static_cast<QKeyEvent*>(ptr)->nScanCode;
}
void QKeyEvent_SetNScanCode(void* ptr, unsigned int vqu)
{
static_cast<QKeyEvent*>(ptr)->nScanCode = vqu;
}
unsigned int QKeyEvent_NVirtualKey(void* ptr)
{
return static_cast<QKeyEvent*>(ptr)->nVirtualKey;
}
void QKeyEvent_SetNVirtualKey(void* ptr, unsigned int vqu)
{
static_cast<QKeyEvent*>(ptr)->nVirtualKey = vqu;
}
struct QtGui_PackedString QKeyEvent_Txt(void* ptr)
{
return ({ QByteArray t9192bb = static_cast<QKeyEvent*>(ptr)->txt.toUtf8(); QtGui_PackedString { const_cast<char*>(t9192bb.prepend("WHITESPACE").constData()+10), t9192bb.size()-10 }; });
}
void QKeyEvent_SetTxt(void* ptr, struct QtGui_PackedString vqs)
{
static_cast<QKeyEvent*>(ptr)->txt = QString::fromUtf8(vqs.data, vqs.len);
}
void* QKeySequence_QKeySequence_FromString(struct QtGui_PackedString str, long long format)
{
return new QKeySequence(QKeySequence::fromString(QString::fromUtf8(str.data, str.len), static_cast<QKeySequence::SequenceFormat>(format)));
}
void* QKeySequence_QKeySequence_Mnemonic(struct QtGui_PackedString text)
{
return new QKeySequence(QKeySequence::mnemonic(QString::fromUtf8(text.data, text.len)));
}
void* QKeySequence_NewQKeySequence()
{
return new QKeySequence();
}
void* QKeySequence_NewQKeySequence5(long long key)
{
return new QKeySequence(static_cast<QKeySequence::StandardKey>(key));
}
void* QKeySequence_NewQKeySequence4(void* keysequence)
{
return new QKeySequence(*static_cast<QKeySequence*>(keysequence));
}
void* QKeySequence_NewQKeySequence2(struct QtGui_PackedString key, long long format)
{
return new QKeySequence(QString::fromUtf8(key.data, key.len), static_cast<QKeySequence::SequenceFormat>(format));
}
void* QKeySequence_NewQKeySequence3(int k1, int k2, int k3, int k4)
{
return new QKeySequence(k1, k2, k3, k4);
}
struct QtGui_PackedList QKeySequence_QKeySequence_KeyBindings(long long key)
{
return ({ QList<QKeySequence>* tmpValue = new QList<QKeySequence>(QKeySequence::keyBindings(static_cast<QKeySequence::StandardKey>(key))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedList QKeySequence_QKeySequence_ListFromString(struct QtGui_PackedString str, long long format)
{
return ({ QList<QKeySequence>* tmpValue = new QList<QKeySequence>(QKeySequence::listFromString(QString::fromUtf8(str.data, str.len), static_cast<QKeySequence::SequenceFormat>(format))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedString QKeySequence_QKeySequence_ListToString(void* list, long long format)
{
return ({ QByteArray tdd68e7 = QKeySequence::listToString(*static_cast<QList<QKeySequence>*>(list), static_cast<QKeySequence::SequenceFormat>(format)).toUtf8(); QtGui_PackedString { const_cast<char*>(tdd68e7.prepend("WHITESPACE").constData()+10), tdd68e7.size()-10 }; });
}
void QKeySequence_Swap(void* ptr, void* other)
{
static_cast<QKeySequence*>(ptr)->swap(*static_cast<QKeySequence*>(other));
}
void QKeySequence_DestroyQKeySequence(void* ptr)
{
static_cast<QKeySequence*>(ptr)->~QKeySequence();
}
long long QKeySequence_Matches(void* ptr, void* seq)
{
return static_cast<QKeySequence*>(ptr)->matches(*static_cast<QKeySequence*>(seq));
}
struct QtGui_PackedString QKeySequence_ToString(void* ptr, long long format)
{
return ({ QByteArray t3bf8a8 = static_cast<QKeySequence*>(ptr)->toString(static_cast<QKeySequence::SequenceFormat>(format)).toUtf8(); QtGui_PackedString { const_cast<char*>(t3bf8a8.prepend("WHITESPACE").constData()+10), t3bf8a8.size()-10 }; });
}
char QKeySequence_IsEmpty(void* ptr)
{
return static_cast<QKeySequence*>(ptr)->isEmpty();
}
int QKeySequence_Count(void* ptr)
{
return static_cast<QKeySequence*>(ptr)->count();
}
void* QKeySequence___keyBindings_atList(void* ptr, int i)
{
return new QKeySequence(({QKeySequence tmp = static_cast<QList<QKeySequence>*>(ptr)->at(i); if (i == static_cast<QList<QKeySequence>*>(ptr)->size()-1) { static_cast<QList<QKeySequence>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QKeySequence___keyBindings_setList(void* ptr, void* i)
{
static_cast<QList<QKeySequence>*>(ptr)->append(*static_cast<QKeySequence*>(i));
}
void* QKeySequence___keyBindings_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QKeySequence>();
}
void* QKeySequence___listFromString_atList(void* ptr, int i)
{
return new QKeySequence(({QKeySequence tmp = static_cast<QList<QKeySequence>*>(ptr)->at(i); if (i == static_cast<QList<QKeySequence>*>(ptr)->size()-1) { static_cast<QList<QKeySequence>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QKeySequence___listFromString_setList(void* ptr, void* i)
{
static_cast<QList<QKeySequence>*>(ptr)->append(*static_cast<QKeySequence*>(i));
}
void* QKeySequence___listFromString_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QKeySequence>();
}
void* QKeySequence___listToString_list_atList(void* ptr, int i)
{
return new QKeySequence(({QKeySequence tmp = static_cast<QList<QKeySequence>*>(ptr)->at(i); if (i == static_cast<QList<QKeySequence>*>(ptr)->size()-1) { static_cast<QList<QKeySequence>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QKeySequence___listToString_list_setList(void* ptr, void* i)
{
static_cast<QList<QKeySequence>*>(ptr)->append(*static_cast<QKeySequence*>(i));
}
void* QKeySequence___listToString_list_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QKeySequence>();
}
void* QLinearGradient_NewQLinearGradient()
{
return new QLinearGradient();
}
void* QLinearGradient_NewQLinearGradient2(void* start, void* finalStop)
{
return new QLinearGradient(*static_cast<QPointF*>(start), *static_cast<QPointF*>(finalStop));
}
void* QLinearGradient_NewQLinearGradient3(double x1, double y1, double x2, double y2)
{
return new QLinearGradient(x1, y1, x2, y2);
}
void QLinearGradient_SetFinalStop(void* ptr, void* stop)
{
static_cast<QLinearGradient*>(ptr)->setFinalStop(*static_cast<QPointF*>(stop));
}
void QLinearGradient_SetFinalStop2(void* ptr, double x, double y)
{
static_cast<QLinearGradient*>(ptr)->setFinalStop(x, y);
}
void QLinearGradient_SetStart(void* ptr, void* start)
{
static_cast<QLinearGradient*>(ptr)->setStart(*static_cast<QPointF*>(start));
}
void QLinearGradient_SetStart2(void* ptr, double x, double y)
{
static_cast<QLinearGradient*>(ptr)->setStart(x, y);
}
void* QLinearGradient_FinalStop(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QLinearGradient*>(ptr)->finalStop(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void* QLinearGradient_Start(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QLinearGradient*>(ptr)->start(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void* QMatrix_Rotate(void* ptr, double degrees)
{
return new QMatrix(static_cast<QMatrix*>(ptr)->rotate(degrees));
}
void* QMatrix_Scale(void* ptr, double sx, double sy)
{
return new QMatrix(static_cast<QMatrix*>(ptr)->scale(sx, sy));
}
void* QMatrix_Shear(void* ptr, double sh, double sv)
{
return new QMatrix(static_cast<QMatrix*>(ptr)->shear(sh, sv));
}
void* QMatrix_Translate(void* ptr, double dx, double dy)
{
return new QMatrix(static_cast<QMatrix*>(ptr)->translate(dx, dy));
}
void* QMatrix_NewQMatrix()
{
return new QMatrix();
}
void* QMatrix_NewQMatrix4(void* other)
{
return new QMatrix(*static_cast<QMatrix*>(other));
}
void* QMatrix_NewQMatrix5(void* matrix)
{
return new QMatrix(*static_cast<QMatrix*>(matrix));
}
void* QMatrix_NewQMatrix3(double m11, double m12, double m21, double m22, double dx, double dy)
{
return new QMatrix(m11, m12, m21, m22, dx, dy);
}
void QMatrix_Reset(void* ptr)
{
static_cast<QMatrix*>(ptr)->reset();
}
void QMatrix_SetMatrix(void* ptr, double m11, double m12, double m21, double m22, double dx, double dy)
{
static_cast<QMatrix*>(ptr)->setMatrix(m11, m12, m21, m22, dx, dy);
}
void* QMatrix_Map5(void* ptr, void* line)
{
return ({ QLine tmpValue = static_cast<QMatrix*>(ptr)->map(*static_cast<QLine*>(line)); new QLine(tmpValue.p1(), tmpValue.p2()); });
}
void* QMatrix_Map6(void* ptr, void* line)
{
return ({ QLineF tmpValue = static_cast<QMatrix*>(ptr)->map(*static_cast<QLineF*>(line)); new QLineF(tmpValue.p1(), tmpValue.p2()); });
}
void* QMatrix_Inverted(void* ptr, char invertible)
{
Q_UNUSED(invertible);
return new QMatrix(static_cast<QMatrix*>(ptr)->inverted(NULL));
}
void* QMatrix_Map10(void* ptr, void* path)
{
return new QPainterPath(static_cast<QMatrix*>(ptr)->map(*static_cast<QPainterPath*>(path)));
}
void* QMatrix_Map3(void* ptr, void* point)
{
return ({ QPoint tmpValue = static_cast<QMatrix*>(ptr)->map(*static_cast<QPoint*>(point)); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QMatrix_Map4(void* ptr, void* point)
{
return ({ QPointF tmpValue = static_cast<QMatrix*>(ptr)->map(*static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void* QMatrix_Map8(void* ptr, void* polygon)
{
return new QPolygon(static_cast<QMatrix*>(ptr)->map(*static_cast<QPolygon*>(polygon)));
}
void* QMatrix_MapToPolygon(void* ptr, void* rectangle)
{
return new QPolygon(static_cast<QMatrix*>(ptr)->mapToPolygon(*static_cast<QRect*>(rectangle)));
}
void* QMatrix_Map7(void* ptr, void* polygon)
{
return new QPolygonF(static_cast<QMatrix*>(ptr)->map(*static_cast<QPolygonF*>(polygon)));
}
void* QMatrix_MapRect2(void* ptr, void* rectangle)
{
return ({ QRect tmpValue = static_cast<QMatrix*>(ptr)->mapRect(*static_cast<QRect*>(rectangle)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QMatrix_MapRect(void* ptr, void* rectangle)
{
return ({ QRectF tmpValue = static_cast<QMatrix*>(ptr)->mapRect(*static_cast<QRectF*>(rectangle)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QMatrix_Map9(void* ptr, void* region)
{
return new QRegion(static_cast<QMatrix*>(ptr)->map(*static_cast<QRegion*>(region)));
}
char QMatrix_IsIdentity(void* ptr)
{
return static_cast<QMatrix*>(ptr)->isIdentity();
}
char QMatrix_IsInvertible(void* ptr)
{
return static_cast<QMatrix*>(ptr)->isInvertible();
}
double QMatrix_Determinant(void* ptr)
{
return static_cast<QMatrix*>(ptr)->determinant();
}
double QMatrix_Dx(void* ptr)
{
return static_cast<QMatrix*>(ptr)->dx();
}
double QMatrix_Dy(void* ptr)
{
return static_cast<QMatrix*>(ptr)->dy();
}
double QMatrix_M11(void* ptr)
{
return static_cast<QMatrix*>(ptr)->m11();
}
double QMatrix_M12(void* ptr)
{
return static_cast<QMatrix*>(ptr)->m12();
}
double QMatrix_M21(void* ptr)
{
return static_cast<QMatrix*>(ptr)->m21();
}
double QMatrix_M22(void* ptr)
{
return static_cast<QMatrix*>(ptr)->m22();
}
void QMatrix_Map2(void* ptr, int x, int y, int tx, int ty)
{
static_cast<QMatrix*>(ptr)->map(x, y, &tx, &ty);
}
void QMatrix_Map(void* ptr, double x, double y, double tx, double ty)
{
static_cast<QMatrix*>(ptr)->map(x, y, &tx, &ty);
}
void* QMatrix4x4_NewQMatrix4x4()
{
return new QMatrix4x4();
}
void* QMatrix4x4_NewQMatrix4x48(void* matrix)
{
return new QMatrix4x4(*static_cast<QMatrix*>(matrix));
}
void* QMatrix4x4_NewQMatrix4x47(void* transform)
{
return new QMatrix4x4(*static_cast<QTransform*>(transform));
}
void* QMatrix4x4_NewQMatrix4x43(float values)
{
return new QMatrix4x4(const_cast<const float*>(&values));
}
void* QMatrix4x4_NewQMatrix4x44(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
{
return new QMatrix4x4(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
}
float QMatrix4x4_Data(void* ptr)
{
return *static_cast<QMatrix4x4*>(ptr)->data();
}
void QMatrix4x4_Fill(void* ptr, float value)
{
static_cast<QMatrix4x4*>(ptr)->fill(value);
}
void QMatrix4x4_Frustum(void* ptr, float left, float right, float bottom, float top, float nearPlane, float farPlane)
{
static_cast<QMatrix4x4*>(ptr)->frustum(left, right, bottom, top, nearPlane, farPlane);
}
void QMatrix4x4_LookAt(void* ptr, void* eye, void* center, void* up)
{
static_cast<QMatrix4x4*>(ptr)->lookAt(*static_cast<QVector3D*>(eye), *static_cast<QVector3D*>(center), *static_cast<QVector3D*>(up));
}
void QMatrix4x4_Optimize(void* ptr)
{
static_cast<QMatrix4x4*>(ptr)->optimize();
}
void QMatrix4x4_Ortho3(void* ptr, void* rect)
{
static_cast<QMatrix4x4*>(ptr)->ortho(*static_cast<QRect*>(rect));
}
void QMatrix4x4_Ortho2(void* ptr, void* rect)
{
static_cast<QMatrix4x4*>(ptr)->ortho(*static_cast<QRectF*>(rect));
}
void QMatrix4x4_Ortho(void* ptr, float left, float right, float bottom, float top, float nearPlane, float farPlane)
{
static_cast<QMatrix4x4*>(ptr)->ortho(left, right, bottom, top, nearPlane, farPlane);
}
void QMatrix4x4_Perspective(void* ptr, float verticalAngle, float aspectRatio, float nearPlane, float farPlane)
{
static_cast<QMatrix4x4*>(ptr)->perspective(verticalAngle, aspectRatio, nearPlane, farPlane);
}
void QMatrix4x4_Rotate3(void* ptr, void* quaternion)
{
static_cast<QMatrix4x4*>(ptr)->rotate(*static_cast<QQuaternion*>(quaternion));
}
void QMatrix4x4_Rotate(void* ptr, float angle, void* vector)
{
static_cast<QMatrix4x4*>(ptr)->rotate(angle, *static_cast<QVector3D*>(vector));
}
void QMatrix4x4_Rotate2(void* ptr, float angle, float x, float y, float z)
{
static_cast<QMatrix4x4*>(ptr)->rotate(angle, x, y, z);
}
void QMatrix4x4_Scale(void* ptr, void* vector)
{
static_cast<QMatrix4x4*>(ptr)->scale(*static_cast<QVector3D*>(vector));
}
void QMatrix4x4_Scale4(void* ptr, float factor)
{
static_cast<QMatrix4x4*>(ptr)->scale(factor);
}
void QMatrix4x4_Scale2(void* ptr, float x, float y)
{
static_cast<QMatrix4x4*>(ptr)->scale(x, y);
}
void QMatrix4x4_Scale3(void* ptr, float x, float y, float z)
{
static_cast<QMatrix4x4*>(ptr)->scale(x, y, z);
}
void QMatrix4x4_SetColumn(void* ptr, int index, void* value)
{
static_cast<QMatrix4x4*>(ptr)->setColumn(index, *static_cast<QVector4D*>(value));
}
void QMatrix4x4_SetRow(void* ptr, int index, void* value)
{
static_cast<QMatrix4x4*>(ptr)->setRow(index, *static_cast<QVector4D*>(value));
}
void QMatrix4x4_SetToIdentity(void* ptr)
{
static_cast<QMatrix4x4*>(ptr)->setToIdentity();
}
void QMatrix4x4_Translate(void* ptr, void* vector)
{
static_cast<QMatrix4x4*>(ptr)->translate(*static_cast<QVector3D*>(vector));
}
void QMatrix4x4_Translate2(void* ptr, float x, float y)
{
static_cast<QMatrix4x4*>(ptr)->translate(x, y);
}
void QMatrix4x4_Translate3(void* ptr, float x, float y, float z)
{
static_cast<QMatrix4x4*>(ptr)->translate(x, y, z);
}
void QMatrix4x4_Viewport2(void* ptr, void* rect)
{
static_cast<QMatrix4x4*>(ptr)->viewport(*static_cast<QRectF*>(rect));
}
void QMatrix4x4_Viewport(void* ptr, float left, float bottom, float width, float height, float nearPlane, float farPlane)
{
static_cast<QMatrix4x4*>(ptr)->viewport(left, bottom, width, height, nearPlane, farPlane);
}
void* QMatrix4x4_ToAffine(void* ptr)
{
return new QMatrix(static_cast<QMatrix4x4*>(ptr)->toAffine());
}
void* QMatrix4x4_Inverted(void* ptr, char invertible)
{
Q_UNUSED(invertible);
return new QMatrix4x4(static_cast<QMatrix4x4*>(ptr)->inverted(NULL));
}
void* QMatrix4x4_Transposed(void* ptr)
{
return new QMatrix4x4(static_cast<QMatrix4x4*>(ptr)->transposed());
}
void* QMatrix4x4_Map(void* ptr, void* point)
{
return ({ QPoint tmpValue = static_cast<QMatrix4x4*>(ptr)->map(*static_cast<QPoint*>(point)); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QMatrix4x4_Map2(void* ptr, void* point)
{
return ({ QPointF tmpValue = static_cast<QMatrix4x4*>(ptr)->map(*static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void* QMatrix4x4_MapRect(void* ptr, void* rect)
{
return ({ QRect tmpValue = static_cast<QMatrix4x4*>(ptr)->mapRect(*static_cast<QRect*>(rect)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QMatrix4x4_MapRect2(void* ptr, void* rect)
{
return ({ QRectF tmpValue = static_cast<QMatrix4x4*>(ptr)->mapRect(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QMatrix4x4_ToTransform(void* ptr)
{
return new QTransform(static_cast<QMatrix4x4*>(ptr)->toTransform());
}
void* QMatrix4x4_ToTransform2(void* ptr, float distanceToPlane)
{
return new QTransform(static_cast<QMatrix4x4*>(ptr)->toTransform(distanceToPlane));
}
void* QMatrix4x4_Map3(void* ptr, void* point)
{
return new QVector3D(static_cast<QMatrix4x4*>(ptr)->map(*static_cast<QVector3D*>(point)));
}
void* QMatrix4x4_MapVector(void* ptr, void* vector)
{
return new QVector3D(static_cast<QMatrix4x4*>(ptr)->mapVector(*static_cast<QVector3D*>(vector)));
}
void* QMatrix4x4_Column(void* ptr, int index)
{
return new QVector4D(static_cast<QMatrix4x4*>(ptr)->column(index));
}
void* QMatrix4x4_Map4(void* ptr, void* point)
{
return new QVector4D(static_cast<QMatrix4x4*>(ptr)->map(*static_cast<QVector4D*>(point)));
}
void* QMatrix4x4_Row(void* ptr, int index)
{
return new QVector4D(static_cast<QMatrix4x4*>(ptr)->row(index));
}
char QMatrix4x4_IsAffine(void* ptr)
{
return static_cast<QMatrix4x4*>(ptr)->isAffine();
}
char QMatrix4x4_IsIdentity(void* ptr)
{
return static_cast<QMatrix4x4*>(ptr)->isIdentity();
}
float QMatrix4x4_ConstData(void* ptr)
{
return *static_cast<QMatrix4x4*>(ptr)->constData();
}
float QMatrix4x4_Data2(void* ptr)
{
return *static_cast<QMatrix4x4*>(ptr)->data();
}
double QMatrix4x4_Determinant(void* ptr)
{
return static_cast<QMatrix4x4*>(ptr)->determinant();
}
void QMatrix4x4_CopyDataTo(void* ptr, float values)
{
static_cast<QMatrix4x4*>(ptr)->copyDataTo(&values);
}
class MyQMouseEvent: public QMouseEvent
{
public:
MyQMouseEvent(QEvent::Type ty, const QPointF &localPos, Qt::MouseButton button, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers) : QMouseEvent(ty, localPos, button, buttons, modifiers) {};
MyQMouseEvent(QEvent::Type ty, const QPointF &localPos, const QPointF &screenPos, Qt::MouseButton button, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers) : QMouseEvent(ty, localPos, screenPos, button, buttons, modifiers) {};
MyQMouseEvent(QEvent::Type ty, const QPointF &localPos, const QPointF &windowPos, const QPointF &screenPos, Qt::MouseButton button, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers) : QMouseEvent(ty, localPos, windowPos, screenPos, button, buttons, modifiers) {};
MyQMouseEvent(QEvent::Type ty, const QPointF &localPos, const QPointF &windowPos, const QPointF &screenPos, Qt::MouseButton button, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Qt::MouseEventSource source) : QMouseEvent(ty, localPos, windowPos, screenPos, button, buttons, modifiers, source) {};
};
void* QMouseEvent_NewQMouseEvent(long long ty, void* localPos, long long button, long long buttons, long long modifiers)
{
return new MyQMouseEvent(static_cast<QEvent::Type>(ty), *static_cast<QPointF*>(localPos), static_cast<Qt::MouseButton>(button), static_cast<Qt::MouseButton>(buttons), static_cast<Qt::KeyboardModifier>(modifiers));
}
void* QMouseEvent_NewQMouseEvent2(long long ty, void* localPos, void* screenPos, long long button, long long buttons, long long modifiers)
{
return new MyQMouseEvent(static_cast<QEvent::Type>(ty), *static_cast<QPointF*>(localPos), *static_cast<QPointF*>(screenPos), static_cast<Qt::MouseButton>(button), static_cast<Qt::MouseButton>(buttons), static_cast<Qt::KeyboardModifier>(modifiers));
}
void* QMouseEvent_NewQMouseEvent3(long long ty, void* localPos, void* windowPos, void* screenPos, long long button, long long buttons, long long modifiers)
{
return new MyQMouseEvent(static_cast<QEvent::Type>(ty), *static_cast<QPointF*>(localPos), *static_cast<QPointF*>(windowPos), *static_cast<QPointF*>(screenPos), static_cast<Qt::MouseButton>(button), static_cast<Qt::MouseButton>(buttons), static_cast<Qt::KeyboardModifier>(modifiers));
}
void* QMouseEvent_NewQMouseEvent4(long long ty, void* localPos, void* windowPos, void* screenPos, long long button, long long buttons, long long modifiers, long long source)
{
return new MyQMouseEvent(static_cast<QEvent::Type>(ty), *static_cast<QPointF*>(localPos), *static_cast<QPointF*>(windowPos), *static_cast<QPointF*>(screenPos), static_cast<Qt::MouseButton>(button), static_cast<Qt::MouseButton>(buttons), static_cast<Qt::KeyboardModifier>(modifiers), static_cast<Qt::MouseEventSource>(source));
}
void* QMouseEvent_GlobalPos(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QMouseEvent*>(ptr)->globalPos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QMouseEvent_Pos(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QMouseEvent*>(ptr)->pos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
long long QMouseEvent_Button(void* ptr)
{
return static_cast<QMouseEvent*>(ptr)->button();
}
long long QMouseEvent_Buttons(void* ptr)
{
return static_cast<QMouseEvent*>(ptr)->buttons();
}
long long QMouseEvent_Flags(void* ptr)
{
return static_cast<QMouseEvent*>(ptr)->flags();
}
long long QMouseEvent_Source(void* ptr)
{
return static_cast<QMouseEvent*>(ptr)->source();
}
void* QMouseEvent_LocalPos(void* ptr)
{
return const_cast<QPointF*>(&static_cast<QMouseEvent*>(ptr)->localPos());
}
void* QMouseEvent_ScreenPos(void* ptr)
{
return const_cast<QPointF*>(&static_cast<QMouseEvent*>(ptr)->screenPos());
}
void* QMouseEvent_WindowPos(void* ptr)
{
return const_cast<QPointF*>(&static_cast<QMouseEvent*>(ptr)->windowPos());
}
int QMouseEvent_GlobalX(void* ptr)
{
return static_cast<QMouseEvent*>(ptr)->globalX();
}
int QMouseEvent_GlobalY(void* ptr)
{
return static_cast<QMouseEvent*>(ptr)->globalY();
}
int QMouseEvent_X(void* ptr)
{
return static_cast<QMouseEvent*>(ptr)->x();
}
int QMouseEvent_Y(void* ptr)
{
return static_cast<QMouseEvent*>(ptr)->y();
}
long long QMouseEvent_B(void* ptr)
{
return static_cast<QMouseEvent*>(ptr)->b;
}
void QMouseEvent_SetB(void* ptr, long long vqt)
{
static_cast<QMouseEvent*>(ptr)->b = static_cast<Qt::MouseButton>(vqt);
}
int QMouseEvent_Caps(void* ptr)
{
return static_cast<QMouseEvent*>(ptr)->caps;
}
void QMouseEvent_SetCaps(void* ptr, int vin)
{
static_cast<QMouseEvent*>(ptr)->caps = vin;
}
void* QMouseEvent_L(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QMouseEvent*>(ptr)->l; new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QMouseEvent_SetL(void* ptr, void* vqp)
{
static_cast<QMouseEvent*>(ptr)->l = *static_cast<QPointF*>(vqp);
}
long long QMouseEvent_MouseState(void* ptr)
{
return static_cast<QMouseEvent*>(ptr)->mouseState;
}
void QMouseEvent_SetMouseState(void* ptr, long long vqt)
{
static_cast<QMouseEvent*>(ptr)->mouseState = static_cast<Qt::MouseButton>(vqt);
}
void* QMouseEvent_S(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QMouseEvent*>(ptr)->s; new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QMouseEvent_SetS(void* ptr, void* vqp)
{
static_cast<QMouseEvent*>(ptr)->s = *static_cast<QPointF*>(vqp);
}
void* QMouseEvent_Velocity(void* ptr)
{
return new QVector2D(static_cast<QMouseEvent*>(ptr)->velocity);
}
void QMouseEvent_SetVelocity(void* ptr, void* vqv)
{
static_cast<QMouseEvent*>(ptr)->velocity = *static_cast<QVector2D*>(vqv);
}
void* QMouseEvent_W(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QMouseEvent*>(ptr)->w; new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QMouseEvent_SetW(void* ptr, void* vqp)
{
static_cast<QMouseEvent*>(ptr)->w = *static_cast<QPointF*>(vqp);
}
class MyQMoveEvent: public QMoveEvent
{
public:
MyQMoveEvent(const QPoint &pos, const QPoint &oldPos) : QMoveEvent(pos, oldPos) {};
};
void* QMoveEvent_NewQMoveEvent(void* pos, void* oldPos)
{
return new MyQMoveEvent(*static_cast<QPoint*>(pos), *static_cast<QPoint*>(oldPos));
}
void* QMoveEvent_OldPos(void* ptr)
{
return const_cast<QPoint*>(&static_cast<QMoveEvent*>(ptr)->oldPos());
}
void* QMoveEvent_Pos(void* ptr)
{
return const_cast<QPoint*>(&static_cast<QMoveEvent*>(ptr)->pos());
}
void* QMoveEvent_Oldp(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QMoveEvent*>(ptr)->oldp; new QPoint(tmpValue.x(), tmpValue.y()); });
}
void QMoveEvent_SetOldp(void* ptr, void* vqp)
{
static_cast<QMoveEvent*>(ptr)->oldp = *static_cast<QPoint*>(vqp);
}
void* QMoveEvent_P(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QMoveEvent*>(ptr)->p; new QPoint(tmpValue.x(), tmpValue.y()); });
}
void QMoveEvent_SetP(void* ptr, void* vqp)
{
static_cast<QMoveEvent*>(ptr)->p = *static_cast<QPoint*>(vqp);
}
class MyQMovie: public QMovie
{
public:
MyQMovie(QIODevice *device, const QByteArray &format = QByteArray(), QObject *parent = Q_NULLPTR) : QMovie(device, format, parent) {QMovie_QMovie_QRegisterMetaType();};
MyQMovie(QObject *parent = Q_NULLPTR) : QMovie(parent) {QMovie_QMovie_QRegisterMetaType();};
MyQMovie(const QString &fileName, const QByteArray &format = QByteArray(), QObject *parent = Q_NULLPTR) : QMovie(fileName, format, parent) {QMovie_QMovie_QRegisterMetaType();};
bool jumpToNextFrame() { return callbackQMovie_JumpToNextFrame(this) != 0; };
void Signal_Error(QImageReader::ImageReaderError error) { callbackQMovie_Error(this, error); };
void Signal_Finished() { callbackQMovie_Finished(this); };
void Signal_FrameChanged(int frameNumber) { callbackQMovie_FrameChanged(this, frameNumber); };
void Signal_Resized(const QSize & size) { callbackQMovie_Resized(this, const_cast<QSize*>(&size)); };
void setPaused(bool paused) { callbackQMovie_SetPaused(this, paused); };
void setSpeed(int percentSpeed) { callbackQMovie_SetSpeed(this, percentSpeed); };
void start() { callbackQMovie_Start(this); };
void Signal_Started() { callbackQMovie_Started(this); };
void Signal_StateChanged(QMovie::MovieState state) { callbackQMovie_StateChanged(this, state); };
void stop() { callbackQMovie_Stop(this); };
void Signal_Updated(const QRect & rect) { callbackQMovie_Updated(this, const_cast<QRect*>(&rect)); };
~MyQMovie() { callbackQMovie_DestroyQMovie(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMovie_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQMovie_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQMovie_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQMovie_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQMovie_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQMovie_CustomEvent(this, event); };
void deleteLater() { callbackQMovie_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQMovie_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQMovie_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMovie_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQMovie_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQMovie*)
int QMovie_QMovie_QRegisterMetaType(){qRegisterMetaType<QMovie*>(); return qRegisterMetaType<MyQMovie*>();}
struct QtGui_PackedList QMovie_QMovie_SupportedFormats()
{
return ({ QList<QByteArray>* tmpValue = new QList<QByteArray>(QMovie::supportedFormats()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QMovie_NewQMovie2(void* device, void* format, void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format), static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format), static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format), static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format), static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format), static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format), static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format), static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format), static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format), static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format), static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format), static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format), static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format), static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format), static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format), static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format), static_cast<QWindow*>(parent));
} else {
return new MyQMovie(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format), static_cast<QObject*>(parent));
}
}
void* QMovie_NewQMovie(void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQMovie(static_cast<QWindow*>(parent));
} else {
return new MyQMovie(static_cast<QObject*>(parent));
}
}
void* QMovie_NewQMovie3(struct QtGui_PackedString fileName, void* format, void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQMovie(QString::fromUtf8(fileName.data, fileName.len), *static_cast<QByteArray*>(format), static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQMovie(QString::fromUtf8(fileName.data, fileName.len), *static_cast<QByteArray*>(format), static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQMovie(QString::fromUtf8(fileName.data, fileName.len), *static_cast<QByteArray*>(format), static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQMovie(QString::fromUtf8(fileName.data, fileName.len), *static_cast<QByteArray*>(format), static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQMovie(QString::fromUtf8(fileName.data, fileName.len), *static_cast<QByteArray*>(format), static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQMovie(QString::fromUtf8(fileName.data, fileName.len), *static_cast<QByteArray*>(format), static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQMovie(QString::fromUtf8(fileName.data, fileName.len), *static_cast<QByteArray*>(format), static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQMovie(QString::fromUtf8(fileName.data, fileName.len), *static_cast<QByteArray*>(format), static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQMovie(QString::fromUtf8(fileName.data, fileName.len), *static_cast<QByteArray*>(format), static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQMovie(QString::fromUtf8(fileName.data, fileName.len), *static_cast<QByteArray*>(format), static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQMovie(QString::fromUtf8(fileName.data, fileName.len), *static_cast<QByteArray*>(format), static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQMovie(QString::fromUtf8(fileName.data, fileName.len), *static_cast<QByteArray*>(format), static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQMovie(QString::fromUtf8(fileName.data, fileName.len), *static_cast<QByteArray*>(format), static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQMovie(QString::fromUtf8(fileName.data, fileName.len), *static_cast<QByteArray*>(format), static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQMovie(QString::fromUtf8(fileName.data, fileName.len), *static_cast<QByteArray*>(format), static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQMovie(QString::fromUtf8(fileName.data, fileName.len), *static_cast<QByteArray*>(format), static_cast<QWindow*>(parent));
} else {
return new MyQMovie(QString::fromUtf8(fileName.data, fileName.len), *static_cast<QByteArray*>(format), static_cast<QObject*>(parent));
}
}
void* QMovie_ScaledSize(void* ptr)
{
return ({ QSize tmpValue = static_cast<QMovie*>(ptr)->scaledSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}
struct QtGui_PackedString QMovie_QMovie_Tr(char* s, char* c, int n)
{
return ({ QByteArray t36e6fa = QMovie::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t36e6fa.prepend("WHITESPACE").constData()+10), t36e6fa.size()-10 }; });
}
struct QtGui_PackedString QMovie_QMovie_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray t75522a = QMovie::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t75522a.prepend("WHITESPACE").constData()+10), t75522a.size()-10 }; });
}
char QMovie_JumpToFrame(void* ptr, int frameNumber)
{
return static_cast<QMovie*>(ptr)->jumpToFrame(frameNumber);
}
char QMovie_JumpToNextFrame(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QMovie*>(ptr), "jumpToNextFrame", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
char QMovie_JumpToNextFrameDefault(void* ptr)
{
return static_cast<QMovie*>(ptr)->QMovie::jumpToNextFrame();
}
void QMovie_ConnectError(void* ptr)
{
QObject::connect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)(QImageReader::ImageReaderError)>(&QMovie::error), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)(QImageReader::ImageReaderError)>(&MyQMovie::Signal_Error));
}
void QMovie_DisconnectError(void* ptr)
{
QObject::disconnect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)(QImageReader::ImageReaderError)>(&QMovie::error), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)(QImageReader::ImageReaderError)>(&MyQMovie::Signal_Error));
}
void QMovie_Error(void* ptr, long long error)
{
static_cast<QMovie*>(ptr)->error(static_cast<QImageReader::ImageReaderError>(error));
}
void QMovie_ConnectFinished(void* ptr)
{
QObject::connect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)()>(&QMovie::finished), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)()>(&MyQMovie::Signal_Finished));
}
void QMovie_DisconnectFinished(void* ptr)
{
QObject::disconnect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)()>(&QMovie::finished), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)()>(&MyQMovie::Signal_Finished));
}
void QMovie_Finished(void* ptr)
{
static_cast<QMovie*>(ptr)->finished();
}
void QMovie_ConnectFrameChanged(void* ptr)
{
QObject::connect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)(int)>(&QMovie::frameChanged), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)(int)>(&MyQMovie::Signal_FrameChanged));
}
void QMovie_DisconnectFrameChanged(void* ptr)
{
QObject::disconnect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)(int)>(&QMovie::frameChanged), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)(int)>(&MyQMovie::Signal_FrameChanged));
}
void QMovie_FrameChanged(void* ptr, int frameNumber)
{
static_cast<QMovie*>(ptr)->frameChanged(frameNumber);
}
void QMovie_ConnectResized(void* ptr)
{
QObject::connect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)(const QSize &)>(&QMovie::resized), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)(const QSize &)>(&MyQMovie::Signal_Resized));
}
void QMovie_DisconnectResized(void* ptr)
{
QObject::disconnect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)(const QSize &)>(&QMovie::resized), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)(const QSize &)>(&MyQMovie::Signal_Resized));
}
void QMovie_Resized(void* ptr, void* size)
{
static_cast<QMovie*>(ptr)->resized(*static_cast<QSize*>(size));
}
void QMovie_SetBackgroundColor(void* ptr, void* color)
{
static_cast<QMovie*>(ptr)->setBackgroundColor(*static_cast<QColor*>(color));
}
void QMovie_SetCacheMode(void* ptr, long long mode)
{
static_cast<QMovie*>(ptr)->setCacheMode(static_cast<QMovie::CacheMode>(mode));
}
void QMovie_SetDevice(void* ptr, void* device)
{
static_cast<QMovie*>(ptr)->setDevice(static_cast<QIODevice*>(device));
}
void QMovie_SetFileName(void* ptr, struct QtGui_PackedString fileName)
{
static_cast<QMovie*>(ptr)->setFileName(QString::fromUtf8(fileName.data, fileName.len));
}
void QMovie_SetFormat(void* ptr, void* format)
{
static_cast<QMovie*>(ptr)->setFormat(*static_cast<QByteArray*>(format));
}
void QMovie_SetPaused(void* ptr, char paused)
{
QMetaObject::invokeMethod(static_cast<QMovie*>(ptr), "setPaused", Q_ARG(bool, paused != 0));
}
void QMovie_SetPausedDefault(void* ptr, char paused)
{
static_cast<QMovie*>(ptr)->QMovie::setPaused(paused != 0);
}
void QMovie_SetScaledSize(void* ptr, void* size)
{
static_cast<QMovie*>(ptr)->setScaledSize(*static_cast<QSize*>(size));
}
void QMovie_SetSpeed(void* ptr, int percentSpeed)
{
QMetaObject::invokeMethod(static_cast<QMovie*>(ptr), "setSpeed", Q_ARG(int, percentSpeed));
}
void QMovie_SetSpeedDefault(void* ptr, int percentSpeed)
{
static_cast<QMovie*>(ptr)->QMovie::setSpeed(percentSpeed);
}
void QMovie_Start(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QMovie*>(ptr), "start");
}
void QMovie_StartDefault(void* ptr)
{
static_cast<QMovie*>(ptr)->QMovie::start();
}
void QMovie_ConnectStarted(void* ptr)
{
QObject::connect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)()>(&QMovie::started), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)()>(&MyQMovie::Signal_Started));
}
void QMovie_DisconnectStarted(void* ptr)
{
QObject::disconnect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)()>(&QMovie::started), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)()>(&MyQMovie::Signal_Started));
}
void QMovie_Started(void* ptr)
{
static_cast<QMovie*>(ptr)->started();
}
void QMovie_ConnectStateChanged(void* ptr)
{
qRegisterMetaType<QMovie::MovieState>();
QObject::connect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)(QMovie::MovieState)>(&QMovie::stateChanged), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)(QMovie::MovieState)>(&MyQMovie::Signal_StateChanged));
}
void QMovie_DisconnectStateChanged(void* ptr)
{
QObject::disconnect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)(QMovie::MovieState)>(&QMovie::stateChanged), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)(QMovie::MovieState)>(&MyQMovie::Signal_StateChanged));
}
void QMovie_StateChanged(void* ptr, long long state)
{
static_cast<QMovie*>(ptr)->stateChanged(static_cast<QMovie::MovieState>(state));
}
void QMovie_Stop(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QMovie*>(ptr), "stop");
}
void QMovie_StopDefault(void* ptr)
{
static_cast<QMovie*>(ptr)->QMovie::stop();
}
void QMovie_ConnectUpdated(void* ptr)
{
QObject::connect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)(const QRect &)>(&QMovie::updated), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)(const QRect &)>(&MyQMovie::Signal_Updated));
}
void QMovie_DisconnectUpdated(void* ptr)
{
QObject::disconnect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)(const QRect &)>(&QMovie::updated), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)(const QRect &)>(&MyQMovie::Signal_Updated));
}
void QMovie_Updated(void* ptr, void* rect)
{
static_cast<QMovie*>(ptr)->updated(*static_cast<QRect*>(rect));
}
void QMovie_DestroyQMovie(void* ptr)
{
static_cast<QMovie*>(ptr)->~QMovie();
}
void QMovie_DestroyQMovieDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QMovie_Format(void* ptr)
{
return new QByteArray(static_cast<QMovie*>(ptr)->format());
}
void* QMovie_BackgroundColor(void* ptr)
{
return new QColor(static_cast<QMovie*>(ptr)->backgroundColor());
}
void* QMovie_Device(void* ptr)
{
return static_cast<QMovie*>(ptr)->device();
}
void* QMovie_CurrentImage(void* ptr)
{
return new QImage(static_cast<QMovie*>(ptr)->currentImage());
}
long long QMovie_LastError(void* ptr)
{
return static_cast<QMovie*>(ptr)->lastError();
}
long long QMovie_CacheMode(void* ptr)
{
return static_cast<QMovie*>(ptr)->cacheMode();
}
long long QMovie_State(void* ptr)
{
return static_cast<QMovie*>(ptr)->state();
}
void* QMovie_CurrentPixmap(void* ptr)
{
return new QPixmap(static_cast<QMovie*>(ptr)->currentPixmap());
}
void* QMovie_FrameRect(void* ptr)
{
return ({ QRect tmpValue = static_cast<QMovie*>(ptr)->frameRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
struct QtGui_PackedString QMovie_FileName(void* ptr)
{
return ({ QByteArray t73bc7e = static_cast<QMovie*>(ptr)->fileName().toUtf8(); QtGui_PackedString { const_cast<char*>(t73bc7e.prepend("WHITESPACE").constData()+10), t73bc7e.size()-10 }; });
}
struct QtGui_PackedString QMovie_LastErrorString(void* ptr)
{
return ({ QByteArray tc1e035 = static_cast<QMovie*>(ptr)->lastErrorString().toUtf8(); QtGui_PackedString { const_cast<char*>(tc1e035.prepend("WHITESPACE").constData()+10), tc1e035.size()-10 }; });
}
char QMovie_IsValid(void* ptr)
{
return static_cast<QMovie*>(ptr)->isValid();
}
void* QMovie_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QMovie*>(ptr)->QMovie::metaObject());
}
int QMovie_CurrentFrameNumber(void* ptr)
{
return static_cast<QMovie*>(ptr)->currentFrameNumber();
}
int QMovie_FrameCount(void* ptr)
{
return static_cast<QMovie*>(ptr)->frameCount();
}
int QMovie_LoopCount(void* ptr)
{
return static_cast<QMovie*>(ptr)->loopCount();
}
int QMovie_NextFrameDelay(void* ptr)
{
return static_cast<QMovie*>(ptr)->nextFrameDelay();
}
int QMovie_Speed(void* ptr)
{
return static_cast<QMovie*>(ptr)->speed();
}
void* QMovie___supportedFormats_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QMovie___supportedFormats_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QMovie___supportedFormats_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QMovie___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QMovie___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QMovie___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QMovie___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QMovie___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QMovie___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QMovie___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QMovie___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QMovie___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QMovie___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QMovie___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QMovie___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QMovie___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QMovie___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QMovie___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QMovie_EventDefault(void* ptr, void* e)
{
return static_cast<QMovie*>(ptr)->QMovie::event(static_cast<QEvent*>(e));
}
char QMovie_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QMovie*>(ptr)->QMovie::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QMovie*>(ptr)->QMovie::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QMovie*>(ptr)->QMovie::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QMovie*>(ptr)->QMovie::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QMovie*>(ptr)->QMovie::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QMovie_ChildEventDefault(void* ptr, void* event)
{
static_cast<QMovie*>(ptr)->QMovie::childEvent(static_cast<QChildEvent*>(event));
}
void QMovie_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QMovie*>(ptr)->QMovie::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QMovie_CustomEventDefault(void* ptr, void* event)
{
static_cast<QMovie*>(ptr)->QMovie::customEvent(static_cast<QEvent*>(event));
}
void QMovie_DeleteLaterDefault(void* ptr)
{
static_cast<QMovie*>(ptr)->QMovie::deleteLater();
}
void QMovie_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QMovie*>(ptr)->QMovie::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QMovie_TimerEventDefault(void* ptr, void* event)
{
static_cast<QMovie*>(ptr)->QMovie::timerEvent(static_cast<QTimerEvent*>(event));
}
class MyQNativeGestureEvent: public QNativeGestureEvent
{
public:
MyQNativeGestureEvent(Qt::NativeGestureType ty, const QTouchDevice *device, const QPointF &localPos, const QPointF &windowPos, const QPointF &screenPos, qreal realValue, ulong sequenceId, quint64 intValue) : QNativeGestureEvent(ty, device, localPos, windowPos, screenPos, realValue, sequenceId, intValue) {};
~MyQNativeGestureEvent() { callbackQNativeGestureEvent_DestroyQNativeGestureEvent(this); };
};
void* QNativeGestureEvent_NewQNativeGestureEvent(long long ty, void* device, void* localPos, void* windowPos, void* screenPos, double realValue, unsigned long sequenceId, unsigned long long intValue)
{
return new MyQNativeGestureEvent(static_cast<Qt::NativeGestureType>(ty), static_cast<QTouchDevice*>(device), *static_cast<QPointF*>(localPos), *static_cast<QPointF*>(windowPos), *static_cast<QPointF*>(screenPos), realValue, sequenceId, intValue);
}
void QNativeGestureEvent_DestroyQNativeGestureEvent(void* ptr)
{
static_cast<QNativeGestureEvent*>(ptr)->~QNativeGestureEvent();
}
void QNativeGestureEvent_DestroyQNativeGestureEventDefault(void* ptr)
{
Q_UNUSED(ptr);
}
long long QNativeGestureEvent_GestureType(void* ptr)
{
return static_cast<QNativeGestureEvent*>(ptr)->gestureType();
}
void* QNativeGestureEvent_GlobalPos(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QNativeGestureEvent*>(ptr)->globalPos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QNativeGestureEvent_Pos(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QNativeGestureEvent*>(ptr)->pos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QNativeGestureEvent_LocalPos(void* ptr)
{
return const_cast<QPointF*>(&static_cast<QNativeGestureEvent*>(ptr)->localPos());
}
void* QNativeGestureEvent_ScreenPos(void* ptr)
{
return const_cast<QPointF*>(&static_cast<QNativeGestureEvent*>(ptr)->screenPos());
}
void* QNativeGestureEvent_WindowPos(void* ptr)
{
return const_cast<QPointF*>(&static_cast<QNativeGestureEvent*>(ptr)->windowPos());
}
void* QNativeGestureEvent_Device(void* ptr)
{
return const_cast<QTouchDevice*>(static_cast<QNativeGestureEvent*>(ptr)->device());
}
double QNativeGestureEvent_Value(void* ptr)
{
return static_cast<QNativeGestureEvent*>(ptr)->value();
}
long long QNativeGestureEvent_MGestureType(void* ptr)
{
return static_cast<QNativeGestureEvent*>(ptr)->mGestureType;
}
void QNativeGestureEvent_SetMGestureType(void* ptr, long long vqt)
{
static_cast<QNativeGestureEvent*>(ptr)->mGestureType = static_cast<Qt::NativeGestureType>(vqt);
}
unsigned long long QNativeGestureEvent_MIntValue(void* ptr)
{
return static_cast<QNativeGestureEvent*>(ptr)->mIntValue;
}
void QNativeGestureEvent_SetMIntValue(void* ptr, unsigned long long vqu)
{
static_cast<QNativeGestureEvent*>(ptr)->mIntValue = vqu;
}
void* QNativeGestureEvent_MLocalPos(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QNativeGestureEvent*>(ptr)->mLocalPos; new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QNativeGestureEvent_SetMLocalPos(void* ptr, void* vqp)
{
static_cast<QNativeGestureEvent*>(ptr)->mLocalPos = *static_cast<QPointF*>(vqp);
}
double QNativeGestureEvent_MRealValue(void* ptr)
{
return static_cast<QNativeGestureEvent*>(ptr)->mRealValue;
}
void QNativeGestureEvent_SetMRealValue(void* ptr, double vqr)
{
static_cast<QNativeGestureEvent*>(ptr)->mRealValue = vqr;
}
void* QNativeGestureEvent_MScreenPos(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QNativeGestureEvent*>(ptr)->mScreenPos; new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QNativeGestureEvent_SetMScreenPos(void* ptr, void* vqp)
{
static_cast<QNativeGestureEvent*>(ptr)->mScreenPos = *static_cast<QPointF*>(vqp);
}
unsigned long QNativeGestureEvent_MSequenceId(void* ptr)
{
return static_cast<QNativeGestureEvent*>(ptr)->mSequenceId;
}
void QNativeGestureEvent_SetMSequenceId(void* ptr, unsigned long vul)
{
static_cast<QNativeGestureEvent*>(ptr)->mSequenceId = vul;
}
void* QNativeGestureEvent_MWindowPos(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QNativeGestureEvent*>(ptr)->mWindowPos; new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QNativeGestureEvent_SetMWindowPos(void* ptr, void* vqp)
{
static_cast<QNativeGestureEvent*>(ptr)->mWindowPos = *static_cast<QPointF*>(vqp);
}
class MyQOffscreenSurface: public QOffscreenSurface
{
public:
MyQOffscreenSurface(QScreen *targetScreen = Q_NULLPTR) : QOffscreenSurface(targetScreen) {QOffscreenSurface_QOffscreenSurface_QRegisterMetaType();};
MyQOffscreenSurface(QScreen *targetScreen, QObject *parent) : QOffscreenSurface(targetScreen, parent) {QOffscreenSurface_QOffscreenSurface_QRegisterMetaType();};
void Signal_ScreenChanged(QScreen * screen) { callbackQOffscreenSurface_ScreenChanged(this, screen); };
~MyQOffscreenSurface() { callbackQOffscreenSurface_DestroyQOffscreenSurface(this); };
QSize size() const { return *static_cast<QSize*>(callbackQOffscreenSurface_Size(const_cast<void*>(static_cast<const void*>(this)))); };
QSurface::SurfaceType surfaceType() const { return static_cast<QSurface::SurfaceType>(callbackQOffscreenSurface_SurfaceType(const_cast<void*>(static_cast<const void*>(this)))); };
QSurfaceFormat format() const { return *static_cast<QSurfaceFormat*>(callbackQOffscreenSurface_Format(const_cast<void*>(static_cast<const void*>(this)))); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQOffscreenSurface_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQOffscreenSurface_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQOffscreenSurface_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQOffscreenSurface_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQOffscreenSurface_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQOffscreenSurface_CustomEvent(this, event); };
void deleteLater() { callbackQOffscreenSurface_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQOffscreenSurface_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQOffscreenSurface_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQOffscreenSurface_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQOffscreenSurface_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQOffscreenSurface*)
int QOffscreenSurface_QOffscreenSurface_QRegisterMetaType(){qRegisterMetaType<QOffscreenSurface*>(); return qRegisterMetaType<MyQOffscreenSurface*>();}
void* QOffscreenSurface_NewQOffscreenSurface2(void* targetScreen)
{
return new MyQOffscreenSurface(static_cast<QScreen*>(targetScreen));
}
void* QOffscreenSurface_NewQOffscreenSurface(void* targetScreen, void* parent)
{
return new MyQOffscreenSurface(static_cast<QScreen*>(targetScreen), static_cast<QObject*>(parent));
}
struct QtGui_PackedString QOffscreenSurface_QOffscreenSurface_Tr(char* s, char* c, int n)
{
return ({ QByteArray t442f01 = QOffscreenSurface::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t442f01.prepend("WHITESPACE").constData()+10), t442f01.size()-10 }; });
}
struct QtGui_PackedString QOffscreenSurface_QOffscreenSurface_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray t0b1a83 = QOffscreenSurface::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t0b1a83.prepend("WHITESPACE").constData()+10), t0b1a83.size()-10 }; });
}
void QOffscreenSurface_Create(void* ptr)
{
static_cast<QOffscreenSurface*>(ptr)->create();
}
void QOffscreenSurface_Destroy(void* ptr)
{
static_cast<QOffscreenSurface*>(ptr)->destroy();
}
void QOffscreenSurface_ConnectScreenChanged(void* ptr)
{
QObject::connect(static_cast<QOffscreenSurface*>(ptr), static_cast<void (QOffscreenSurface::*)(QScreen *)>(&QOffscreenSurface::screenChanged), static_cast<MyQOffscreenSurface*>(ptr), static_cast<void (MyQOffscreenSurface::*)(QScreen *)>(&MyQOffscreenSurface::Signal_ScreenChanged));
}
void QOffscreenSurface_DisconnectScreenChanged(void* ptr)
{
QObject::disconnect(static_cast<QOffscreenSurface*>(ptr), static_cast<void (QOffscreenSurface::*)(QScreen *)>(&QOffscreenSurface::screenChanged), static_cast<MyQOffscreenSurface*>(ptr), static_cast<void (MyQOffscreenSurface::*)(QScreen *)>(&MyQOffscreenSurface::Signal_ScreenChanged));
}
void QOffscreenSurface_ScreenChanged(void* ptr, void* screen)
{
static_cast<QOffscreenSurface*>(ptr)->screenChanged(static_cast<QScreen*>(screen));
}
void QOffscreenSurface_SetFormat(void* ptr, void* format)
{
static_cast<QOffscreenSurface*>(ptr)->setFormat(*static_cast<QSurfaceFormat*>(format));
}
void QOffscreenSurface_SetNativeHandle(void* ptr, void* handle)
{
static_cast<QOffscreenSurface*>(ptr)->setNativeHandle(handle);
}
void QOffscreenSurface_SetScreen(void* ptr, void* newScreen)
{
static_cast<QOffscreenSurface*>(ptr)->setScreen(static_cast<QScreen*>(newScreen));
}
void QOffscreenSurface_DestroyQOffscreenSurface(void* ptr)
{
static_cast<QOffscreenSurface*>(ptr)->~QOffscreenSurface();
}
void QOffscreenSurface_DestroyQOffscreenSurfaceDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QOffscreenSurface_Screen(void* ptr)
{
return static_cast<QOffscreenSurface*>(ptr)->screen();
}
void* QOffscreenSurface_Size(void* ptr)
{
return ({ QSize tmpValue = static_cast<QOffscreenSurface*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
}
void* QOffscreenSurface_SizeDefault(void* ptr)
{
return ({ QSize tmpValue = static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::size(); new QSize(tmpValue.width(), tmpValue.height()); });
}
long long QOffscreenSurface_SurfaceType(void* ptr)
{
return static_cast<QOffscreenSurface*>(ptr)->surfaceType();
}
long long QOffscreenSurface_SurfaceTypeDefault(void* ptr)
{
return static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::surfaceType();
}
void* QOffscreenSurface_Format(void* ptr)
{
return new QSurfaceFormat(static_cast<QOffscreenSurface*>(ptr)->format());
}
void* QOffscreenSurface_FormatDefault(void* ptr)
{
return new QSurfaceFormat(static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::format());
}
void* QOffscreenSurface_RequestedFormat(void* ptr)
{
return new QSurfaceFormat(static_cast<QOffscreenSurface*>(ptr)->requestedFormat());
}
char QOffscreenSurface_IsValid(void* ptr)
{
return static_cast<QOffscreenSurface*>(ptr)->isValid();
}
void* QOffscreenSurface_MetaObject(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QOffscreenSurface*>(ptr)->metaObject());
}
void* QOffscreenSurface_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::metaObject());
}
void* QOffscreenSurface_NativeHandle(void* ptr)
{
return static_cast<QOffscreenSurface*>(ptr)->nativeHandle();
}
void* QOffscreenSurface___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QOffscreenSurface___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QOffscreenSurface___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QOffscreenSurface___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOffscreenSurface___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOffscreenSurface___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOffscreenSurface___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOffscreenSurface___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOffscreenSurface___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOffscreenSurface___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOffscreenSurface___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOffscreenSurface___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOffscreenSurface___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOffscreenSurface___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOffscreenSurface___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QOffscreenSurface_Event(void* ptr, void* e)
{
return static_cast<QOffscreenSurface*>(ptr)->event(static_cast<QEvent*>(e));
}
char QOffscreenSurface_EventDefault(void* ptr, void* e)
{
return static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::event(static_cast<QEvent*>(e));
}
char QOffscreenSurface_EventFilter(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QOffscreenSurface*>(ptr)->eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QOffscreenSurface*>(ptr)->eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QOffscreenSurface*>(ptr)->eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QOffscreenSurface*>(ptr)->eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QOffscreenSurface*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
char QOffscreenSurface_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QOffscreenSurface_ChildEvent(void* ptr, void* event)
{
static_cast<QOffscreenSurface*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}
void QOffscreenSurface_ChildEventDefault(void* ptr, void* event)
{
static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::childEvent(static_cast<QChildEvent*>(event));
}
void QOffscreenSurface_ConnectNotify(void* ptr, void* sign)
{
static_cast<QOffscreenSurface*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QOffscreenSurface_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QOffscreenSurface_CustomEvent(void* ptr, void* event)
{
static_cast<QOffscreenSurface*>(ptr)->customEvent(static_cast<QEvent*>(event));
}
void QOffscreenSurface_CustomEventDefault(void* ptr, void* event)
{
static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::customEvent(static_cast<QEvent*>(event));
}
void QOffscreenSurface_DeleteLater(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QOffscreenSurface*>(ptr), "deleteLater");
}
void QOffscreenSurface_DeleteLaterDefault(void* ptr)
{
static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::deleteLater();
}
void QOffscreenSurface_DisconnectNotify(void* ptr, void* sign)
{
static_cast<QOffscreenSurface*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QOffscreenSurface_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QOffscreenSurface_TimerEvent(void* ptr, void* event)
{
static_cast<QOffscreenSurface*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}
void QOffscreenSurface_TimerEventDefault(void* ptr, void* event)
{
static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::timerEvent(static_cast<QTimerEvent*>(event));
}
void* QOpenGLBuffer_NewQOpenGLBuffer()
{
return new QOpenGLBuffer();
}
void* QOpenGLBuffer_NewQOpenGLBuffer2(long long ty)
{
return new QOpenGLBuffer(static_cast<QOpenGLBuffer::Type>(ty));
}
void* QOpenGLBuffer_NewQOpenGLBuffer3(void* other)
{
return new QOpenGLBuffer(*static_cast<QOpenGLBuffer*>(other));
}
char QOpenGLBuffer_Bind(void* ptr)
{
return static_cast<QOpenGLBuffer*>(ptr)->bind();
}
char QOpenGLBuffer_Create(void* ptr)
{
return static_cast<QOpenGLBuffer*>(ptr)->create();
}
char QOpenGLBuffer_Read(void* ptr, int offset, void* data, int count)
{
return static_cast<QOpenGLBuffer*>(ptr)->read(offset, data, count);
}
char QOpenGLBuffer_Unmap(void* ptr)
{
return static_cast<QOpenGLBuffer*>(ptr)->unmap();
}
void* QOpenGLBuffer_Map(void* ptr, long long access)
{
return static_cast<QOpenGLBuffer*>(ptr)->map(static_cast<QOpenGLBuffer::Access>(access));
}
void* QOpenGLBuffer_MapRange(void* ptr, int offset, int count, long long access)
{
return static_cast<QOpenGLBuffer*>(ptr)->mapRange(offset, count, static_cast<QOpenGLBuffer::RangeAccessFlag>(access));
}
void QOpenGLBuffer_Allocate(void* ptr, void* data, int count)
{
static_cast<QOpenGLBuffer*>(ptr)->allocate(data, count);
}
void QOpenGLBuffer_Allocate2(void* ptr, int count)
{
static_cast<QOpenGLBuffer*>(ptr)->allocate(count);
}
void QOpenGLBuffer_Destroy(void* ptr)
{
static_cast<QOpenGLBuffer*>(ptr)->destroy();
}
void QOpenGLBuffer_Release(void* ptr)
{
static_cast<QOpenGLBuffer*>(ptr)->release();
}
void QOpenGLBuffer_QOpenGLBuffer_Release2(long long ty)
{
QOpenGLBuffer::release(static_cast<QOpenGLBuffer::Type>(ty));
}
void QOpenGLBuffer_SetUsagePattern(void* ptr, long long value)
{
static_cast<QOpenGLBuffer*>(ptr)->setUsagePattern(static_cast<QOpenGLBuffer::UsagePattern>(value));
}
void QOpenGLBuffer_Write(void* ptr, int offset, void* data, int count)
{
static_cast<QOpenGLBuffer*>(ptr)->write(offset, data, count);
}
void QOpenGLBuffer_DestroyQOpenGLBuffer(void* ptr)
{
static_cast<QOpenGLBuffer*>(ptr)->~QOpenGLBuffer();
}
unsigned int QOpenGLBuffer_BufferId(void* ptr)
{
return static_cast<QOpenGLBuffer*>(ptr)->bufferId();
}
long long QOpenGLBuffer_Type(void* ptr)
{
return static_cast<QOpenGLBuffer*>(ptr)->type();
}
long long QOpenGLBuffer_UsagePattern(void* ptr)
{
return static_cast<QOpenGLBuffer*>(ptr)->usagePattern();
}
char QOpenGLBuffer_IsCreated(void* ptr)
{
return static_cast<QOpenGLBuffer*>(ptr)->isCreated();
}
int QOpenGLBuffer_Size(void* ptr)
{
return static_cast<QOpenGLBuffer*>(ptr)->size();
}
class MyQOpenGLContext: public QOpenGLContext
{
public:
MyQOpenGLContext(QObject *parent = Q_NULLPTR) : QOpenGLContext(parent) {QOpenGLContext_QOpenGLContext_QRegisterMetaType();};
void Signal_AboutToBeDestroyed() { callbackQOpenGLContext_AboutToBeDestroyed(this); };
~MyQOpenGLContext() { callbackQOpenGLContext_DestroyQOpenGLContext(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQOpenGLContext_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQOpenGLContext_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQOpenGLContext_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQOpenGLContext_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQOpenGLContext_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQOpenGLContext_CustomEvent(this, event); };
void deleteLater() { callbackQOpenGLContext_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQOpenGLContext_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQOpenGLContext_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQOpenGLContext_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQOpenGLContext_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQOpenGLContext*)
int QOpenGLContext_QOpenGLContext_QRegisterMetaType(){qRegisterMetaType<QOpenGLContext*>(); return qRegisterMetaType<MyQOpenGLContext*>();}
void* QOpenGLContext_QOpenGLContext_CurrentContext()
{
return QOpenGLContext::currentContext();
}
void* QOpenGLContext_QOpenGLContext_GlobalShareContext()
{
return QOpenGLContext::globalShareContext();
}
void* QOpenGLContext_NewQOpenGLContext(void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLContext(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLContext(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLContext(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLContext(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLContext(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLContext(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLContext(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLContext(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLContext(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLContext(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLContext(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLContext(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLContext(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLContext(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLContext(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLContext(static_cast<QWindow*>(parent));
} else {
return new MyQOpenGLContext(static_cast<QObject*>(parent));
}
}
long long QOpenGLContext_QOpenGLContext_OpenGLModuleType()
{
return QOpenGLContext::openGLModuleType();
}
struct QtGui_PackedString QOpenGLContext_QOpenGLContext_Tr(char* s, char* c, int n)
{
return ({ QByteArray t7cf95d = QOpenGLContext::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t7cf95d.prepend("WHITESPACE").constData()+10), t7cf95d.size()-10 }; });
}
struct QtGui_PackedString QOpenGLContext_QOpenGLContext_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray t677775 = QOpenGLContext::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t677775.prepend("WHITESPACE").constData()+10), t677775.size()-10 }; });
}
char QOpenGLContext_QOpenGLContext_AreSharing(void* first, void* second)
{
return QOpenGLContext::areSharing(static_cast<QOpenGLContext*>(first), static_cast<QOpenGLContext*>(second));
}
char QOpenGLContext_Create(void* ptr)
{
return static_cast<QOpenGLContext*>(ptr)->create();
}
char QOpenGLContext_MakeCurrent(void* ptr, void* surface)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(surface))) {
return static_cast<QOpenGLContext*>(ptr)->makeCurrent(static_cast<QOffscreenSurface*>(surface));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(surface))) {
return static_cast<QOpenGLContext*>(ptr)->makeCurrent(static_cast<QPaintDeviceWindow*>(surface));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(surface))) {
return static_cast<QOpenGLContext*>(ptr)->makeCurrent(static_cast<QWindow*>(surface));
} else {
return static_cast<QOpenGLContext*>(ptr)->makeCurrent(static_cast<QSurface*>(surface));
}
}
char QOpenGLContext_QOpenGLContext_SupportsThreadedOpenGL()
{
return QOpenGLContext::supportsThreadedOpenGL();
}
void* QOpenGLContext_QOpenGLContext_OpenGLModuleHandle()
{
return QOpenGLContext::openGLModuleHandle();
}
void QOpenGLContext_ConnectAboutToBeDestroyed(void* ptr)
{
QObject::connect(static_cast<QOpenGLContext*>(ptr), static_cast<void (QOpenGLContext::*)()>(&QOpenGLContext::aboutToBeDestroyed), static_cast<MyQOpenGLContext*>(ptr), static_cast<void (MyQOpenGLContext::*)()>(&MyQOpenGLContext::Signal_AboutToBeDestroyed));
}
void QOpenGLContext_DisconnectAboutToBeDestroyed(void* ptr)
{
QObject::disconnect(static_cast<QOpenGLContext*>(ptr), static_cast<void (QOpenGLContext::*)()>(&QOpenGLContext::aboutToBeDestroyed), static_cast<MyQOpenGLContext*>(ptr), static_cast<void (MyQOpenGLContext::*)()>(&MyQOpenGLContext::Signal_AboutToBeDestroyed));
}
void QOpenGLContext_AboutToBeDestroyed(void* ptr)
{
static_cast<QOpenGLContext*>(ptr)->aboutToBeDestroyed();
}
void QOpenGLContext_DoneCurrent(void* ptr)
{
static_cast<QOpenGLContext*>(ptr)->doneCurrent();
}
void QOpenGLContext_SetFormat(void* ptr, void* format)
{
static_cast<QOpenGLContext*>(ptr)->setFormat(*static_cast<QSurfaceFormat*>(format));
}
void QOpenGLContext_SetNativeHandle(void* ptr, void* handle)
{
static_cast<QOpenGLContext*>(ptr)->setNativeHandle(*static_cast<QVariant*>(handle));
}
void QOpenGLContext_SetScreen(void* ptr, void* screen)
{
static_cast<QOpenGLContext*>(ptr)->setScreen(static_cast<QScreen*>(screen));
}
void QOpenGLContext_SetShareContext(void* ptr, void* shareContext)
{
static_cast<QOpenGLContext*>(ptr)->setShareContext(static_cast<QOpenGLContext*>(shareContext));
}
void QOpenGLContext_SwapBuffers(void* ptr, void* surface)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(surface))) {
static_cast<QOpenGLContext*>(ptr)->swapBuffers(static_cast<QOffscreenSurface*>(surface));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(surface))) {
static_cast<QOpenGLContext*>(ptr)->swapBuffers(static_cast<QPaintDeviceWindow*>(surface));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(surface))) {
static_cast<QOpenGLContext*>(ptr)->swapBuffers(static_cast<QWindow*>(surface));
} else {
static_cast<QOpenGLContext*>(ptr)->swapBuffers(static_cast<QSurface*>(surface));
}
}
void QOpenGLContext_DestroyQOpenGLContext(void* ptr)
{
static_cast<QOpenGLContext*>(ptr)->~QOpenGLContext();
}
void QOpenGLContext_DestroyQOpenGLContextDefault(void* ptr)
{
Q_UNUSED(ptr);
}
unsigned int QOpenGLContext_DefaultFramebufferObject(void* ptr)
{
return static_cast<QOpenGLContext*>(ptr)->defaultFramebufferObject();
}
void* QOpenGLContext_VersionFunctions(void* ptr, void* versionProfile)
{
return static_cast<QOpenGLContext*>(ptr)->versionFunctions(*static_cast<QOpenGLVersionProfile*>(versionProfile));
}
void* QOpenGLContext_ShareContext(void* ptr)
{
return static_cast<QOpenGLContext*>(ptr)->shareContext();
}
void* QOpenGLContext_ShareGroup(void* ptr)
{
return static_cast<QOpenGLContext*>(ptr)->shareGroup();
}
void* QOpenGLContext_ExtraFunctions(void* ptr)
{
return static_cast<QOpenGLContext*>(ptr)->extraFunctions();
}
void* QOpenGLContext_Functions(void* ptr)
{
return static_cast<QOpenGLContext*>(ptr)->functions();
}
void* QOpenGLContext_Screen(void* ptr)
{
return static_cast<QOpenGLContext*>(ptr)->screen();
}
void* QOpenGLContext_Surface(void* ptr)
{
return static_cast<QOpenGLContext*>(ptr)->surface();
}
void* QOpenGLContext_Format(void* ptr)
{
return new QSurfaceFormat(static_cast<QOpenGLContext*>(ptr)->format());
}
void* QOpenGLContext_NativeHandle(void* ptr)
{
return new QVariant(static_cast<QOpenGLContext*>(ptr)->nativeHandle());
}
char QOpenGLContext_HasExtension(void* ptr, void* extension)
{
return static_cast<QOpenGLContext*>(ptr)->hasExtension(*static_cast<QByteArray*>(extension));
}
char QOpenGLContext_IsOpenGLES(void* ptr)
{
return static_cast<QOpenGLContext*>(ptr)->isOpenGLES();
}
char QOpenGLContext_IsValid(void* ptr)
{
return static_cast<QOpenGLContext*>(ptr)->isValid();
}
void* QOpenGLContext_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QOpenGLContext*>(ptr)->QOpenGLContext::metaObject());
}
void* QOpenGLContext___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QOpenGLContext___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QOpenGLContext___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QOpenGLContext___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLContext___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLContext___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOpenGLContext___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLContext___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLContext___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOpenGLContext___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLContext___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLContext___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOpenGLContext___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLContext___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLContext___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QOpenGLContext_EventDefault(void* ptr, void* e)
{
return static_cast<QOpenGLContext*>(ptr)->QOpenGLContext::event(static_cast<QEvent*>(e));
}
char QOpenGLContext_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLContext*>(ptr)->QOpenGLContext::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLContext*>(ptr)->QOpenGLContext::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLContext*>(ptr)->QOpenGLContext::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLContext*>(ptr)->QOpenGLContext::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QOpenGLContext*>(ptr)->QOpenGLContext::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QOpenGLContext_ChildEventDefault(void* ptr, void* event)
{
static_cast<QOpenGLContext*>(ptr)->QOpenGLContext::childEvent(static_cast<QChildEvent*>(event));
}
void QOpenGLContext_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QOpenGLContext*>(ptr)->QOpenGLContext::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QOpenGLContext_CustomEventDefault(void* ptr, void* event)
{
static_cast<QOpenGLContext*>(ptr)->QOpenGLContext::customEvent(static_cast<QEvent*>(event));
}
void QOpenGLContext_DeleteLaterDefault(void* ptr)
{
static_cast<QOpenGLContext*>(ptr)->QOpenGLContext::deleteLater();
}
void QOpenGLContext_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QOpenGLContext*>(ptr)->QOpenGLContext::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QOpenGLContext_TimerEventDefault(void* ptr, void* event)
{
static_cast<QOpenGLContext*>(ptr)->QOpenGLContext::timerEvent(static_cast<QTimerEvent*>(event));
}
class MyQOpenGLContextGroup: public QOpenGLContextGroup
{
public:
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQOpenGLContextGroup_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQOpenGLContextGroup_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQOpenGLContextGroup_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQOpenGLContextGroup_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQOpenGLContextGroup_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQOpenGLContextGroup_CustomEvent(this, event); };
void deleteLater() { callbackQOpenGLContextGroup_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQOpenGLContextGroup_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQOpenGLContextGroup_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQOpenGLContextGroup_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQOpenGLContextGroup_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQOpenGLContextGroup*)
int QOpenGLContextGroup_QOpenGLContextGroup_QRegisterMetaType(){qRegisterMetaType<QOpenGLContextGroup*>(); return qRegisterMetaType<MyQOpenGLContextGroup*>();}
void* QOpenGLContextGroup_QOpenGLContextGroup_CurrentContextGroup()
{
return QOpenGLContextGroup::currentContextGroup();
}
struct QtGui_PackedString QOpenGLContextGroup_QOpenGLContextGroup_Tr(char* s, char* c, int n)
{
return ({ QByteArray t572cea = QOpenGLContextGroup::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t572cea.prepend("WHITESPACE").constData()+10), t572cea.size()-10 }; });
}
struct QtGui_PackedString QOpenGLContextGroup_QOpenGLContextGroup_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray tf747b1 = QOpenGLContextGroup::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(tf747b1.prepend("WHITESPACE").constData()+10), tf747b1.size()-10 }; });
}
struct QtGui_PackedList QOpenGLContextGroup_Shares(void* ptr)
{
return ({ QList<QOpenGLContext *>* tmpValue = new QList<QOpenGLContext *>(static_cast<QOpenGLContextGroup*>(ptr)->shares()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QOpenGLContextGroup_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QOpenGLContextGroup*>(ptr)->QOpenGLContextGroup::metaObject());
}
void* QOpenGLContextGroup___shares_atList(void* ptr, int i)
{
return ({QOpenGLContext * tmp = static_cast<QList<QOpenGLContext *>*>(ptr)->at(i); if (i == static_cast<QList<QOpenGLContext *>*>(ptr)->size()-1) { static_cast<QList<QOpenGLContext *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLContextGroup___shares_setList(void* ptr, void* i)
{
static_cast<QList<QOpenGLContext *>*>(ptr)->append(static_cast<QOpenGLContext*>(i));
}
void* QOpenGLContextGroup___shares_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QOpenGLContext *>();
}
void* QOpenGLContextGroup___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QOpenGLContextGroup___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QOpenGLContextGroup___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QOpenGLContextGroup___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLContextGroup___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLContextGroup___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOpenGLContextGroup___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLContextGroup___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLContextGroup___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOpenGLContextGroup___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLContextGroup___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLContextGroup___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOpenGLContextGroup___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLContextGroup___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLContextGroup___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QOpenGLContextGroup_EventDefault(void* ptr, void* e)
{
return static_cast<QOpenGLContextGroup*>(ptr)->QOpenGLContextGroup::event(static_cast<QEvent*>(e));
}
char QOpenGLContextGroup_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLContextGroup*>(ptr)->QOpenGLContextGroup::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLContextGroup*>(ptr)->QOpenGLContextGroup::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLContextGroup*>(ptr)->QOpenGLContextGroup::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLContextGroup*>(ptr)->QOpenGLContextGroup::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QOpenGLContextGroup*>(ptr)->QOpenGLContextGroup::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QOpenGLContextGroup_ChildEventDefault(void* ptr, void* event)
{
static_cast<QOpenGLContextGroup*>(ptr)->QOpenGLContextGroup::childEvent(static_cast<QChildEvent*>(event));
}
void QOpenGLContextGroup_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QOpenGLContextGroup*>(ptr)->QOpenGLContextGroup::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QOpenGLContextGroup_CustomEventDefault(void* ptr, void* event)
{
static_cast<QOpenGLContextGroup*>(ptr)->QOpenGLContextGroup::customEvent(static_cast<QEvent*>(event));
}
void QOpenGLContextGroup_DeleteLaterDefault(void* ptr)
{
static_cast<QOpenGLContextGroup*>(ptr)->QOpenGLContextGroup::deleteLater();
}
void QOpenGLContextGroup_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QOpenGLContextGroup*>(ptr)->QOpenGLContextGroup::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QOpenGLContextGroup_TimerEventDefault(void* ptr, void* event)
{
static_cast<QOpenGLContextGroup*>(ptr)->QOpenGLContextGroup::timerEvent(static_cast<QTimerEvent*>(event));
}
class MyQOpenGLDebugLogger: public QOpenGLDebugLogger
{
public:
MyQOpenGLDebugLogger(QObject *parent = Q_NULLPTR) : QOpenGLDebugLogger(parent) {QOpenGLDebugLogger_QOpenGLDebugLogger_QRegisterMetaType();};
void logMessage(const QOpenGLDebugMessage & debugMessage) { callbackQOpenGLDebugLogger_LogMessage(this, const_cast<QOpenGLDebugMessage*>(&debugMessage)); };
void Signal_MessageLogged(const QOpenGLDebugMessage & debugMessage) { callbackQOpenGLDebugLogger_MessageLogged(this, const_cast<QOpenGLDebugMessage*>(&debugMessage)); };
void startLogging(QOpenGLDebugLogger::LoggingMode loggingMode) { callbackQOpenGLDebugLogger_StartLogging(this, loggingMode); };
void stopLogging() { callbackQOpenGLDebugLogger_StopLogging(this); };
~MyQOpenGLDebugLogger() { callbackQOpenGLDebugLogger_DestroyQOpenGLDebugLogger(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQOpenGLDebugLogger_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQOpenGLDebugLogger_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQOpenGLDebugLogger_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQOpenGLDebugLogger_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQOpenGLDebugLogger_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQOpenGLDebugLogger_CustomEvent(this, event); };
void deleteLater() { callbackQOpenGLDebugLogger_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQOpenGLDebugLogger_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQOpenGLDebugLogger_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQOpenGLDebugLogger_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQOpenGLDebugLogger_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQOpenGLDebugLogger*)
int QOpenGLDebugLogger_QOpenGLDebugLogger_QRegisterMetaType(){qRegisterMetaType<QOpenGLDebugLogger*>(); return qRegisterMetaType<MyQOpenGLDebugLogger*>();}
void* QOpenGLDebugLogger_NewQOpenGLDebugLogger(void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLDebugLogger(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLDebugLogger(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLDebugLogger(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLDebugLogger(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLDebugLogger(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLDebugLogger(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLDebugLogger(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLDebugLogger(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLDebugLogger(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLDebugLogger(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLDebugLogger(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLDebugLogger(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLDebugLogger(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLDebugLogger(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLDebugLogger(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLDebugLogger(static_cast<QWindow*>(parent));
} else {
return new MyQOpenGLDebugLogger(static_cast<QObject*>(parent));
}
}
struct QtGui_PackedString QOpenGLDebugLogger_QOpenGLDebugLogger_Tr(char* s, char* c, int n)
{
return ({ QByteArray t098dc5 = QOpenGLDebugLogger::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t098dc5.prepend("WHITESPACE").constData()+10), t098dc5.size()-10 }; });
}
struct QtGui_PackedString QOpenGLDebugLogger_QOpenGLDebugLogger_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray t584e57 = QOpenGLDebugLogger::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t584e57.prepend("WHITESPACE").constData()+10), t584e57.size()-10 }; });
}
char QOpenGLDebugLogger_Initialize(void* ptr)
{
return static_cast<QOpenGLDebugLogger*>(ptr)->initialize();
}
void QOpenGLDebugLogger_DisableMessages(void* ptr, long long sources, long long types, long long severities)
{
static_cast<QOpenGLDebugLogger*>(ptr)->disableMessages(static_cast<QOpenGLDebugMessage::Source>(sources), static_cast<QOpenGLDebugMessage::Type>(types), static_cast<QOpenGLDebugMessage::Severity>(severities));
}
void QOpenGLDebugLogger_DisableMessages2(void* ptr, void* ids, long long sources, long long types)
{
static_cast<QOpenGLDebugLogger*>(ptr)->disableMessages(*static_cast<QVector<GLuint>*>(ids), static_cast<QOpenGLDebugMessage::Source>(sources), static_cast<QOpenGLDebugMessage::Type>(types));
}
void QOpenGLDebugLogger_EnableMessages(void* ptr, long long sources, long long types, long long severities)
{
static_cast<QOpenGLDebugLogger*>(ptr)->enableMessages(static_cast<QOpenGLDebugMessage::Source>(sources), static_cast<QOpenGLDebugMessage::Type>(types), static_cast<QOpenGLDebugMessage::Severity>(severities));
}
void QOpenGLDebugLogger_EnableMessages2(void* ptr, void* ids, long long sources, long long types)
{
static_cast<QOpenGLDebugLogger*>(ptr)->enableMessages(*static_cast<QVector<GLuint>*>(ids), static_cast<QOpenGLDebugMessage::Source>(sources), static_cast<QOpenGLDebugMessage::Type>(types));
}
void QOpenGLDebugLogger_LogMessage(void* ptr, void* debugMessage)
{
QMetaObject::invokeMethod(static_cast<QOpenGLDebugLogger*>(ptr), "logMessage", Q_ARG(const QOpenGLDebugMessage, *static_cast<QOpenGLDebugMessage*>(debugMessage)));
}
void QOpenGLDebugLogger_LogMessageDefault(void* ptr, void* debugMessage)
{
static_cast<QOpenGLDebugLogger*>(ptr)->QOpenGLDebugLogger::logMessage(*static_cast<QOpenGLDebugMessage*>(debugMessage));
}
void QOpenGLDebugLogger_ConnectMessageLogged(void* ptr)
{
QObject::connect(static_cast<QOpenGLDebugLogger*>(ptr), static_cast<void (QOpenGLDebugLogger::*)(const QOpenGLDebugMessage &)>(&QOpenGLDebugLogger::messageLogged), static_cast<MyQOpenGLDebugLogger*>(ptr), static_cast<void (MyQOpenGLDebugLogger::*)(const QOpenGLDebugMessage &)>(&MyQOpenGLDebugLogger::Signal_MessageLogged));
}
void QOpenGLDebugLogger_DisconnectMessageLogged(void* ptr)
{
QObject::disconnect(static_cast<QOpenGLDebugLogger*>(ptr), static_cast<void (QOpenGLDebugLogger::*)(const QOpenGLDebugMessage &)>(&QOpenGLDebugLogger::messageLogged), static_cast<MyQOpenGLDebugLogger*>(ptr), static_cast<void (MyQOpenGLDebugLogger::*)(const QOpenGLDebugMessage &)>(&MyQOpenGLDebugLogger::Signal_MessageLogged));
}
void QOpenGLDebugLogger_MessageLogged(void* ptr, void* debugMessage)
{
static_cast<QOpenGLDebugLogger*>(ptr)->messageLogged(*static_cast<QOpenGLDebugMessage*>(debugMessage));
}
void QOpenGLDebugLogger_PopGroup(void* ptr)
{
static_cast<QOpenGLDebugLogger*>(ptr)->popGroup();
}
void QOpenGLDebugLogger_PushGroup(void* ptr, struct QtGui_PackedString name, unsigned int id, long long source)
{
static_cast<QOpenGLDebugLogger*>(ptr)->pushGroup(QString::fromUtf8(name.data, name.len), id, static_cast<QOpenGLDebugMessage::Source>(source));
}
void QOpenGLDebugLogger_StartLogging(void* ptr, long long loggingMode)
{
qRegisterMetaType<QOpenGLDebugLogger::LoggingMode>();
QMetaObject::invokeMethod(static_cast<QOpenGLDebugLogger*>(ptr), "startLogging", Q_ARG(QOpenGLDebugLogger::LoggingMode, static_cast<QOpenGLDebugLogger::LoggingMode>(loggingMode)));
}
void QOpenGLDebugLogger_StartLoggingDefault(void* ptr, long long loggingMode)
{
static_cast<QOpenGLDebugLogger*>(ptr)->QOpenGLDebugLogger::startLogging(static_cast<QOpenGLDebugLogger::LoggingMode>(loggingMode));
}
void QOpenGLDebugLogger_StopLogging(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QOpenGLDebugLogger*>(ptr), "stopLogging");
}
void QOpenGLDebugLogger_StopLoggingDefault(void* ptr)
{
static_cast<QOpenGLDebugLogger*>(ptr)->QOpenGLDebugLogger::stopLogging();
}
void QOpenGLDebugLogger_DestroyQOpenGLDebugLogger(void* ptr)
{
static_cast<QOpenGLDebugLogger*>(ptr)->~QOpenGLDebugLogger();
}
void QOpenGLDebugLogger_DestroyQOpenGLDebugLoggerDefault(void* ptr)
{
Q_UNUSED(ptr);
}
struct QtGui_PackedList QOpenGLDebugLogger_LoggedMessages(void* ptr)
{
return ({ QList<QOpenGLDebugMessage>* tmpValue = new QList<QOpenGLDebugMessage>(static_cast<QOpenGLDebugLogger*>(ptr)->loggedMessages()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
long long QOpenGLDebugLogger_LoggingMode(void* ptr)
{
return static_cast<QOpenGLDebugLogger*>(ptr)->loggingMode();
}
char QOpenGLDebugLogger_IsLogging(void* ptr)
{
return static_cast<QOpenGLDebugLogger*>(ptr)->isLogging();
}
void* QOpenGLDebugLogger_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QOpenGLDebugLogger*>(ptr)->QOpenGLDebugLogger::metaObject());
}
long long QOpenGLDebugLogger_MaximumMessageLength(void* ptr)
{
return static_cast<QOpenGLDebugLogger*>(ptr)->maximumMessageLength();
}
unsigned int QOpenGLDebugLogger___disableMessages_ids_atList2(void* ptr, int i)
{
return ({GLuint tmp = static_cast<QVector<GLuint>*>(ptr)->at(i); if (i == static_cast<QVector<GLuint>*>(ptr)->size()-1) { static_cast<QVector<GLuint>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QOpenGLDebugLogger___disableMessages_ids_setList2(void* ptr, unsigned int i)
{
static_cast<QVector<GLuint>*>(ptr)->append(i);
}
void* QOpenGLDebugLogger___disableMessages_ids_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<GLuint>();
}
unsigned int QOpenGLDebugLogger___enableMessages_ids_atList2(void* ptr, int i)
{
return ({GLuint tmp = static_cast<QVector<GLuint>*>(ptr)->at(i); if (i == static_cast<QVector<GLuint>*>(ptr)->size()-1) { static_cast<QVector<GLuint>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QOpenGLDebugLogger___enableMessages_ids_setList2(void* ptr, unsigned int i)
{
static_cast<QVector<GLuint>*>(ptr)->append(i);
}
void* QOpenGLDebugLogger___enableMessages_ids_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<GLuint>();
}
void* QOpenGLDebugLogger___loggedMessages_atList(void* ptr, int i)
{
return new QOpenGLDebugMessage(({QOpenGLDebugMessage tmp = static_cast<QList<QOpenGLDebugMessage>*>(ptr)->at(i); if (i == static_cast<QList<QOpenGLDebugMessage>*>(ptr)->size()-1) { static_cast<QList<QOpenGLDebugMessage>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QOpenGLDebugLogger___loggedMessages_setList(void* ptr, void* i)
{
static_cast<QList<QOpenGLDebugMessage>*>(ptr)->append(*static_cast<QOpenGLDebugMessage*>(i));
}
void* QOpenGLDebugLogger___loggedMessages_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QOpenGLDebugMessage>();
}
void* QOpenGLDebugLogger___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QOpenGLDebugLogger___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QOpenGLDebugLogger___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QOpenGLDebugLogger___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLDebugLogger___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLDebugLogger___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOpenGLDebugLogger___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLDebugLogger___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLDebugLogger___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOpenGLDebugLogger___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLDebugLogger___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLDebugLogger___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOpenGLDebugLogger___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLDebugLogger___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLDebugLogger___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QOpenGLDebugLogger_EventDefault(void* ptr, void* e)
{
return static_cast<QOpenGLDebugLogger*>(ptr)->QOpenGLDebugLogger::event(static_cast<QEvent*>(e));
}
char QOpenGLDebugLogger_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLDebugLogger*>(ptr)->QOpenGLDebugLogger::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLDebugLogger*>(ptr)->QOpenGLDebugLogger::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLDebugLogger*>(ptr)->QOpenGLDebugLogger::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLDebugLogger*>(ptr)->QOpenGLDebugLogger::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QOpenGLDebugLogger*>(ptr)->QOpenGLDebugLogger::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QOpenGLDebugLogger_ChildEventDefault(void* ptr, void* event)
{
static_cast<QOpenGLDebugLogger*>(ptr)->QOpenGLDebugLogger::childEvent(static_cast<QChildEvent*>(event));
}
void QOpenGLDebugLogger_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QOpenGLDebugLogger*>(ptr)->QOpenGLDebugLogger::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QOpenGLDebugLogger_CustomEventDefault(void* ptr, void* event)
{
static_cast<QOpenGLDebugLogger*>(ptr)->QOpenGLDebugLogger::customEvent(static_cast<QEvent*>(event));
}
void QOpenGLDebugLogger_DeleteLaterDefault(void* ptr)
{
static_cast<QOpenGLDebugLogger*>(ptr)->QOpenGLDebugLogger::deleteLater();
}
void QOpenGLDebugLogger_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QOpenGLDebugLogger*>(ptr)->QOpenGLDebugLogger::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QOpenGLDebugLogger_TimerEventDefault(void* ptr, void* event)
{
static_cast<QOpenGLDebugLogger*>(ptr)->QOpenGLDebugLogger::timerEvent(static_cast<QTimerEvent*>(event));
}
void* QOpenGLDebugMessage_QOpenGLDebugMessage_CreateApplicationMessage(struct QtGui_PackedString text, unsigned int id, long long severity, long long ty)
{
return new QOpenGLDebugMessage(QOpenGLDebugMessage::createApplicationMessage(QString::fromUtf8(text.data, text.len), id, static_cast<QOpenGLDebugMessage::Severity>(severity), static_cast<QOpenGLDebugMessage::Type>(ty)));
}
void* QOpenGLDebugMessage_QOpenGLDebugMessage_CreateThirdPartyMessage(struct QtGui_PackedString text, unsigned int id, long long severity, long long ty)
{
return new QOpenGLDebugMessage(QOpenGLDebugMessage::createThirdPartyMessage(QString::fromUtf8(text.data, text.len), id, static_cast<QOpenGLDebugMessage::Severity>(severity), static_cast<QOpenGLDebugMessage::Type>(ty)));
}
void* QOpenGLDebugMessage_NewQOpenGLDebugMessage()
{
return new QOpenGLDebugMessage();
}
void* QOpenGLDebugMessage_NewQOpenGLDebugMessage2(void* debugMessage)
{
return new QOpenGLDebugMessage(*static_cast<QOpenGLDebugMessage*>(debugMessage));
}
void QOpenGLDebugMessage_Swap(void* ptr, void* debugMessage)
{
static_cast<QOpenGLDebugMessage*>(ptr)->swap(*static_cast<QOpenGLDebugMessage*>(debugMessage));
}
void QOpenGLDebugMessage_DestroyQOpenGLDebugMessage(void* ptr)
{
static_cast<QOpenGLDebugMessage*>(ptr)->~QOpenGLDebugMessage();
}
unsigned int QOpenGLDebugMessage_Id(void* ptr)
{
return static_cast<QOpenGLDebugMessage*>(ptr)->id();
}
long long QOpenGLDebugMessage_Severity(void* ptr)
{
return static_cast<QOpenGLDebugMessage*>(ptr)->severity();
}
long long QOpenGLDebugMessage_Source(void* ptr)
{
return static_cast<QOpenGLDebugMessage*>(ptr)->source();
}
long long QOpenGLDebugMessage_Type(void* ptr)
{
return static_cast<QOpenGLDebugMessage*>(ptr)->type();
}
struct QtGui_PackedString QOpenGLDebugMessage_Message(void* ptr)
{
return ({ QByteArray t195421 = static_cast<QOpenGLDebugMessage*>(ptr)->message().toUtf8(); QtGui_PackedString { const_cast<char*>(t195421.prepend("WHITESPACE").constData()+10), t195421.size()-10 }; });
}
char QOpenGLExtraFunctions_GlIsEnabledi(void* ptr, unsigned int target, unsigned int index)
{
return static_cast<QOpenGLExtraFunctions*>(ptr)->glIsEnabledi(target, index);
}
char QOpenGLExtraFunctions_GlIsProgramPipeline(void* ptr, unsigned int pipeline)
{
return static_cast<QOpenGLExtraFunctions*>(ptr)->glIsProgramPipeline(pipeline);
}
char QOpenGLExtraFunctions_GlIsQuery(void* ptr, unsigned int id)
{
return static_cast<QOpenGLExtraFunctions*>(ptr)->glIsQuery(id);
}
char QOpenGLExtraFunctions_GlIsSampler(void* ptr, unsigned int sampler)
{
return static_cast<QOpenGLExtraFunctions*>(ptr)->glIsSampler(sampler);
}
char QOpenGLExtraFunctions_GlIsTransformFeedback(void* ptr, unsigned int id)
{
return static_cast<QOpenGLExtraFunctions*>(ptr)->glIsTransformFeedback(id);
}
char QOpenGLExtraFunctions_GlIsVertexArray(void* ptr, unsigned int array)
{
return static_cast<QOpenGLExtraFunctions*>(ptr)->glIsVertexArray(array);
}
char QOpenGLExtraFunctions_GlUnmapBuffer(void* ptr, unsigned int target)
{
return static_cast<QOpenGLExtraFunctions*>(ptr)->glUnmapBuffer(target);
}
unsigned int QOpenGLExtraFunctions_GlGetGraphicsResetStatus(void* ptr)
{
return static_cast<QOpenGLExtraFunctions*>(ptr)->glGetGraphicsResetStatus();
}
void* QOpenGLExtraFunctions_NewQOpenGLExtraFunctions()
{
return new QOpenGLExtraFunctions();
}
void* QOpenGLExtraFunctions_NewQOpenGLExtraFunctions2(void* context)
{
return new QOpenGLExtraFunctions(static_cast<QOpenGLContext*>(context));
}
struct QtGui_PackedString QOpenGLExtraFunctions_GlGetStringi(void* ptr, unsigned int name, unsigned int index)
{
return ({ char* t7c422e = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLExtraFunctions*>(ptr)->glGetStringi(name, index)))); QtGui_PackedString { t7c422e, -1 }; });
}
void QOpenGLExtraFunctions_GlActiveShaderProgram(void* ptr, unsigned int pipeline, unsigned int program)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glActiveShaderProgram(pipeline, program);
}
void QOpenGLExtraFunctions_GlBeginQuery(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glBeginQuery(target, id);
}
void QOpenGLExtraFunctions_GlBeginTransformFeedback(void* ptr, unsigned int primitiveMode)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glBeginTransformFeedback(primitiveMode);
}
void QOpenGLExtraFunctions_GlBindBufferBase(void* ptr, unsigned int target, unsigned int index, unsigned int buffer)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glBindBufferBase(target, index, buffer);
}
void QOpenGLExtraFunctions_GlBindImageTexture(void* ptr, unsigned int unit, unsigned int texture, int level, char layered, int layer, unsigned int access, unsigned int format)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glBindImageTexture(unit, texture, level, layered != 0, layer, access, format);
}
void QOpenGLExtraFunctions_GlBindProgramPipeline(void* ptr, unsigned int pipeline)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glBindProgramPipeline(pipeline);
}
void QOpenGLExtraFunctions_GlBindSampler(void* ptr, unsigned int unit, unsigned int sampler)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glBindSampler(unit, sampler);
}
void QOpenGLExtraFunctions_GlBindTransformFeedback(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glBindTransformFeedback(target, id);
}
void QOpenGLExtraFunctions_GlBindVertexArray(void* ptr, unsigned int array)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glBindVertexArray(array);
}
void QOpenGLExtraFunctions_GlBlendBarrier(void* ptr)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glBlendBarrier();
}
void QOpenGLExtraFunctions_GlBlendEquationSeparatei(void* ptr, unsigned int buf, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glBlendEquationSeparatei(buf, modeRGB, modeAlpha);
}
void QOpenGLExtraFunctions_GlBlendEquationi(void* ptr, unsigned int buf, unsigned int mode)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glBlendEquationi(buf, mode);
}
void QOpenGLExtraFunctions_GlBlendFuncSeparatei(void* ptr, unsigned int buf, unsigned int srcRGB, unsigned int dstRGB, unsigned int srcAlpha, unsigned int dstAlpha)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
void QOpenGLExtraFunctions_GlBlendFunci(void* ptr, unsigned int buf, unsigned int src, unsigned int dst)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glBlendFunci(buf, src, dst);
}
void QOpenGLExtraFunctions_GlBlitFramebuffer(void* ptr, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, unsigned int mask, unsigned int filter)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
void QOpenGLExtraFunctions_GlClearBufferfi(void* ptr, unsigned int buffer, int drawbuffer, float depth, int stencil)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glClearBufferfi(buffer, drawbuffer, depth, stencil);
}
void QOpenGLExtraFunctions_GlClearBufferfv(void* ptr, unsigned int buffer, int drawbuffer, float value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glClearBufferfv(buffer, drawbuffer, const_cast<const GLfloat*>(&value));
}
void QOpenGLExtraFunctions_GlClearBufferiv(void* ptr, unsigned int buffer, int drawbuffer, int value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glClearBufferiv(buffer, drawbuffer, const_cast<const GLint*>(&value));
}
void QOpenGLExtraFunctions_GlClearBufferuiv(void* ptr, unsigned int buffer, int drawbuffer, unsigned int value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glClearBufferuiv(buffer, drawbuffer, const_cast<const GLuint*>(&value));
}
void QOpenGLExtraFunctions_GlColorMaski(void* ptr, unsigned int index, char r, char g, char b, char a)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glColorMaski(index, r != 0, g != 0, b != 0, a != 0);
}
void QOpenGLExtraFunctions_GlCompressedTexImage3D(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int depth, int border, int imageSize, void* data)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void QOpenGLExtraFunctions_GlCompressedTexSubImage3D(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLExtraFunctions_GlCopyImageSubData(void* ptr, unsigned int srcName, unsigned int srcTarget, int srcLevel, int srcX, int srcY, int srcZ, unsigned int dstName, unsigned int dstTarget, int dstLevel, int dstX, int dstY, int dstZ, int srcWidth, int srcHeight, int srcDepth)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
}
void QOpenGLExtraFunctions_GlCopyTexSubImage3D(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLExtraFunctions_GlDebugMessageControl(void* ptr, unsigned int source, unsigned int ty, unsigned int severity, int count, unsigned int ids, char enabled)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glDebugMessageControl(source, ty, severity, count, const_cast<const GLuint*>(&ids), enabled != 0);
}
void QOpenGLExtraFunctions_GlDeleteProgramPipelines(void* ptr, int n, unsigned int pipelines)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glDeleteProgramPipelines(n, const_cast<const GLuint*>(&pipelines));
}
void QOpenGLExtraFunctions_GlDeleteQueries(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glDeleteQueries(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLExtraFunctions_GlDeleteSamplers(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glDeleteSamplers(count, const_cast<const GLuint*>(&samplers));
}
void QOpenGLExtraFunctions_GlDeleteTransformFeedbacks(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glDeleteTransformFeedbacks(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLExtraFunctions_GlDeleteVertexArrays(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glDeleteVertexArrays(n, const_cast<const GLuint*>(&arrays));
}
void QOpenGLExtraFunctions_GlDisablei(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glDisablei(target, index);
}
void QOpenGLExtraFunctions_GlDispatchCompute(void* ptr, unsigned int num_groups_x, unsigned int num_groups_y, unsigned int num_groups_z)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
}
void QOpenGLExtraFunctions_GlDrawArraysIndirect(void* ptr, unsigned int mode, void* indirect)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glDrawArraysIndirect(mode, indirect);
}
void QOpenGLExtraFunctions_GlDrawArraysInstanced(void* ptr, unsigned int mode, int first, int count, int instancecount)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glDrawArraysInstanced(mode, first, count, instancecount);
}
void QOpenGLExtraFunctions_GlDrawBuffers(void* ptr, int n, unsigned int bufs)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glDrawBuffers(n, const_cast<const GLenum*>(&bufs));
}
void QOpenGLExtraFunctions_GlDrawElementsBaseVertex(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glDrawElementsBaseVertex(mode, count, ty, indices, basevertex);
}
void QOpenGLExtraFunctions_GlDrawElementsIndirect(void* ptr, unsigned int mode, unsigned int ty, void* indirect)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glDrawElementsIndirect(mode, ty, indirect);
}
void QOpenGLExtraFunctions_GlDrawElementsInstanced(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glDrawElementsInstanced(mode, count, ty, indices, instancecount);
}
void QOpenGLExtraFunctions_GlDrawElementsInstancedBaseVertex(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glDrawElementsInstancedBaseVertex(mode, count, ty, indices, instancecount, basevertex);
}
void QOpenGLExtraFunctions_GlDrawRangeElements(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLExtraFunctions_GlDrawRangeElementsBaseVertex(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glDrawRangeElementsBaseVertex(mode, start, end, count, ty, indices, basevertex);
}
void QOpenGLExtraFunctions_GlEnablei(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glEnablei(target, index);
}
void QOpenGLExtraFunctions_GlEndQuery(void* ptr, unsigned int target)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glEndQuery(target);
}
void QOpenGLExtraFunctions_GlEndTransformFeedback(void* ptr)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glEndTransformFeedback();
}
void QOpenGLExtraFunctions_GlFramebufferParameteri(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glFramebufferParameteri(target, pname, param);
}
void QOpenGLExtraFunctions_GlFramebufferTexture(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glFramebufferTexture(target, attachment, texture, level);
}
void QOpenGLExtraFunctions_GlFramebufferTextureLayer(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level, int layer)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glFramebufferTextureLayer(target, attachment, texture, level, layer);
}
void QOpenGLExtraFunctions_GlGenProgramPipelines(void* ptr, int n, unsigned int pipelines)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGenProgramPipelines(n, &pipelines);
}
void QOpenGLExtraFunctions_GlGenQueries(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGenQueries(n, &ids);
}
void QOpenGLExtraFunctions_GlGenSamplers(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGenSamplers(count, &samplers);
}
void QOpenGLExtraFunctions_GlGenTransformFeedbacks(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGenTransformFeedbacks(n, &ids);
}
void QOpenGLExtraFunctions_GlGenVertexArrays(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGenVertexArrays(n, &arrays);
}
void QOpenGLExtraFunctions_GlGetActiveUniformBlockiv(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int pname, int params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, &params);
}
void QOpenGLExtraFunctions_GlGetActiveUniformsiv(void* ptr, unsigned int program, int uniformCount, unsigned int uniformIndices, unsigned int pname, int params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetActiveUniformsiv(program, uniformCount, const_cast<const GLuint*>(&uniformIndices), pname, &params);
}
void QOpenGLExtraFunctions_GlGetBooleani_v(void* ptr, unsigned int target, unsigned int index, char data)
{
Q_UNUSED(data);
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetBooleani_v(target, index, NULL);
}
void QOpenGLExtraFunctions_GlGetBufferPointerv(void* ptr, unsigned int target, unsigned int pname, void* params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetBufferPointerv(target, pname, &params);
}
void QOpenGLExtraFunctions_GlGetFramebufferParameteriv(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetFramebufferParameteriv(target, pname, &params);
}
void QOpenGLExtraFunctions_GlGetIntegeri_v(void* ptr, unsigned int target, unsigned int index, int data)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetIntegeri_v(target, index, &data);
}
void QOpenGLExtraFunctions_GlGetInternalformativ(void* ptr, unsigned int target, unsigned int internalformat, unsigned int pname, int bufSize, int params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetInternalformativ(target, internalformat, pname, bufSize, &params);
}
void QOpenGLExtraFunctions_GlGetMultisamplefv(void* ptr, unsigned int pname, unsigned int index, float val)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetMultisamplefv(pname, index, &val);
}
void QOpenGLExtraFunctions_GlGetPointerv(void* ptr, unsigned int pname, void* params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetPointerv(pname, &params);
}
void QOpenGLExtraFunctions_GlGetProgramBinary(void* ptr, unsigned int program, int bufSize, int length, unsigned int binaryFormat, void* binary)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetProgramBinary(program, bufSize, &length, &binaryFormat, binary);
}
void QOpenGLExtraFunctions_GlGetProgramInterfaceiv(void* ptr, unsigned int program, unsigned int programInterface, unsigned int pname, int params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetProgramInterfaceiv(program, programInterface, pname, &params);
}
void QOpenGLExtraFunctions_GlGetProgramPipelineiv(void* ptr, unsigned int pipeline, unsigned int pname, int params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetProgramPipelineiv(pipeline, pname, &params);
}
void QOpenGLExtraFunctions_GlGetProgramResourceiv(void* ptr, unsigned int program, unsigned int programInterface, unsigned int index, int propCount, unsigned int props, int bufSize, int length, int params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetProgramResourceiv(program, programInterface, index, propCount, const_cast<const GLenum*>(&props), bufSize, &length, &params);
}
void QOpenGLExtraFunctions_GlGetQueryObjectuiv(void* ptr, unsigned int id, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetQueryObjectuiv(id, pname, &params);
}
void QOpenGLExtraFunctions_GlGetQueryiv(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetQueryiv(target, pname, &params);
}
void QOpenGLExtraFunctions_GlGetSamplerParameterIiv(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetSamplerParameterIiv(sampler, pname, &params);
}
void QOpenGLExtraFunctions_GlGetSamplerParameterIuiv(void* ptr, unsigned int sampler, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetSamplerParameterIuiv(sampler, pname, &params);
}
void QOpenGLExtraFunctions_GlGetSamplerParameterfv(void* ptr, unsigned int sampler, unsigned int pname, float params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetSamplerParameterfv(sampler, pname, &params);
}
void QOpenGLExtraFunctions_GlGetSamplerParameteriv(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetSamplerParameteriv(sampler, pname, &params);
}
void QOpenGLExtraFunctions_GlGetTexLevelParameterfv(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLExtraFunctions_GlGetTexLevelParameteriv(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLExtraFunctions_GlGetTexParameterIiv(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetTexParameterIiv(target, pname, &params);
}
void QOpenGLExtraFunctions_GlGetTexParameterIuiv(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetTexParameterIuiv(target, pname, &params);
}
void QOpenGLExtraFunctions_GlGetUniformuiv(void* ptr, unsigned int program, int location, unsigned int params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetUniformuiv(program, location, &params);
}
void QOpenGLExtraFunctions_GlGetVertexAttribIiv(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetVertexAttribIiv(index, pname, &params);
}
void QOpenGLExtraFunctions_GlGetVertexAttribIuiv(void* ptr, unsigned int index, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetVertexAttribIuiv(index, pname, &params);
}
void QOpenGLExtraFunctions_GlGetnUniformfv(void* ptr, unsigned int program, int location, int bufSize, float params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetnUniformfv(program, location, bufSize, &params);
}
void QOpenGLExtraFunctions_GlGetnUniformiv(void* ptr, unsigned int program, int location, int bufSize, int params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetnUniformiv(program, location, bufSize, &params);
}
void QOpenGLExtraFunctions_GlGetnUniformuiv(void* ptr, unsigned int program, int location, int bufSize, unsigned int params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glGetnUniformuiv(program, location, bufSize, &params);
}
void QOpenGLExtraFunctions_GlInvalidateFramebuffer(void* ptr, unsigned int target, int numAttachments, unsigned int attachments)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glInvalidateFramebuffer(target, numAttachments, const_cast<const GLenum*>(&attachments));
}
void QOpenGLExtraFunctions_GlInvalidateSubFramebuffer(void* ptr, unsigned int target, int numAttachments, unsigned int attachments, int x, int y, int width, int height)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glInvalidateSubFramebuffer(target, numAttachments, const_cast<const GLenum*>(&attachments), x, y, width, height);
}
void QOpenGLExtraFunctions_GlMemoryBarrier(void* ptr, unsigned int barriers)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glMemoryBarrier(barriers);
}
void QOpenGLExtraFunctions_GlMemoryBarrierByRegion(void* ptr, unsigned int barriers)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glMemoryBarrierByRegion(barriers);
}
void QOpenGLExtraFunctions_GlMinSampleShading(void* ptr, float value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glMinSampleShading(value);
}
void QOpenGLExtraFunctions_GlPatchParameteri(void* ptr, unsigned int pname, int value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glPatchParameteri(pname, value);
}
void QOpenGLExtraFunctions_GlPauseTransformFeedback(void* ptr)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glPauseTransformFeedback();
}
void QOpenGLExtraFunctions_GlPopDebugGroup(void* ptr)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glPopDebugGroup();
}
void QOpenGLExtraFunctions_GlPrimitiveBoundingBox(void* ptr, float minX, float minY, float minZ, float minW, float maxX, float maxY, float maxZ, float maxW)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glPrimitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
}
void QOpenGLExtraFunctions_GlProgramBinary(void* ptr, unsigned int program, unsigned int binaryFormat, void* binary, int length)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramBinary(program, binaryFormat, binary, length);
}
void QOpenGLExtraFunctions_GlProgramParameteri(void* ptr, unsigned int program, unsigned int pname, int value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramParameteri(program, pname, value);
}
void QOpenGLExtraFunctions_GlProgramUniform1f(void* ptr, unsigned int program, int location, float v0)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniform1f(program, location, v0);
}
void QOpenGLExtraFunctions_GlProgramUniform1fv(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniform1fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLExtraFunctions_GlProgramUniform1i(void* ptr, unsigned int program, int location, int v0)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniform1i(program, location, v0);
}
void QOpenGLExtraFunctions_GlProgramUniform1iv(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniform1iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLExtraFunctions_GlProgramUniform1ui(void* ptr, unsigned int program, int location, unsigned int v0)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniform1ui(program, location, v0);
}
void QOpenGLExtraFunctions_GlProgramUniform1uiv(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniform1uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLExtraFunctions_GlProgramUniform2f(void* ptr, unsigned int program, int location, float v0, float v1)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniform2f(program, location, v0, v1);
}
void QOpenGLExtraFunctions_GlProgramUniform2fv(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniform2fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLExtraFunctions_GlProgramUniform2i(void* ptr, unsigned int program, int location, int v0, int v1)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniform2i(program, location, v0, v1);
}
void QOpenGLExtraFunctions_GlProgramUniform2iv(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniform2iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLExtraFunctions_GlProgramUniform2ui(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniform2ui(program, location, v0, v1);
}
void QOpenGLExtraFunctions_GlProgramUniform2uiv(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniform2uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLExtraFunctions_GlProgramUniform3f(void* ptr, unsigned int program, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniform3f(program, location, v0, v1, v2);
}
void QOpenGLExtraFunctions_GlProgramUniform3fv(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniform3fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLExtraFunctions_GlProgramUniform3i(void* ptr, unsigned int program, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniform3i(program, location, v0, v1, v2);
}
void QOpenGLExtraFunctions_GlProgramUniform3iv(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniform3iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLExtraFunctions_GlProgramUniform3ui(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniform3ui(program, location, v0, v1, v2);
}
void QOpenGLExtraFunctions_GlProgramUniform3uiv(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniform3uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLExtraFunctions_GlProgramUniform4f(void* ptr, unsigned int program, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniform4f(program, location, v0, v1, v2, v3);
}
void QOpenGLExtraFunctions_GlProgramUniform4fv(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniform4fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLExtraFunctions_GlProgramUniform4i(void* ptr, unsigned int program, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniform4i(program, location, v0, v1, v2, v3);
}
void QOpenGLExtraFunctions_GlProgramUniform4iv(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniform4iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLExtraFunctions_GlProgramUniform4ui(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniform4ui(program, location, v0, v1, v2, v3);
}
void QOpenGLExtraFunctions_GlProgramUniform4uiv(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniform4uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLExtraFunctions_GlProgramUniformMatrix2fv(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniformMatrix2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLExtraFunctions_GlProgramUniformMatrix2x3fv(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniformMatrix2x3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLExtraFunctions_GlProgramUniformMatrix2x4fv(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniformMatrix2x4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLExtraFunctions_GlProgramUniformMatrix3fv(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniformMatrix3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLExtraFunctions_GlProgramUniformMatrix3x2fv(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniformMatrix3x2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLExtraFunctions_GlProgramUniformMatrix3x4fv(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniformMatrix3x4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLExtraFunctions_GlProgramUniformMatrix4fv(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniformMatrix4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLExtraFunctions_GlProgramUniformMatrix4x2fv(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniformMatrix4x2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLExtraFunctions_GlProgramUniformMatrix4x3fv(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glProgramUniformMatrix4x3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLExtraFunctions_GlReadBuffer(void* ptr, unsigned int src)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glReadBuffer(src);
}
void QOpenGLExtraFunctions_GlReadnPixels(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, int bufSize, void* data)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glReadnPixels(x, y, width, height, format, ty, bufSize, data);
}
void QOpenGLExtraFunctions_GlRenderbufferStorageMultisample(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
}
void QOpenGLExtraFunctions_GlResumeTransformFeedback(void* ptr)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glResumeTransformFeedback();
}
void QOpenGLExtraFunctions_GlSampleMaski(void* ptr, unsigned int maskNumber, unsigned int mask)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glSampleMaski(maskNumber, mask);
}
void QOpenGLExtraFunctions_GlSamplerParameterIiv(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glSamplerParameterIiv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLExtraFunctions_GlSamplerParameterIuiv(void* ptr, unsigned int sampler, unsigned int pname, unsigned int param)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glSamplerParameterIuiv(sampler, pname, const_cast<const GLuint*>(&param));
}
void QOpenGLExtraFunctions_GlSamplerParameterf(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glSamplerParameterf(sampler, pname, param);
}
void QOpenGLExtraFunctions_GlSamplerParameterfv(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glSamplerParameterfv(sampler, pname, const_cast<const GLfloat*>(&param));
}
void QOpenGLExtraFunctions_GlSamplerParameteri(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glSamplerParameteri(sampler, pname, param);
}
void QOpenGLExtraFunctions_GlSamplerParameteriv(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glSamplerParameteriv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLExtraFunctions_GlTexBuffer(void* ptr, unsigned int target, unsigned int internalformat, unsigned int buffer)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glTexBuffer(target, internalformat, buffer);
}
void QOpenGLExtraFunctions_GlTexImage3D(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLExtraFunctions_GlTexParameterIiv(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glTexParameterIiv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLExtraFunctions_GlTexParameterIuiv(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glTexParameterIuiv(target, pname, const_cast<const GLuint*>(&params));
}
void QOpenGLExtraFunctions_GlTexStorage2D(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glTexStorage2D(target, levels, internalformat, width, height);
}
void QOpenGLExtraFunctions_GlTexStorage2DMultisample(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glTexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLExtraFunctions_GlTexStorage3D(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width, int height, int depth)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glTexStorage3D(target, levels, internalformat, width, height, depth);
}
void QOpenGLExtraFunctions_GlTexStorage3DMultisample(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glTexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLExtraFunctions_GlTexSubImage3D(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLExtraFunctions_GlUniform1ui(void* ptr, int location, unsigned int v0)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glUniform1ui(location, v0);
}
void QOpenGLExtraFunctions_GlUniform1uiv(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glUniform1uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLExtraFunctions_GlUniform2ui(void* ptr, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glUniform2ui(location, v0, v1);
}
void QOpenGLExtraFunctions_GlUniform2uiv(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glUniform2uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLExtraFunctions_GlUniform3ui(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glUniform3ui(location, v0, v1, v2);
}
void QOpenGLExtraFunctions_GlUniform3uiv(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glUniform3uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLExtraFunctions_GlUniform4ui(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glUniform4ui(location, v0, v1, v2, v3);
}
void QOpenGLExtraFunctions_GlUniform4uiv(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glUniform4uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLExtraFunctions_GlUniformBlockBinding(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int uniformBlockBinding)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}
void QOpenGLExtraFunctions_GlUniformMatrix2x3fv(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glUniformMatrix2x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLExtraFunctions_GlUniformMatrix2x4fv(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glUniformMatrix2x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLExtraFunctions_GlUniformMatrix3x2fv(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glUniformMatrix3x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLExtraFunctions_GlUniformMatrix3x4fv(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glUniformMatrix3x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLExtraFunctions_GlUniformMatrix4x2fv(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glUniformMatrix4x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLExtraFunctions_GlUniformMatrix4x3fv(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glUniformMatrix4x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLExtraFunctions_GlUseProgramStages(void* ptr, unsigned int pipeline, unsigned int stages, unsigned int program)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glUseProgramStages(pipeline, stages, program);
}
void QOpenGLExtraFunctions_GlValidateProgramPipeline(void* ptr, unsigned int pipeline)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glValidateProgramPipeline(pipeline);
}
void QOpenGLExtraFunctions_GlVertexAttribBinding(void* ptr, unsigned int attribindex, unsigned int bindingindex)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glVertexAttribBinding(attribindex, bindingindex);
}
void QOpenGLExtraFunctions_GlVertexAttribDivisor(void* ptr, unsigned int index, unsigned int divisor)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glVertexAttribDivisor(index, divisor);
}
void QOpenGLExtraFunctions_GlVertexAttribFormat(void* ptr, unsigned int attribindex, int size, unsigned int ty, char normalized, unsigned int relativeoffset)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glVertexAttribFormat(attribindex, size, ty, normalized != 0, relativeoffset);
}
void QOpenGLExtraFunctions_GlVertexAttribI4i(void* ptr, unsigned int index, int x, int y, int z, int w)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glVertexAttribI4i(index, x, y, z, w);
}
void QOpenGLExtraFunctions_GlVertexAttribI4iv(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glVertexAttribI4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLExtraFunctions_GlVertexAttribI4ui(void* ptr, unsigned int index, unsigned int x, unsigned int y, unsigned int z, unsigned int w)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glVertexAttribI4ui(index, x, y, z, w);
}
void QOpenGLExtraFunctions_GlVertexAttribI4uiv(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glVertexAttribI4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLExtraFunctions_GlVertexAttribIFormat(void* ptr, unsigned int attribindex, int size, unsigned int ty, unsigned int relativeoffset)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glVertexAttribIFormat(attribindex, size, ty, relativeoffset);
}
void QOpenGLExtraFunctions_GlVertexAttribIPointer(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glVertexAttribIPointer(index, size, ty, stride, pointer);
}
void QOpenGLExtraFunctions_GlVertexBindingDivisor(void* ptr, unsigned int bindingindex, unsigned int divisor)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->glVertexBindingDivisor(bindingindex, divisor);
}
void QOpenGLExtraFunctions_DestroyQOpenGLExtraFunctions(void* ptr)
{
static_cast<QOpenGLExtraFunctions*>(ptr)->~QOpenGLExtraFunctions();
}
class MyQOpenGLFramebufferObject: public QOpenGLFramebufferObject
{
public:
MyQOpenGLFramebufferObject(const QSize &size, GLenum target = GL_TEXTURE_2D) : QOpenGLFramebufferObject(size, target) {};
MyQOpenGLFramebufferObject(const QSize &size, QOpenGLFramebufferObject::Attachment attachment, GLenum target = GL_TEXTURE_2D, GLenum internalFormat = 0) : QOpenGLFramebufferObject(size, attachment, target, internalFormat) {};
MyQOpenGLFramebufferObject(const QSize &size, const QOpenGLFramebufferObjectFormat &format) : QOpenGLFramebufferObject(size, format) {};
MyQOpenGLFramebufferObject(int width, int height, GLenum target = GL_TEXTURE_2D) : QOpenGLFramebufferObject(width, height, target) {};
MyQOpenGLFramebufferObject(int width, int height, QOpenGLFramebufferObject::Attachment attachment, GLenum target = GL_TEXTURE_2D, GLenum internalFormat = 0) : QOpenGLFramebufferObject(width, height, attachment, target, internalFormat) {};
MyQOpenGLFramebufferObject(int width, int height, const QOpenGLFramebufferObjectFormat &format) : QOpenGLFramebufferObject(width, height, format) {};
~MyQOpenGLFramebufferObject() { callbackQOpenGLFramebufferObject_DestroyQOpenGLFramebufferObject(this); };
};
unsigned int QOpenGLFramebufferObject_TakeTexture(void* ptr)
{
return static_cast<QOpenGLFramebufferObject*>(ptr)->takeTexture();
}
unsigned int QOpenGLFramebufferObject_TakeTexture2(void* ptr, int colorAttachmentIndex)
{
return static_cast<QOpenGLFramebufferObject*>(ptr)->takeTexture(colorAttachmentIndex);
}
void* QOpenGLFramebufferObject_NewQOpenGLFramebufferObject(void* size, unsigned int target)
{
return new MyQOpenGLFramebufferObject(*static_cast<QSize*>(size), target);
}
void* QOpenGLFramebufferObject_NewQOpenGLFramebufferObject3(void* size, long long attachment, unsigned int target, unsigned int internalFormat)
{
return new MyQOpenGLFramebufferObject(*static_cast<QSize*>(size), static_cast<QOpenGLFramebufferObject::Attachment>(attachment), target, internalFormat);
}
void* QOpenGLFramebufferObject_NewQOpenGLFramebufferObject5(void* size, void* format)
{
return new MyQOpenGLFramebufferObject(*static_cast<QSize*>(size), *static_cast<QOpenGLFramebufferObjectFormat*>(format));
}
void* QOpenGLFramebufferObject_NewQOpenGLFramebufferObject2(int width, int height, unsigned int target)
{
return new MyQOpenGLFramebufferObject(width, height, target);
}
void* QOpenGLFramebufferObject_NewQOpenGLFramebufferObject4(int width, int height, long long attachment, unsigned int target, unsigned int internalFormat)
{
return new MyQOpenGLFramebufferObject(width, height, static_cast<QOpenGLFramebufferObject::Attachment>(attachment), target, internalFormat);
}
void* QOpenGLFramebufferObject_NewQOpenGLFramebufferObject6(int width, int height, void* format)
{
return new MyQOpenGLFramebufferObject(width, height, *static_cast<QOpenGLFramebufferObjectFormat*>(format));
}
char QOpenGLFramebufferObject_Bind(void* ptr)
{
return static_cast<QOpenGLFramebufferObject*>(ptr)->bind();
}
char QOpenGLFramebufferObject_QOpenGLFramebufferObject_BindDefault()
{
return QOpenGLFramebufferObject::bindDefault();
}
char QOpenGLFramebufferObject_QOpenGLFramebufferObject_HasOpenGLFramebufferBlit()
{
return QOpenGLFramebufferObject::hasOpenGLFramebufferBlit();
}
char QOpenGLFramebufferObject_QOpenGLFramebufferObject_HasOpenGLFramebufferObjects()
{
return QOpenGLFramebufferObject::hasOpenGLFramebufferObjects();
}
char QOpenGLFramebufferObject_Release(void* ptr)
{
return static_cast<QOpenGLFramebufferObject*>(ptr)->release();
}
void QOpenGLFramebufferObject_AddColorAttachment(void* ptr, void* size, unsigned int internalFormat)
{
static_cast<QOpenGLFramebufferObject*>(ptr)->addColorAttachment(*static_cast<QSize*>(size), internalFormat);
}
void QOpenGLFramebufferObject_AddColorAttachment2(void* ptr, int width, int height, unsigned int internalFormat)
{
static_cast<QOpenGLFramebufferObject*>(ptr)->addColorAttachment(width, height, internalFormat);
}
void QOpenGLFramebufferObject_QOpenGLFramebufferObject_BlitFramebuffer4(void* target, void* source, unsigned int buffers, unsigned int filter)
{
QOpenGLFramebufferObject::blitFramebuffer(static_cast<QOpenGLFramebufferObject*>(target), static_cast<QOpenGLFramebufferObject*>(source), buffers, filter);
}
void QOpenGLFramebufferObject_QOpenGLFramebufferObject_BlitFramebuffer3(void* target, void* targetRect, void* source, void* sourceRect, unsigned int buffers, unsigned int filter)
{
QOpenGLFramebufferObject::blitFramebuffer(static_cast<QOpenGLFramebufferObject*>(target), *static_cast<QRect*>(targetRect), static_cast<QOpenGLFramebufferObject*>(source), *static_cast<QRect*>(sourceRect), buffers, filter);
}
void QOpenGLFramebufferObject_QOpenGLFramebufferObject_BlitFramebuffer2(void* target, void* targetRect, void* source, void* sourceRect, unsigned int buffers, unsigned int filter, int readColorAttachmentIndex, int drawColorAttachmentIndex)
{
QOpenGLFramebufferObject::blitFramebuffer(static_cast<QOpenGLFramebufferObject*>(target), *static_cast<QRect*>(targetRect), static_cast<QOpenGLFramebufferObject*>(source), *static_cast<QRect*>(sourceRect), buffers, filter, readColorAttachmentIndex, drawColorAttachmentIndex);
}
void QOpenGLFramebufferObject_QOpenGLFramebufferObject_BlitFramebuffer(void* target, void* targetRect, void* source, void* sourceRect, unsigned int buffers, unsigned int filter, int readColorAttachmentIndex, int drawColorAttachmentIndex, long long restorePolicy)
{
QOpenGLFramebufferObject::blitFramebuffer(static_cast<QOpenGLFramebufferObject*>(target), *static_cast<QRect*>(targetRect), static_cast<QOpenGLFramebufferObject*>(source), *static_cast<QRect*>(sourceRect), buffers, filter, readColorAttachmentIndex, drawColorAttachmentIndex, static_cast<QOpenGLFramebufferObject::FramebufferRestorePolicy>(restorePolicy));
}
void QOpenGLFramebufferObject_SetAttachment(void* ptr, long long attachment)
{
static_cast<QOpenGLFramebufferObject*>(ptr)->setAttachment(static_cast<QOpenGLFramebufferObject::Attachment>(attachment));
}
void QOpenGLFramebufferObject_DestroyQOpenGLFramebufferObject(void* ptr)
{
static_cast<QOpenGLFramebufferObject*>(ptr)->~QOpenGLFramebufferObject();
}
void QOpenGLFramebufferObject_DestroyQOpenGLFramebufferObjectDefault(void* ptr)
{
Q_UNUSED(ptr);
}
unsigned int QOpenGLFramebufferObject_Handle(void* ptr)
{
return static_cast<QOpenGLFramebufferObject*>(ptr)->handle();
}
unsigned int QOpenGLFramebufferObject_Texture(void* ptr)
{
return static_cast<QOpenGLFramebufferObject*>(ptr)->texture();
}
void* QOpenGLFramebufferObject_ToImage2(void* ptr)
{
return new QImage(static_cast<QOpenGLFramebufferObject*>(ptr)->toImage());
}
void* QOpenGLFramebufferObject_ToImage(void* ptr, char flipped)
{
return new QImage(static_cast<QOpenGLFramebufferObject*>(ptr)->toImage(flipped != 0));
}
void* QOpenGLFramebufferObject_ToImage3(void* ptr, char flipped, int colorAttachmentIndex)
{
return new QImage(static_cast<QOpenGLFramebufferObject*>(ptr)->toImage(flipped != 0, colorAttachmentIndex));
}
long long QOpenGLFramebufferObject_Attachment(void* ptr)
{
return static_cast<QOpenGLFramebufferObject*>(ptr)->attachment();
}
void* QOpenGLFramebufferObject_Format(void* ptr)
{
return new QOpenGLFramebufferObjectFormat(static_cast<QOpenGLFramebufferObject*>(ptr)->format());
}
void* QOpenGLFramebufferObject_Size(void* ptr)
{
return ({ QSize tmpValue = static_cast<QOpenGLFramebufferObject*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
}
struct QtGui_PackedList QOpenGLFramebufferObject_Textures(void* ptr)
{
return ({ QVector<GLuint>* tmpValue = new QVector<GLuint>(static_cast<QOpenGLFramebufferObject*>(ptr)->textures()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedList QOpenGLFramebufferObject_Sizes(void* ptr)
{
return ({ QVector<QSize>* tmpValue = new QVector<QSize>(static_cast<QOpenGLFramebufferObject*>(ptr)->sizes()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
char QOpenGLFramebufferObject_IsBound(void* ptr)
{
return static_cast<QOpenGLFramebufferObject*>(ptr)->isBound();
}
char QOpenGLFramebufferObject_IsValid(void* ptr)
{
return static_cast<QOpenGLFramebufferObject*>(ptr)->isValid();
}
int QOpenGLFramebufferObject_Height(void* ptr)
{
return static_cast<QOpenGLFramebufferObject*>(ptr)->height();
}
int QOpenGLFramebufferObject_Width(void* ptr)
{
return static_cast<QOpenGLFramebufferObject*>(ptr)->width();
}
unsigned int QOpenGLFramebufferObject___textures_atList(void* ptr, int i)
{
return ({GLuint tmp = static_cast<QVector<GLuint>*>(ptr)->at(i); if (i == static_cast<QVector<GLuint>*>(ptr)->size()-1) { static_cast<QVector<GLuint>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QOpenGLFramebufferObject___textures_setList(void* ptr, unsigned int i)
{
static_cast<QVector<GLuint>*>(ptr)->append(i);
}
void* QOpenGLFramebufferObject___textures_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<GLuint>();
}
void* QOpenGLFramebufferObject___sizes_atList(void* ptr, int i)
{
return ({ QSize tmpValue = ({QSize tmp = static_cast<QVector<QSize>*>(ptr)->at(i); if (i == static_cast<QVector<QSize>*>(ptr)->size()-1) { static_cast<QVector<QSize>*>(ptr)->~QVector(); free(ptr); }; tmp; }); new QSize(tmpValue.width(), tmpValue.height()); });
}
void QOpenGLFramebufferObject___sizes_setList(void* ptr, void* i)
{
static_cast<QVector<QSize>*>(ptr)->append(*static_cast<QSize*>(i));
}
void* QOpenGLFramebufferObject___sizes_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QSize>();
}
void* QOpenGLFramebufferObjectFormat_NewQOpenGLFramebufferObjectFormat()
{
return new QOpenGLFramebufferObjectFormat();
}
void* QOpenGLFramebufferObjectFormat_NewQOpenGLFramebufferObjectFormat2(void* other)
{
return new QOpenGLFramebufferObjectFormat(*static_cast<QOpenGLFramebufferObjectFormat*>(other));
}
void QOpenGLFramebufferObjectFormat_SetAttachment(void* ptr, long long attachment)
{
static_cast<QOpenGLFramebufferObjectFormat*>(ptr)->setAttachment(static_cast<QOpenGLFramebufferObject::Attachment>(attachment));
}
void QOpenGLFramebufferObjectFormat_SetInternalTextureFormat(void* ptr, unsigned int internalTextureFormat)
{
static_cast<QOpenGLFramebufferObjectFormat*>(ptr)->setInternalTextureFormat(internalTextureFormat);
}
void QOpenGLFramebufferObjectFormat_SetMipmap(void* ptr, char enabled)
{
static_cast<QOpenGLFramebufferObjectFormat*>(ptr)->setMipmap(enabled != 0);
}
void QOpenGLFramebufferObjectFormat_SetSamples(void* ptr, int samples)
{
static_cast<QOpenGLFramebufferObjectFormat*>(ptr)->setSamples(samples);
}
void QOpenGLFramebufferObjectFormat_SetTextureTarget(void* ptr, unsigned int target)
{
static_cast<QOpenGLFramebufferObjectFormat*>(ptr)->setTextureTarget(target);
}
void QOpenGLFramebufferObjectFormat_DestroyQOpenGLFramebufferObjectFormat(void* ptr)
{
static_cast<QOpenGLFramebufferObjectFormat*>(ptr)->~QOpenGLFramebufferObjectFormat();
}
unsigned int QOpenGLFramebufferObjectFormat_InternalTextureFormat(void* ptr)
{
return static_cast<QOpenGLFramebufferObjectFormat*>(ptr)->internalTextureFormat();
}
unsigned int QOpenGLFramebufferObjectFormat_TextureTarget(void* ptr)
{
return static_cast<QOpenGLFramebufferObjectFormat*>(ptr)->textureTarget();
}
long long QOpenGLFramebufferObjectFormat_Attachment(void* ptr)
{
return static_cast<QOpenGLFramebufferObjectFormat*>(ptr)->attachment();
}
char QOpenGLFramebufferObjectFormat_Mipmap(void* ptr)
{
return static_cast<QOpenGLFramebufferObjectFormat*>(ptr)->mipmap();
}
int QOpenGLFramebufferObjectFormat_Samples(void* ptr)
{
return static_cast<QOpenGLFramebufferObjectFormat*>(ptr)->samples();
}
char QOpenGLFunctions_GlIsBuffer(void* ptr, unsigned int buffer)
{
return static_cast<QOpenGLFunctions*>(ptr)->glIsBuffer(buffer);
}
char QOpenGLFunctions_GlIsEnabled(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_GlIsFramebuffer(void* ptr, unsigned int framebuffer)
{
return static_cast<QOpenGLFunctions*>(ptr)->glIsFramebuffer(framebuffer);
}
char QOpenGLFunctions_GlIsProgram(void* ptr, unsigned int program)
{
return static_cast<QOpenGLFunctions*>(ptr)->glIsProgram(program);
}
char QOpenGLFunctions_GlIsRenderbuffer(void* ptr, unsigned int renderbuffer)
{
return static_cast<QOpenGLFunctions*>(ptr)->glIsRenderbuffer(renderbuffer);
}
char QOpenGLFunctions_GlIsShader(void* ptr, unsigned int shader)
{
return static_cast<QOpenGLFunctions*>(ptr)->glIsShader(shader);
}
char QOpenGLFunctions_GlIsTexture(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions*>(ptr)->glIsTexture(texture);
}
unsigned int QOpenGLFunctions_GlCheckFramebufferStatus(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions*>(ptr)->glCheckFramebufferStatus(target);
}
unsigned int QOpenGLFunctions_GlGetError(void* ptr)
{
return static_cast<QOpenGLFunctions*>(ptr)->glGetError();
}
int QOpenGLFunctions_GlGetAttribLocation(void* ptr, unsigned int program, char* name)
{
return static_cast<QOpenGLFunctions*>(ptr)->glGetAttribLocation(program, const_cast<const char*>(name));
}
int QOpenGLFunctions_GlGetUniformLocation(void* ptr, unsigned int program, char* name)
{
return static_cast<QOpenGLFunctions*>(ptr)->glGetUniformLocation(program, const_cast<const char*>(name));
}
unsigned int QOpenGLFunctions_GlCreateProgram(void* ptr)
{
return static_cast<QOpenGLFunctions*>(ptr)->glCreateProgram();
}
unsigned int QOpenGLFunctions_GlCreateShader(void* ptr, unsigned int ty)
{
return static_cast<QOpenGLFunctions*>(ptr)->glCreateShader(ty);
}
void* QOpenGLFunctions_NewQOpenGLFunctions()
{
return new QOpenGLFunctions();
}
void* QOpenGLFunctions_NewQOpenGLFunctions2(void* context)
{
return new QOpenGLFunctions(static_cast<QOpenGLContext*>(context));
}
struct QtGui_PackedString QOpenGLFunctions_GlGetString(void* ptr, unsigned int name)
{
return ({ char* t88dc64 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions*>(ptr)->glGetString(name)))); QtGui_PackedString { t88dc64, -1 }; });
}
void QOpenGLFunctions_GlActiveTexture(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions*>(ptr)->glActiveTexture(texture);
}
void QOpenGLFunctions_GlAttachShader(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions*>(ptr)->glAttachShader(program, shader);
}
void QOpenGLFunctions_GlBindAttribLocation(void* ptr, unsigned int program, unsigned int index, char* name)
{
static_cast<QOpenGLFunctions*>(ptr)->glBindAttribLocation(program, index, const_cast<const char*>(name));
}
void QOpenGLFunctions_GlBindBuffer(void* ptr, unsigned int target, unsigned int buffer)
{
static_cast<QOpenGLFunctions*>(ptr)->glBindBuffer(target, buffer);
}
void QOpenGLFunctions_GlBindFramebuffer(void* ptr, unsigned int target, unsigned int framebuffer)
{
static_cast<QOpenGLFunctions*>(ptr)->glBindFramebuffer(target, framebuffer);
}
void QOpenGLFunctions_GlBindRenderbuffer(void* ptr, unsigned int target, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions*>(ptr)->glBindRenderbuffer(target, renderbuffer);
}
void QOpenGLFunctions_GlBindTexture(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_GlBlendColor(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_GlBlendEquation(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_GlBlendEquationSeparate(void* ptr, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions*>(ptr)->glBlendEquationSeparate(modeRGB, modeAlpha);
}
void QOpenGLFunctions_GlBlendFunc(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_GlBlendFuncSeparate(void* ptr, unsigned int srcRGB, unsigned int dstRGB, unsigned int srcAlpha, unsigned int dstAlpha)
{
static_cast<QOpenGLFunctions*>(ptr)->glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
}
void QOpenGLFunctions_GlClear(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_GlClearColor(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_GlClearDepthf(void* ptr, float depth)
{
static_cast<QOpenGLFunctions*>(ptr)->glClearDepthf(depth);
}
void QOpenGLFunctions_GlClearStencil(void* ptr, int s)
{
static_cast<QOpenGLFunctions*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_GlColorMask(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_GlCompileShader(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions*>(ptr)->glCompileShader(shader);
}
void QOpenGLFunctions_GlCompressedTexImage2D(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions*>(ptr)->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void QOpenGLFunctions_GlCompressedTexSubImage2D(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions*>(ptr)->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_GlCopyTexImage2D(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_GlCopyTexSubImage2D(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_GlCullFace(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_GlDeleteBuffers(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions*>(ptr)->glDeleteBuffers(n, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_GlDeleteFramebuffers(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions*>(ptr)->glDeleteFramebuffers(n, const_cast<const GLuint*>(&framebuffers));
}
void QOpenGLFunctions_GlDeleteProgram(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions*>(ptr)->glDeleteProgram(program);
}
void QOpenGLFunctions_GlDeleteRenderbuffers(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions*>(ptr)->glDeleteRenderbuffers(n, const_cast<const GLuint*>(&renderbuffers));
}
void QOpenGLFunctions_GlDeleteShader(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions*>(ptr)->glDeleteShader(shader);
}
void QOpenGLFunctions_GlDeleteTextures(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_GlDepthFunc(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_GlDepthMask(void* ptr, char flag)
{
static_cast<QOpenGLFunctions*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_GlDepthRangef(void* ptr, float zNear, float zFar)
{
static_cast<QOpenGLFunctions*>(ptr)->glDepthRangef(zNear, zFar);
}
void QOpenGLFunctions_GlDetachShader(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions*>(ptr)->glDetachShader(program, shader);
}
void QOpenGLFunctions_GlDisable(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_GlDisableVertexAttribArray(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions*>(ptr)->glDisableVertexAttribArray(index);
}
void QOpenGLFunctions_GlDrawArrays(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_GlDrawElements(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_GlEnable(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_GlEnableVertexAttribArray(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions*>(ptr)->glEnableVertexAttribArray(index);
}
void QOpenGLFunctions_GlFinish(void* ptr)
{
static_cast<QOpenGLFunctions*>(ptr)->glFinish();
}
void QOpenGLFunctions_GlFlush(void* ptr)
{
static_cast<QOpenGLFunctions*>(ptr)->glFlush();
}
void QOpenGLFunctions_GlFramebufferRenderbuffer(void* ptr, unsigned int target, unsigned int attachment, unsigned int renderbuffertarget, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions*>(ptr)->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
void QOpenGLFunctions_GlFramebufferTexture2D(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions*>(ptr)->glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_GlFrontFace(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_GlGenBuffers(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions*>(ptr)->glGenBuffers(n, &buffers);
}
void QOpenGLFunctions_GlGenFramebuffers(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions*>(ptr)->glGenFramebuffers(n, &framebuffers);
}
void QOpenGLFunctions_GlGenRenderbuffers(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions*>(ptr)->glGenRenderbuffers(n, &renderbuffers);
}
void QOpenGLFunctions_GlGenTextures(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_GlGenerateMipmap(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions*>(ptr)->glGenerateMipmap(target);
}
void QOpenGLFunctions_GlGetActiveAttrib(void* ptr, unsigned int program, unsigned int index, int bufsize, int length, int size, unsigned int ty, char* name)
{
static_cast<QOpenGLFunctions*>(ptr)->glGetActiveAttrib(program, index, bufsize, &length, &size, &ty, name);
}
void QOpenGLFunctions_GlGetActiveUniform(void* ptr, unsigned int program, unsigned int index, int bufsize, int length, int size, unsigned int ty, char* name)
{
static_cast<QOpenGLFunctions*>(ptr)->glGetActiveUniform(program, index, bufsize, &length, &size, &ty, name);
}
void QOpenGLFunctions_GlGetAttachedShaders(void* ptr, unsigned int program, int maxcount, int count, unsigned int shaders)
{
static_cast<QOpenGLFunctions*>(ptr)->glGetAttachedShaders(program, maxcount, &count, &shaders);
}
void QOpenGLFunctions_GlGetBooleanv(void* ptr, unsigned int pname, char params)
{
Q_UNUSED(params);
static_cast<QOpenGLFunctions*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_GlGetBufferParameteriv(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions*>(ptr)->glGetBufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_GlGetFloatv(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions*>(ptr)->glGetFloatv(pname, &params);
}
void QOpenGLFunctions_GlGetFramebufferAttachmentParameteriv(void* ptr, unsigned int target, unsigned int attachment, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions*>(ptr)->glGetFramebufferAttachmentParameteriv(target, attachment, pname, &params);
}
void QOpenGLFunctions_GlGetIntegerv(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions*>(ptr)->glGetIntegerv(pname, &params);
}
void QOpenGLFunctions_GlGetProgramInfoLog(void* ptr, unsigned int program, int bufsize, int length, char* infolog)
{
static_cast<QOpenGLFunctions*>(ptr)->glGetProgramInfoLog(program, bufsize, &length, infolog);
}
void QOpenGLFunctions_GlGetProgramiv(void* ptr, unsigned int program, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions*>(ptr)->glGetProgramiv(program, pname, &params);
}
void QOpenGLFunctions_GlGetRenderbufferParameteriv(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions*>(ptr)->glGetRenderbufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_GlGetShaderInfoLog(void* ptr, unsigned int shader, int bufsize, int length, char* infolog)
{
static_cast<QOpenGLFunctions*>(ptr)->glGetShaderInfoLog(shader, bufsize, &length, infolog);
}
void QOpenGLFunctions_GlGetShaderPrecisionFormat(void* ptr, unsigned int shadertype, unsigned int precisiontype, int ran, int precision)
{
static_cast<QOpenGLFunctions*>(ptr)->glGetShaderPrecisionFormat(shadertype, precisiontype, &ran, &precision);
}
void QOpenGLFunctions_GlGetShaderSource(void* ptr, unsigned int shader, int bufsize, int length, char* source)
{
static_cast<QOpenGLFunctions*>(ptr)->glGetShaderSource(shader, bufsize, &length, source);
}
void QOpenGLFunctions_GlGetShaderiv(void* ptr, unsigned int shader, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions*>(ptr)->glGetShaderiv(shader, pname, &params);
}
void QOpenGLFunctions_GlGetTexParameterfv(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_GlGetTexParameteriv(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_GlGetUniformfv(void* ptr, unsigned int program, int location, float params)
{
static_cast<QOpenGLFunctions*>(ptr)->glGetUniformfv(program, location, &params);
}
void QOpenGLFunctions_GlGetUniformiv(void* ptr, unsigned int program, int location, int params)
{
static_cast<QOpenGLFunctions*>(ptr)->glGetUniformiv(program, location, &params);
}
void QOpenGLFunctions_GlGetVertexAttribPointerv(void* ptr, unsigned int index, unsigned int pname, void* pointer)
{
static_cast<QOpenGLFunctions*>(ptr)->glGetVertexAttribPointerv(index, pname, &pointer);
}
void QOpenGLFunctions_GlGetVertexAttribfv(void* ptr, unsigned int index, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions*>(ptr)->glGetVertexAttribfv(index, pname, &params);
}
void QOpenGLFunctions_GlGetVertexAttribiv(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions*>(ptr)->glGetVertexAttribiv(index, pname, &params);
}
void QOpenGLFunctions_GlHint(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_GlLineWidth(void* ptr, float width)
{
static_cast<QOpenGLFunctions*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_GlLinkProgram(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions*>(ptr)->glLinkProgram(program);
}
void QOpenGLFunctions_GlPixelStorei(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_GlPolygonOffset(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_GlReadPixels(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_GlReleaseShaderCompiler(void* ptr)
{
static_cast<QOpenGLFunctions*>(ptr)->glReleaseShaderCompiler();
}
void QOpenGLFunctions_GlRenderbufferStorage(void* ptr, unsigned int target, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions*>(ptr)->glRenderbufferStorage(target, internalformat, width, height);
}
void QOpenGLFunctions_GlSampleCoverage(void* ptr, float value, char invert)
{
static_cast<QOpenGLFunctions*>(ptr)->glSampleCoverage(value, invert != 0);
}
void QOpenGLFunctions_GlScissor(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_GlShaderBinary(void* ptr, int n, unsigned int shaders, unsigned int binaryformat, void* binary, int length)
{
static_cast<QOpenGLFunctions*>(ptr)->glShaderBinary(n, const_cast<const GLuint*>(&shaders), binaryformat, binary, length);
}
void QOpenGLFunctions_GlStencilFunc(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_GlStencilFuncSeparate(void* ptr, unsigned int face, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions*>(ptr)->glStencilFuncSeparate(face, fu, ref, mask);
}
void QOpenGLFunctions_GlStencilMask(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_GlStencilMaskSeparate(void* ptr, unsigned int face, unsigned int mask)
{
static_cast<QOpenGLFunctions*>(ptr)->glStencilMaskSeparate(face, mask);
}
void QOpenGLFunctions_GlStencilOp(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_GlStencilOpSeparate(void* ptr, unsigned int face, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions*>(ptr)->glStencilOpSeparate(face, fail, zfail, zpass);
}
void QOpenGLFunctions_GlTexImage2D(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_GlTexParameterf(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_GlTexParameterfv(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_GlTexParameteri(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_GlTexParameteriv(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_GlTexSubImage2D(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_GlUniform1f(void* ptr, int location, float x)
{
static_cast<QOpenGLFunctions*>(ptr)->glUniform1f(location, x);
}
void QOpenGLFunctions_GlUniform1fv(void* ptr, int location, int count, float v)
{
static_cast<QOpenGLFunctions*>(ptr)->glUniform1fv(location, count, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_GlUniform1i(void* ptr, int location, int x)
{
static_cast<QOpenGLFunctions*>(ptr)->glUniform1i(location, x);
}
void QOpenGLFunctions_GlUniform1iv(void* ptr, int location, int count, int v)
{
static_cast<QOpenGLFunctions*>(ptr)->glUniform1iv(location, count, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_GlUniform2f(void* ptr, int location, float x, float y)
{
static_cast<QOpenGLFunctions*>(ptr)->glUniform2f(location, x, y);
}
void QOpenGLFunctions_GlUniform2fv(void* ptr, int location, int count, float v)
{
static_cast<QOpenGLFunctions*>(ptr)->glUniform2fv(location, count, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_GlUniform2i(void* ptr, int location, int x, int y)
{
static_cast<QOpenGLFunctions*>(ptr)->glUniform2i(location, x, y);
}
void QOpenGLFunctions_GlUniform2iv(void* ptr, int location, int count, int v)
{
static_cast<QOpenGLFunctions*>(ptr)->glUniform2iv(location, count, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_GlUniform3f(void* ptr, int location, float x, float y, float z)
{
static_cast<QOpenGLFunctions*>(ptr)->glUniform3f(location, x, y, z);
}
void QOpenGLFunctions_GlUniform3fv(void* ptr, int location, int count, float v)
{
static_cast<QOpenGLFunctions*>(ptr)->glUniform3fv(location, count, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_GlUniform3i(void* ptr, int location, int x, int y, int z)
{
static_cast<QOpenGLFunctions*>(ptr)->glUniform3i(location, x, y, z);
}
void QOpenGLFunctions_GlUniform3iv(void* ptr, int location, int count, int v)
{
static_cast<QOpenGLFunctions*>(ptr)->glUniform3iv(location, count, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_GlUniform4f(void* ptr, int location, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions*>(ptr)->glUniform4f(location, x, y, z, w);
}
void QOpenGLFunctions_GlUniform4fv(void* ptr, int location, int count, float v)
{
static_cast<QOpenGLFunctions*>(ptr)->glUniform4fv(location, count, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_GlUniform4i(void* ptr, int location, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions*>(ptr)->glUniform4i(location, x, y, z, w);
}
void QOpenGLFunctions_GlUniform4iv(void* ptr, int location, int count, int v)
{
static_cast<QOpenGLFunctions*>(ptr)->glUniform4iv(location, count, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_GlUniformMatrix2fv(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions*>(ptr)->glUniformMatrix2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_GlUniformMatrix3fv(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions*>(ptr)->glUniformMatrix3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_GlUniformMatrix4fv(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions*>(ptr)->glUniformMatrix4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_GlUseProgram(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions*>(ptr)->glUseProgram(program);
}
void QOpenGLFunctions_GlValidateProgram(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions*>(ptr)->glValidateProgram(program);
}
void QOpenGLFunctions_GlVertexAttrib1f(void* ptr, unsigned int indx, float x)
{
static_cast<QOpenGLFunctions*>(ptr)->glVertexAttrib1f(indx, x);
}
void QOpenGLFunctions_GlVertexAttrib1fv(void* ptr, unsigned int indx, float values)
{
static_cast<QOpenGLFunctions*>(ptr)->glVertexAttrib1fv(indx, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_GlVertexAttrib2f(void* ptr, unsigned int indx, float x, float y)
{
static_cast<QOpenGLFunctions*>(ptr)->glVertexAttrib2f(indx, x, y);
}
void QOpenGLFunctions_GlVertexAttrib2fv(void* ptr, unsigned int indx, float values)
{
static_cast<QOpenGLFunctions*>(ptr)->glVertexAttrib2fv(indx, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_GlVertexAttrib3f(void* ptr, unsigned int indx, float x, float y, float z)
{
static_cast<QOpenGLFunctions*>(ptr)->glVertexAttrib3f(indx, x, y, z);
}
void QOpenGLFunctions_GlVertexAttrib3fv(void* ptr, unsigned int indx, float values)
{
static_cast<QOpenGLFunctions*>(ptr)->glVertexAttrib3fv(indx, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_GlVertexAttrib4f(void* ptr, unsigned int indx, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions*>(ptr)->glVertexAttrib4f(indx, x, y, z, w);
}
void QOpenGLFunctions_GlVertexAttrib4fv(void* ptr, unsigned int indx, float values)
{
static_cast<QOpenGLFunctions*>(ptr)->glVertexAttrib4fv(indx, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_GlVertexAttribPointer(void* ptr, unsigned int indx, int size, unsigned int ty, char normalized, int stride, void* p)
{
static_cast<QOpenGLFunctions*>(ptr)->glVertexAttribPointer(indx, size, ty, normalized != 0, stride, p);
}
void QOpenGLFunctions_GlViewport(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_InitializeOpenGLFunctions(void* ptr)
{
static_cast<QOpenGLFunctions*>(ptr)->initializeOpenGLFunctions();
}
void QOpenGLFunctions_DestroyQOpenGLFunctions(void* ptr)
{
static_cast<QOpenGLFunctions*>(ptr)->~QOpenGLFunctions();
}
long long QOpenGLFunctions_OpenGLFeatures(void* ptr)
{
return static_cast<QOpenGLFunctions*>(ptr)->openGLFeatures();
}
char QOpenGLFunctions_HasOpenGLFeature(void* ptr, long long feature)
{
return static_cast<QOpenGLFunctions*>(ptr)->hasOpenGLFeature(static_cast<QOpenGLFunctions::OpenGLFeature>(feature));
}
class MyQOpenGLFunctions_1_0: public QOpenGLFunctions_1_0
{
public:
MyQOpenGLFunctions_1_0() : QOpenGLFunctions_1_0() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_1_0_InitializeOpenGLFunctions2(this) != 0; };
~MyQOpenGLFunctions_1_0() { callbackQOpenGLFunctions_1_0_DestroyQOpenGLFunctions_1_02(this); };
};
char QOpenGLFunctions_1_0_GlIsEnabled2(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_1_0*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_1_0_GlIsList2(void* ptr, unsigned int list)
{
return static_cast<QOpenGLFunctions_1_0*>(ptr)->glIsList(list);
}
unsigned int QOpenGLFunctions_1_0_GlGetError2(void* ptr)
{
return static_cast<QOpenGLFunctions_1_0*>(ptr)->glGetError();
}
int QOpenGLFunctions_1_0_GlRenderMode2(void* ptr, unsigned int mode)
{
return static_cast<QOpenGLFunctions_1_0*>(ptr)->glRenderMode(mode);
}
unsigned int QOpenGLFunctions_1_0_GlGenLists2(void* ptr, int ran)
{
return static_cast<QOpenGLFunctions_1_0*>(ptr)->glGenLists(ran);
}
void* QOpenGLFunctions_1_0_NewQOpenGLFunctions_1_02()
{
return new MyQOpenGLFunctions_1_0();
}
char QOpenGLFunctions_1_0_InitializeOpenGLFunctions2(void* ptr)
{
return static_cast<QOpenGLFunctions_1_0*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_1_0_InitializeOpenGLFunctions2Default(void* ptr)
{
return static_cast<QOpenGLFunctions_1_0*>(ptr)->QOpenGLFunctions_1_0::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_1_0_GlGetString2(void* ptr, unsigned int name)
{
return ({ char* t0c442a = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_1_0*>(ptr)->glGetString(name)))); QtGui_PackedString { t0c442a, -1 }; });
}
void QOpenGLFunctions_1_0_GlAccum2(void* ptr, unsigned int op, float value)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glAccum(op, value);
}
void QOpenGLFunctions_1_0_GlAlphaFunc2(void* ptr, unsigned int fu, float ref)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glAlphaFunc(fu, ref);
}
void QOpenGLFunctions_1_0_GlBegin2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glBegin(mode);
}
void QOpenGLFunctions_1_0_GlBitmap2(void* ptr, int width, int height, float xorig, float yorig, float xmove, float ymove, char* bitmap)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glBitmap(width, height, xorig, yorig, xmove, ymove, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(bitmap))));
}
void QOpenGLFunctions_1_0_GlBlendFunc2(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_1_0_GlCallList2(void* ptr, unsigned int list)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glCallList(list);
}
void QOpenGLFunctions_1_0_GlCallLists2(void* ptr, int n, unsigned int ty, void* lists)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glCallLists(n, ty, lists);
}
void QOpenGLFunctions_1_0_GlClear2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_1_0_GlClearAccum2(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glClearAccum(red, green, blue, alpha);
}
void QOpenGLFunctions_1_0_GlClearColor2(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_1_0_GlClearIndex2(void* ptr, float c)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glClearIndex(c);
}
void QOpenGLFunctions_1_0_GlClearStencil2(void* ptr, int s)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_1_0_GlColor3f2(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColor3f(red, green, blue);
}
void QOpenGLFunctions_1_0_GlColor3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_0_GlColor3i2(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColor3i(red, green, blue);
}
void QOpenGLFunctions_1_0_GlColor3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_0_GlColor3s2(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColor3s(red, green, blue);
}
void QOpenGLFunctions_1_0_GlColor3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_0_GlColor3ub2(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_1_0_GlColor3ubv2(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_1_0_GlColor3ui2(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColor3ui(red, green, blue);
}
void QOpenGLFunctions_1_0_GlColor3uiv2(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_1_0_GlColor3us2(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColor3us(red, green, blue);
}
void QOpenGLFunctions_1_0_GlColor3usv2(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_1_0_GlColor4f2(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColor4f(red, green, blue, alpha);
}
void QOpenGLFunctions_1_0_GlColor4fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColor4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_0_GlColor4i2(void* ptr, int red, int green, int blue, int alpha)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColor4i(red, green, blue, alpha);
}
void QOpenGLFunctions_1_0_GlColor4iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColor4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_0_GlColor4s2(void* ptr, short red, short green, short blue, short alpha)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColor4s(red, green, blue, alpha);
}
void QOpenGLFunctions_1_0_GlColor4sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColor4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_0_GlColor4ub2(void* ptr, char* red, char* green, char* blue, char* alpha)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColor4ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)), *static_cast<GLubyte*>(static_cast<void*>(alpha)));
}
void QOpenGLFunctions_1_0_GlColor4ubv2(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColor4ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_1_0_GlColor4ui2(void* ptr, unsigned int red, unsigned int green, unsigned int blue, unsigned int alpha)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColor4ui(red, green, blue, alpha);
}
void QOpenGLFunctions_1_0_GlColor4uiv2(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColor4uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_1_0_GlColor4us2(void* ptr, unsigned short red, unsigned short green, unsigned short blue, unsigned short alpha)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColor4us(red, green, blue, alpha);
}
void QOpenGLFunctions_1_0_GlColor4usv2(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColor4usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_1_0_GlColorMask2(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_1_0_GlColorMaterial2(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glColorMaterial(face, mode);
}
void QOpenGLFunctions_1_0_GlCopyPixels2(void* ptr, int x, int y, int width, int height, unsigned int ty)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glCopyPixels(x, y, width, height, ty);
}
void QOpenGLFunctions_1_0_GlCullFace2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_1_0_GlDeleteLists2(void* ptr, unsigned int list, int ran)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glDeleteLists(list, ran);
}
void QOpenGLFunctions_1_0_GlDepthFunc2(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_1_0_GlDepthMask2(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_1_0_GlDisable2(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_1_0_GlDrawBuffer2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glDrawBuffer(mode);
}
void QOpenGLFunctions_1_0_GlDrawPixels2(void* ptr, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glDrawPixels(width, height, format, ty, pixels);
}
void QOpenGLFunctions_1_0_GlEdgeFlag2(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glEdgeFlag(flag != 0);
}
void QOpenGLFunctions_1_0_GlEdgeFlagv2(void* ptr, char flag)
{
Q_UNUSED(flag);
static_cast<QOpenGLFunctions_1_0*>(ptr)->glEdgeFlagv(NULL);
}
void QOpenGLFunctions_1_0_GlEnable2(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_1_0_GlEnd2(void* ptr)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glEnd();
}
void QOpenGLFunctions_1_0_GlEndList2(void* ptr)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glEndList();
}
void QOpenGLFunctions_1_0_GlEvalCoord1f2(void* ptr, float u)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glEvalCoord1f(u);
}
void QOpenGLFunctions_1_0_GlEvalCoord1fv2(void* ptr, float u)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glEvalCoord1fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_1_0_GlEvalCoord2f2(void* ptr, float u, float v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glEvalCoord2f(u, v);
}
void QOpenGLFunctions_1_0_GlEvalCoord2fv2(void* ptr, float u)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glEvalCoord2fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_1_0_GlEvalMesh12(void* ptr, unsigned int mode, int i1, int i2)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glEvalMesh1(mode, i1, i2);
}
void QOpenGLFunctions_1_0_GlEvalMesh22(void* ptr, unsigned int mode, int i1, int i2, int j1, int j2)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glEvalMesh2(mode, i1, i2, j1, j2);
}
void QOpenGLFunctions_1_0_GlEvalPoint12(void* ptr, int i)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glEvalPoint1(i);
}
void QOpenGLFunctions_1_0_GlEvalPoint22(void* ptr, int i, int j)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glEvalPoint2(i, j);
}
void QOpenGLFunctions_1_0_GlFeedbackBuffer2(void* ptr, int size, unsigned int ty, float buffer)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glFeedbackBuffer(size, ty, &buffer);
}
void QOpenGLFunctions_1_0_GlFinish2(void* ptr)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glFinish();
}
void QOpenGLFunctions_1_0_GlFlush2(void* ptr)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glFlush();
}
void QOpenGLFunctions_1_0_GlFogf2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glFogf(pname, param);
}
void QOpenGLFunctions_1_0_GlFogfv2(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glFogfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_0_GlFogi2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glFogi(pname, param);
}
void QOpenGLFunctions_1_0_GlFogiv2(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glFogiv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_0_GlFrontFace2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_1_0_GlGetBooleanv2(void* ptr, unsigned int pname, char params)
{
Q_UNUSED(params);
static_cast<QOpenGLFunctions_1_0*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_1_0_GlGetFloatv2(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glGetFloatv(pname, &params);
}
void QOpenGLFunctions_1_0_GlGetIntegerv2(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glGetIntegerv(pname, &params);
}
void QOpenGLFunctions_1_0_GlGetLightfv2(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glGetLightfv(light, pname, &params);
}
void QOpenGLFunctions_1_0_GlGetLightiv2(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glGetLightiv(light, pname, &params);
}
void QOpenGLFunctions_1_0_GlGetMapfv2(void* ptr, unsigned int target, unsigned int query, float v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glGetMapfv(target, query, &v);
}
void QOpenGLFunctions_1_0_GlGetMapiv2(void* ptr, unsigned int target, unsigned int query, int v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glGetMapiv(target, query, &v);
}
void QOpenGLFunctions_1_0_GlGetMaterialfv2(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glGetMaterialfv(face, pname, &params);
}
void QOpenGLFunctions_1_0_GlGetMaterialiv2(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glGetMaterialiv(face, pname, &params);
}
void QOpenGLFunctions_1_0_GlGetPixelMapfv2(void* ptr, unsigned int m, float values)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glGetPixelMapfv(m, &values);
}
void QOpenGLFunctions_1_0_GlGetPixelMapuiv2(void* ptr, unsigned int m, unsigned int values)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glGetPixelMapuiv(m, &values);
}
void QOpenGLFunctions_1_0_GlGetPixelMapusv2(void* ptr, unsigned int m, unsigned short values)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glGetPixelMapusv(m, &values);
}
void QOpenGLFunctions_1_0_GlGetPolygonStipple2(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glGetPolygonStipple(static_cast<GLubyte*>(static_cast<void*>(mask)));
}
void QOpenGLFunctions_1_0_GlGetTexEnvfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glGetTexEnvfv(target, pname, &params);
}
void QOpenGLFunctions_1_0_GlGetTexEnviv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glGetTexEnviv(target, pname, &params);
}
void QOpenGLFunctions_1_0_GlGetTexGenfv2(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glGetTexGenfv(coord, pname, &params);
}
void QOpenGLFunctions_1_0_GlGetTexGeniv2(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glGetTexGeniv(coord, pname, &params);
}
void QOpenGLFunctions_1_0_GlGetTexImage2(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_1_0_GlGetTexLevelParameterfv2(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_1_0_GlGetTexLevelParameteriv2(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_1_0_GlGetTexParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_1_0_GlGetTexParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_1_0_GlHint2(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_1_0_GlIndexMask2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glIndexMask(mask);
}
void QOpenGLFunctions_1_0_GlIndexf2(void* ptr, float c)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glIndexf(c);
}
void QOpenGLFunctions_1_0_GlIndexfv2(void* ptr, float c)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glIndexfv(const_cast<const GLfloat*>(&c));
}
void QOpenGLFunctions_1_0_GlIndexi2(void* ptr, int c)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glIndexi(c);
}
void QOpenGLFunctions_1_0_GlIndexiv2(void* ptr, int c)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glIndexiv(const_cast<const GLint*>(&c));
}
void QOpenGLFunctions_1_0_GlIndexs2(void* ptr, short c)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glIndexs(c);
}
void QOpenGLFunctions_1_0_GlIndexsv2(void* ptr, short c)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glIndexsv(const_cast<const GLshort*>(&c));
}
void QOpenGLFunctions_1_0_GlInitNames2(void* ptr)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glInitNames();
}
void QOpenGLFunctions_1_0_GlLightModelf2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glLightModelf(pname, param);
}
void QOpenGLFunctions_1_0_GlLightModelfv2(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glLightModelfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_0_GlLightModeli2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glLightModeli(pname, param);
}
void QOpenGLFunctions_1_0_GlLightModeliv2(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glLightModeliv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_0_GlLightf2(void* ptr, unsigned int light, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glLightf(light, pname, param);
}
void QOpenGLFunctions_1_0_GlLightfv2(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glLightfv(light, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_0_GlLighti2(void* ptr, unsigned int light, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glLighti(light, pname, param);
}
void QOpenGLFunctions_1_0_GlLightiv2(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glLightiv(light, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_0_GlLineStipple2(void* ptr, int factor, unsigned short pattern)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glLineStipple(factor, pattern);
}
void QOpenGLFunctions_1_0_GlLineWidth2(void* ptr, float width)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_1_0_GlListBase2(void* ptr, unsigned int base)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glListBase(base);
}
void QOpenGLFunctions_1_0_GlLoadIdentity2(void* ptr)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glLoadIdentity();
}
void QOpenGLFunctions_1_0_GlLoadMatrixf2(void* ptr, float m)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glLoadMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_1_0_GlLoadName2(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glLoadName(name);
}
void QOpenGLFunctions_1_0_GlLogicOp2(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_1_0_GlMap1f2(void* ptr, unsigned int target, float u1, float u2, int stride, int order, float points)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glMap1f(target, u1, u2, stride, order, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_1_0_GlMap2f2(void* ptr, unsigned int target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float points)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_1_0_GlMapGrid1f2(void* ptr, int un, float u1, float u2)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glMapGrid1f(un, u1, u2);
}
void QOpenGLFunctions_1_0_GlMapGrid2f2(void* ptr, int un, float u1, float u2, int vn, float v1, float v2)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glMapGrid2f(un, u1, u2, vn, v1, v2);
}
void QOpenGLFunctions_1_0_GlMaterialf2(void* ptr, unsigned int face, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glMaterialf(face, pname, param);
}
void QOpenGLFunctions_1_0_GlMaterialfv2(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glMaterialfv(face, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_0_GlMateriali2(void* ptr, unsigned int face, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glMateriali(face, pname, param);
}
void QOpenGLFunctions_1_0_GlMaterialiv2(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glMaterialiv(face, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_0_GlMatrixMode2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glMatrixMode(mode);
}
void QOpenGLFunctions_1_0_GlMultMatrixf2(void* ptr, float m)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glMultMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_1_0_GlNewList2(void* ptr, unsigned int list, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glNewList(list, mode);
}
void QOpenGLFunctions_1_0_GlNormal3f2(void* ptr, float nx, float ny, float nz)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glNormal3f(nx, ny, nz);
}
void QOpenGLFunctions_1_0_GlNormal3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glNormal3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_0_GlNormal3i2(void* ptr, int nx, int ny, int nz)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glNormal3i(nx, ny, nz);
}
void QOpenGLFunctions_1_0_GlNormal3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glNormal3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_0_GlNormal3s2(void* ptr, short nx, short ny, short nz)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glNormal3s(nx, ny, nz);
}
void QOpenGLFunctions_1_0_GlNormal3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glNormal3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_0_GlPassThrough2(void* ptr, float token)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glPassThrough(token);
}
void QOpenGLFunctions_1_0_GlPixelMapfv2(void* ptr, unsigned int m, int mapsize, float values)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glPixelMapfv(m, mapsize, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_1_0_GlPixelMapuiv2(void* ptr, unsigned int m, int mapsize, unsigned int values)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glPixelMapuiv(m, mapsize, const_cast<const GLuint*>(&values));
}
void QOpenGLFunctions_1_0_GlPixelMapusv2(void* ptr, unsigned int m, int mapsize, unsigned short values)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glPixelMapusv(m, mapsize, const_cast<const GLushort*>(&values));
}
void QOpenGLFunctions_1_0_GlPixelStoref2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_1_0_GlPixelStorei2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_1_0_GlPixelTransferf2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glPixelTransferf(pname, param);
}
void QOpenGLFunctions_1_0_GlPixelTransferi2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glPixelTransferi(pname, param);
}
void QOpenGLFunctions_1_0_GlPixelZoom2(void* ptr, float xfactor, float yfactor)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glPixelZoom(xfactor, yfactor);
}
void QOpenGLFunctions_1_0_GlPointSize2(void* ptr, float size)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_1_0_GlPolygonMode2(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_1_0_GlPolygonStipple2(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glPolygonStipple(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(mask))));
}
void QOpenGLFunctions_1_0_GlPopAttrib2(void* ptr)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glPopAttrib();
}
void QOpenGLFunctions_1_0_GlPopMatrix2(void* ptr)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glPopMatrix();
}
void QOpenGLFunctions_1_0_GlPopName2(void* ptr)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glPopName();
}
void QOpenGLFunctions_1_0_GlPushAttrib2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glPushAttrib(mask);
}
void QOpenGLFunctions_1_0_GlPushMatrix2(void* ptr)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glPushMatrix();
}
void QOpenGLFunctions_1_0_GlPushName2(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glPushName(name);
}
void QOpenGLFunctions_1_0_GlRasterPos2f2(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRasterPos2f(x, y);
}
void QOpenGLFunctions_1_0_GlRasterPos2fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRasterPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_0_GlRasterPos2i2(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRasterPos2i(x, y);
}
void QOpenGLFunctions_1_0_GlRasterPos2iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRasterPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_0_GlRasterPos2s2(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRasterPos2s(x, y);
}
void QOpenGLFunctions_1_0_GlRasterPos2sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRasterPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_0_GlRasterPos3f2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRasterPos3f(x, y, z);
}
void QOpenGLFunctions_1_0_GlRasterPos3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRasterPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_0_GlRasterPos3i2(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRasterPos3i(x, y, z);
}
void QOpenGLFunctions_1_0_GlRasterPos3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRasterPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_0_GlRasterPos3s2(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRasterPos3s(x, y, z);
}
void QOpenGLFunctions_1_0_GlRasterPos3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRasterPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_0_GlRasterPos4f2(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRasterPos4f(x, y, z, w);
}
void QOpenGLFunctions_1_0_GlRasterPos4fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRasterPos4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_0_GlRasterPos4i2(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRasterPos4i(x, y, z, w);
}
void QOpenGLFunctions_1_0_GlRasterPos4iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRasterPos4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_0_GlRasterPos4s2(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRasterPos4s(x, y, z, w);
}
void QOpenGLFunctions_1_0_GlRasterPos4sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRasterPos4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_0_GlReadBuffer2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glReadBuffer(mode);
}
void QOpenGLFunctions_1_0_GlReadPixels2(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_1_0_GlRectf2(void* ptr, float x1, float y1, float x2, float y2)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRectf(x1, y1, x2, y2);
}
void QOpenGLFunctions_1_0_GlRectfv2(void* ptr, float v1, float v2)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRectfv(const_cast<const GLfloat*>(&v1), const_cast<const GLfloat*>(&v2));
}
void QOpenGLFunctions_1_0_GlRecti2(void* ptr, int x1, int y1, int x2, int y2)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRecti(x1, y1, x2, y2);
}
void QOpenGLFunctions_1_0_GlRectiv2(void* ptr, int v1, int v2)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRectiv(const_cast<const GLint*>(&v1), const_cast<const GLint*>(&v2));
}
void QOpenGLFunctions_1_0_GlRects2(void* ptr, short x1, short y1, short x2, short y2)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRects(x1, y1, x2, y2);
}
void QOpenGLFunctions_1_0_GlRectsv2(void* ptr, short v1, short v2)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRectsv(const_cast<const GLshort*>(&v1), const_cast<const GLshort*>(&v2));
}
void QOpenGLFunctions_1_0_GlRotatef2(void* ptr, float angle, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glRotatef(angle, x, y, z);
}
void QOpenGLFunctions_1_0_GlScalef2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glScalef(x, y, z);
}
void QOpenGLFunctions_1_0_GlScissor2(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_1_0_GlSelectBuffer2(void* ptr, int size, unsigned int buffer)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glSelectBuffer(size, &buffer);
}
void QOpenGLFunctions_1_0_GlShadeModel2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glShadeModel(mode);
}
void QOpenGLFunctions_1_0_GlStencilFunc2(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_1_0_GlStencilMask2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_1_0_GlStencilOp2(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_1_0_GlTexCoord1f2(void* ptr, float s)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexCoord1f(s);
}
void QOpenGLFunctions_1_0_GlTexCoord1fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexCoord1fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_0_GlTexCoord1i2(void* ptr, int s)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexCoord1i(s);
}
void QOpenGLFunctions_1_0_GlTexCoord1iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexCoord1iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_0_GlTexCoord1s2(void* ptr, short s)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexCoord1s(s);
}
void QOpenGLFunctions_1_0_GlTexCoord1sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexCoord1sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_0_GlTexCoord2f2(void* ptr, float s, float t)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexCoord2f(s, t);
}
void QOpenGLFunctions_1_0_GlTexCoord2fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexCoord2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_0_GlTexCoord2i2(void* ptr, int s, int t)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexCoord2i(s, t);
}
void QOpenGLFunctions_1_0_GlTexCoord2iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexCoord2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_0_GlTexCoord2s2(void* ptr, short s, short t)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexCoord2s(s, t);
}
void QOpenGLFunctions_1_0_GlTexCoord2sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexCoord2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_0_GlTexCoord3f2(void* ptr, float s, float t, float r)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexCoord3f(s, t, r);
}
void QOpenGLFunctions_1_0_GlTexCoord3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexCoord3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_0_GlTexCoord3i2(void* ptr, int s, int t, int r)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexCoord3i(s, t, r);
}
void QOpenGLFunctions_1_0_GlTexCoord3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexCoord3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_0_GlTexCoord3s2(void* ptr, short s, short t, short r)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexCoord3s(s, t, r);
}
void QOpenGLFunctions_1_0_GlTexCoord3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexCoord3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_0_GlTexCoord4f2(void* ptr, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexCoord4f(s, t, r, q);
}
void QOpenGLFunctions_1_0_GlTexCoord4fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexCoord4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_0_GlTexCoord4i2(void* ptr, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexCoord4i(s, t, r, q);
}
void QOpenGLFunctions_1_0_GlTexCoord4iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexCoord4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_0_GlTexCoord4s2(void* ptr, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexCoord4s(s, t, r, q);
}
void QOpenGLFunctions_1_0_GlTexCoord4sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexCoord4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_0_GlTexEnvf2(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexEnvf(target, pname, param);
}
void QOpenGLFunctions_1_0_GlTexEnvfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexEnvfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_0_GlTexEnvi2(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexEnvi(target, pname, param);
}
void QOpenGLFunctions_1_0_GlTexEnviv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexEnviv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_0_GlTexGenf2(void* ptr, unsigned int coord, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexGenf(coord, pname, param);
}
void QOpenGLFunctions_1_0_GlTexGenfv2(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexGenfv(coord, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_0_GlTexGeni2(void* ptr, unsigned int coord, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexGeni(coord, pname, param);
}
void QOpenGLFunctions_1_0_GlTexGeniv2(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexGeniv(coord, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_0_GlTexImage1D2(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_1_0_GlTexImage2D2(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_1_0_GlTexParameterf2(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_1_0_GlTexParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_0_GlTexParameteri2(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_1_0_GlTexParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_0_GlTranslatef2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glTranslatef(x, y, z);
}
void QOpenGLFunctions_1_0_GlVertex2f2(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glVertex2f(x, y);
}
void QOpenGLFunctions_1_0_GlVertex2fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glVertex2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_0_GlVertex2i2(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glVertex2i(x, y);
}
void QOpenGLFunctions_1_0_GlVertex2iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glVertex2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_0_GlVertex2s2(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glVertex2s(x, y);
}
void QOpenGLFunctions_1_0_GlVertex2sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glVertex2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_0_GlVertex3f2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glVertex3f(x, y, z);
}
void QOpenGLFunctions_1_0_GlVertex3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glVertex3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_0_GlVertex3i2(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glVertex3i(x, y, z);
}
void QOpenGLFunctions_1_0_GlVertex3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glVertex3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_0_GlVertex3s2(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glVertex3s(x, y, z);
}
void QOpenGLFunctions_1_0_GlVertex3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glVertex3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_0_GlVertex4f2(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glVertex4f(x, y, z, w);
}
void QOpenGLFunctions_1_0_GlVertex4fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glVertex4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_0_GlVertex4i2(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glVertex4i(x, y, z, w);
}
void QOpenGLFunctions_1_0_GlVertex4iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glVertex4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_0_GlVertex4s2(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glVertex4s(x, y, z, w);
}
void QOpenGLFunctions_1_0_GlVertex4sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glVertex4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_0_GlViewport2(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_1_0_DestroyQOpenGLFunctions_1_02(void* ptr)
{
static_cast<QOpenGLFunctions_1_0*>(ptr)->~QOpenGLFunctions_1_0();
}
void QOpenGLFunctions_1_0_DestroyQOpenGLFunctions_1_02Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_1_1: public QOpenGLFunctions_1_1
{
public:
MyQOpenGLFunctions_1_1() : QOpenGLFunctions_1_1() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_1_1_InitializeOpenGLFunctions2(this) != 0; };
~MyQOpenGLFunctions_1_1() { callbackQOpenGLFunctions_1_1_DestroyQOpenGLFunctions_1_12(this); };
};
char QOpenGLFunctions_1_1_GlAreTexturesResident2(void* ptr, int n, unsigned int textures, char residences)
{
Q_UNUSED(residences);
return static_cast<QOpenGLFunctions_1_1*>(ptr)->glAreTexturesResident(n, const_cast<const GLuint*>(&textures), NULL);
}
char QOpenGLFunctions_1_1_GlIsEnabled2(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_1_1*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_1_1_GlIsList2(void* ptr, unsigned int list)
{
return static_cast<QOpenGLFunctions_1_1*>(ptr)->glIsList(list);
}
char QOpenGLFunctions_1_1_GlIsTexture2(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_1_1*>(ptr)->glIsTexture(texture);
}
unsigned int QOpenGLFunctions_1_1_GlGetError2(void* ptr)
{
return static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetError();
}
int QOpenGLFunctions_1_1_GlRenderMode2(void* ptr, unsigned int mode)
{
return static_cast<QOpenGLFunctions_1_1*>(ptr)->glRenderMode(mode);
}
unsigned int QOpenGLFunctions_1_1_GlGenLists2(void* ptr, int ran)
{
return static_cast<QOpenGLFunctions_1_1*>(ptr)->glGenLists(ran);
}
void* QOpenGLFunctions_1_1_NewQOpenGLFunctions_1_12()
{
return new MyQOpenGLFunctions_1_1();
}
char QOpenGLFunctions_1_1_InitializeOpenGLFunctions2(void* ptr)
{
return static_cast<QOpenGLFunctions_1_1*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_1_1_InitializeOpenGLFunctions2Default(void* ptr)
{
return static_cast<QOpenGLFunctions_1_1*>(ptr)->QOpenGLFunctions_1_1::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_1_1_GlGetString2(void* ptr, unsigned int name)
{
return ({ char* t1f0c34 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetString(name)))); QtGui_PackedString { t1f0c34, -1 }; });
}
void QOpenGLFunctions_1_1_GlAccum2(void* ptr, unsigned int op, float value)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glAccum(op, value);
}
void QOpenGLFunctions_1_1_GlAlphaFunc2(void* ptr, unsigned int fu, float ref)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glAlphaFunc(fu, ref);
}
void QOpenGLFunctions_1_1_GlArrayElement2(void* ptr, int i)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glArrayElement(i);
}
void QOpenGLFunctions_1_1_GlBegin2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glBegin(mode);
}
void QOpenGLFunctions_1_1_GlBindTexture2(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_1_1_GlBitmap2(void* ptr, int width, int height, float xorig, float yorig, float xmove, float ymove, char* bitmap)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glBitmap(width, height, xorig, yorig, xmove, ymove, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(bitmap))));
}
void QOpenGLFunctions_1_1_GlBlendFunc2(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_1_1_GlCallList2(void* ptr, unsigned int list)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glCallList(list);
}
void QOpenGLFunctions_1_1_GlCallLists2(void* ptr, int n, unsigned int ty, void* lists)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glCallLists(n, ty, lists);
}
void QOpenGLFunctions_1_1_GlClear2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_1_1_GlClearAccum2(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glClearAccum(red, green, blue, alpha);
}
void QOpenGLFunctions_1_1_GlClearColor2(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_1_1_GlClearIndex2(void* ptr, float c)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glClearIndex(c);
}
void QOpenGLFunctions_1_1_GlClearStencil2(void* ptr, int s)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_1_1_GlColor3f2(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColor3f(red, green, blue);
}
void QOpenGLFunctions_1_1_GlColor3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_1_GlColor3i2(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColor3i(red, green, blue);
}
void QOpenGLFunctions_1_1_GlColor3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_1_GlColor3s2(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColor3s(red, green, blue);
}
void QOpenGLFunctions_1_1_GlColor3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_1_GlColor3ub2(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_1_1_GlColor3ubv2(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_1_1_GlColor3ui2(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColor3ui(red, green, blue);
}
void QOpenGLFunctions_1_1_GlColor3uiv2(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_1_1_GlColor3us2(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColor3us(red, green, blue);
}
void QOpenGLFunctions_1_1_GlColor3usv2(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_1_1_GlColor4f2(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColor4f(red, green, blue, alpha);
}
void QOpenGLFunctions_1_1_GlColor4fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColor4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_1_GlColor4i2(void* ptr, int red, int green, int blue, int alpha)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColor4i(red, green, blue, alpha);
}
void QOpenGLFunctions_1_1_GlColor4iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColor4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_1_GlColor4s2(void* ptr, short red, short green, short blue, short alpha)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColor4s(red, green, blue, alpha);
}
void QOpenGLFunctions_1_1_GlColor4sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColor4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_1_GlColor4ub2(void* ptr, char* red, char* green, char* blue, char* alpha)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColor4ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)), *static_cast<GLubyte*>(static_cast<void*>(alpha)));
}
void QOpenGLFunctions_1_1_GlColor4ubv2(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColor4ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_1_1_GlColor4ui2(void* ptr, unsigned int red, unsigned int green, unsigned int blue, unsigned int alpha)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColor4ui(red, green, blue, alpha);
}
void QOpenGLFunctions_1_1_GlColor4uiv2(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColor4uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_1_1_GlColor4us2(void* ptr, unsigned short red, unsigned short green, unsigned short blue, unsigned short alpha)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColor4us(red, green, blue, alpha);
}
void QOpenGLFunctions_1_1_GlColor4usv2(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColor4usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_1_1_GlColorMask2(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_1_1_GlColorMaterial2(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColorMaterial(face, mode);
}
void QOpenGLFunctions_1_1_GlColorPointer2(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_1_1_GlCopyPixels2(void* ptr, int x, int y, int width, int height, unsigned int ty)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glCopyPixels(x, y, width, height, ty);
}
void QOpenGLFunctions_1_1_GlCopyTexImage1D2(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_1_1_GlCopyTexImage2D2(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_1_1_GlCopyTexSubImage1D2(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_1_1_GlCopyTexSubImage2D2(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_1_1_GlCullFace2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_1_1_GlDeleteLists2(void* ptr, unsigned int list, int ran)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glDeleteLists(list, ran);
}
void QOpenGLFunctions_1_1_GlDeleteTextures2(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_1_1_GlDepthFunc2(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_1_1_GlDepthMask2(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_1_1_GlDisable2(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_1_1_GlDisableClientState2(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glDisableClientState(array);
}
void QOpenGLFunctions_1_1_GlDrawArrays2(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_1_1_GlDrawBuffer2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glDrawBuffer(mode);
}
void QOpenGLFunctions_1_1_GlDrawElements2(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_1_1_GlDrawPixels2(void* ptr, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glDrawPixels(width, height, format, ty, pixels);
}
void QOpenGLFunctions_1_1_GlEdgeFlag2(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glEdgeFlag(flag != 0);
}
void QOpenGLFunctions_1_1_GlEdgeFlagPointer2(void* ptr, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glEdgeFlagPointer(stride, pointer);
}
void QOpenGLFunctions_1_1_GlEdgeFlagv2(void* ptr, char flag)
{
Q_UNUSED(flag);
static_cast<QOpenGLFunctions_1_1*>(ptr)->glEdgeFlagv(NULL);
}
void QOpenGLFunctions_1_1_GlEnable2(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_1_1_GlEnableClientState2(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glEnableClientState(array);
}
void QOpenGLFunctions_1_1_GlEnd2(void* ptr)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glEnd();
}
void QOpenGLFunctions_1_1_GlEndList2(void* ptr)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glEndList();
}
void QOpenGLFunctions_1_1_GlEvalCoord1f2(void* ptr, float u)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glEvalCoord1f(u);
}
void QOpenGLFunctions_1_1_GlEvalCoord1fv2(void* ptr, float u)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glEvalCoord1fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_1_1_GlEvalCoord2f2(void* ptr, float u, float v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glEvalCoord2f(u, v);
}
void QOpenGLFunctions_1_1_GlEvalCoord2fv2(void* ptr, float u)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glEvalCoord2fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_1_1_GlEvalMesh12(void* ptr, unsigned int mode, int i1, int i2)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glEvalMesh1(mode, i1, i2);
}
void QOpenGLFunctions_1_1_GlEvalMesh22(void* ptr, unsigned int mode, int i1, int i2, int j1, int j2)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glEvalMesh2(mode, i1, i2, j1, j2);
}
void QOpenGLFunctions_1_1_GlEvalPoint12(void* ptr, int i)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glEvalPoint1(i);
}
void QOpenGLFunctions_1_1_GlEvalPoint22(void* ptr, int i, int j)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glEvalPoint2(i, j);
}
void QOpenGLFunctions_1_1_GlFeedbackBuffer2(void* ptr, int size, unsigned int ty, float buffer)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glFeedbackBuffer(size, ty, &buffer);
}
void QOpenGLFunctions_1_1_GlFinish2(void* ptr)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glFinish();
}
void QOpenGLFunctions_1_1_GlFlush2(void* ptr)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glFlush();
}
void QOpenGLFunctions_1_1_GlFogf2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glFogf(pname, param);
}
void QOpenGLFunctions_1_1_GlFogfv2(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glFogfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_1_GlFogi2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glFogi(pname, param);
}
void QOpenGLFunctions_1_1_GlFogiv2(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glFogiv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_1_GlFrontFace2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_1_1_GlGenTextures2(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_1_1_GlGetBooleanv2(void* ptr, unsigned int pname, char params)
{
Q_UNUSED(params);
static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_1_1_GlGetFloatv2(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetFloatv(pname, &params);
}
void QOpenGLFunctions_1_1_GlGetIntegerv2(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetIntegerv(pname, &params);
}
void QOpenGLFunctions_1_1_GlGetLightfv2(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetLightfv(light, pname, &params);
}
void QOpenGLFunctions_1_1_GlGetLightiv2(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetLightiv(light, pname, &params);
}
void QOpenGLFunctions_1_1_GlGetMapfv2(void* ptr, unsigned int target, unsigned int query, float v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetMapfv(target, query, &v);
}
void QOpenGLFunctions_1_1_GlGetMapiv2(void* ptr, unsigned int target, unsigned int query, int v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetMapiv(target, query, &v);
}
void QOpenGLFunctions_1_1_GlGetMaterialfv2(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetMaterialfv(face, pname, &params);
}
void QOpenGLFunctions_1_1_GlGetMaterialiv2(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetMaterialiv(face, pname, &params);
}
void QOpenGLFunctions_1_1_GlGetPixelMapfv2(void* ptr, unsigned int m, float values)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetPixelMapfv(m, &values);
}
void QOpenGLFunctions_1_1_GlGetPixelMapuiv2(void* ptr, unsigned int m, unsigned int values)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetPixelMapuiv(m, &values);
}
void QOpenGLFunctions_1_1_GlGetPixelMapusv2(void* ptr, unsigned int m, unsigned short values)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetPixelMapusv(m, &values);
}
void QOpenGLFunctions_1_1_GlGetPointerv2(void* ptr, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetPointerv(pname, &params);
}
void QOpenGLFunctions_1_1_GlGetPolygonStipple2(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetPolygonStipple(static_cast<GLubyte*>(static_cast<void*>(mask)));
}
void QOpenGLFunctions_1_1_GlGetTexEnvfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetTexEnvfv(target, pname, &params);
}
void QOpenGLFunctions_1_1_GlGetTexEnviv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetTexEnviv(target, pname, &params);
}
void QOpenGLFunctions_1_1_GlGetTexGenfv2(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetTexGenfv(coord, pname, &params);
}
void QOpenGLFunctions_1_1_GlGetTexGeniv2(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetTexGeniv(coord, pname, &params);
}
void QOpenGLFunctions_1_1_GlGetTexImage2(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_1_1_GlGetTexLevelParameterfv2(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_1_1_GlGetTexLevelParameteriv2(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_1_1_GlGetTexParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_1_1_GlGetTexParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_1_1_GlHint2(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_1_1_GlIndexMask2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glIndexMask(mask);
}
void QOpenGLFunctions_1_1_GlIndexPointer2(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glIndexPointer(ty, stride, pointer);
}
void QOpenGLFunctions_1_1_GlIndexf2(void* ptr, float c)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glIndexf(c);
}
void QOpenGLFunctions_1_1_GlIndexfv2(void* ptr, float c)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glIndexfv(const_cast<const GLfloat*>(&c));
}
void QOpenGLFunctions_1_1_GlIndexi2(void* ptr, int c)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glIndexi(c);
}
void QOpenGLFunctions_1_1_GlIndexiv2(void* ptr, int c)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glIndexiv(const_cast<const GLint*>(&c));
}
void QOpenGLFunctions_1_1_GlIndexs2(void* ptr, short c)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glIndexs(c);
}
void QOpenGLFunctions_1_1_GlIndexsv2(void* ptr, short c)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glIndexsv(const_cast<const GLshort*>(&c));
}
void QOpenGLFunctions_1_1_GlIndexub2(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glIndexub(*static_cast<GLubyte*>(static_cast<void*>(c)));
}
void QOpenGLFunctions_1_1_GlIndexubv2(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glIndexubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(c))));
}
void QOpenGLFunctions_1_1_GlInitNames2(void* ptr)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glInitNames();
}
void QOpenGLFunctions_1_1_GlInterleavedArrays2(void* ptr, unsigned int format, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glInterleavedArrays(format, stride, pointer);
}
void QOpenGLFunctions_1_1_GlLightModelf2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glLightModelf(pname, param);
}
void QOpenGLFunctions_1_1_GlLightModelfv2(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glLightModelfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_1_GlLightModeli2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glLightModeli(pname, param);
}
void QOpenGLFunctions_1_1_GlLightModeliv2(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glLightModeliv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_1_GlLightf2(void* ptr, unsigned int light, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glLightf(light, pname, param);
}
void QOpenGLFunctions_1_1_GlLightfv2(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glLightfv(light, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_1_GlLighti2(void* ptr, unsigned int light, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glLighti(light, pname, param);
}
void QOpenGLFunctions_1_1_GlLightiv2(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glLightiv(light, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_1_GlLineStipple2(void* ptr, int factor, unsigned short pattern)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glLineStipple(factor, pattern);
}
void QOpenGLFunctions_1_1_GlLineWidth2(void* ptr, float width)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_1_1_GlListBase2(void* ptr, unsigned int base)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glListBase(base);
}
void QOpenGLFunctions_1_1_GlLoadIdentity2(void* ptr)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glLoadIdentity();
}
void QOpenGLFunctions_1_1_GlLoadMatrixf2(void* ptr, float m)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glLoadMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_1_1_GlLoadName2(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glLoadName(name);
}
void QOpenGLFunctions_1_1_GlLogicOp2(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_1_1_GlMap1f2(void* ptr, unsigned int target, float u1, float u2, int stride, int order, float points)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glMap1f(target, u1, u2, stride, order, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_1_1_GlMap2f2(void* ptr, unsigned int target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float points)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_1_1_GlMapGrid1f2(void* ptr, int un, float u1, float u2)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glMapGrid1f(un, u1, u2);
}
void QOpenGLFunctions_1_1_GlMapGrid2f2(void* ptr, int un, float u1, float u2, int vn, float v1, float v2)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glMapGrid2f(un, u1, u2, vn, v1, v2);
}
void QOpenGLFunctions_1_1_GlMaterialf2(void* ptr, unsigned int face, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glMaterialf(face, pname, param);
}
void QOpenGLFunctions_1_1_GlMaterialfv2(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glMaterialfv(face, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_1_GlMateriali2(void* ptr, unsigned int face, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glMateriali(face, pname, param);
}
void QOpenGLFunctions_1_1_GlMaterialiv2(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glMaterialiv(face, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_1_GlMatrixMode2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glMatrixMode(mode);
}
void QOpenGLFunctions_1_1_GlMultMatrixf2(void* ptr, float m)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glMultMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_1_1_GlNewList2(void* ptr, unsigned int list, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glNewList(list, mode);
}
void QOpenGLFunctions_1_1_GlNormal3f2(void* ptr, float nx, float ny, float nz)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glNormal3f(nx, ny, nz);
}
void QOpenGLFunctions_1_1_GlNormal3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glNormal3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_1_GlNormal3i2(void* ptr, int nx, int ny, int nz)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glNormal3i(nx, ny, nz);
}
void QOpenGLFunctions_1_1_GlNormal3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glNormal3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_1_GlNormal3s2(void* ptr, short nx, short ny, short nz)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glNormal3s(nx, ny, nz);
}
void QOpenGLFunctions_1_1_GlNormal3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glNormal3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_1_GlNormalPointer2(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glNormalPointer(ty, stride, pointer);
}
void QOpenGLFunctions_1_1_GlPassThrough2(void* ptr, float token)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glPassThrough(token);
}
void QOpenGLFunctions_1_1_GlPixelMapfv2(void* ptr, unsigned int m, int mapsize, float values)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glPixelMapfv(m, mapsize, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_1_1_GlPixelMapuiv2(void* ptr, unsigned int m, int mapsize, unsigned int values)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glPixelMapuiv(m, mapsize, const_cast<const GLuint*>(&values));
}
void QOpenGLFunctions_1_1_GlPixelMapusv2(void* ptr, unsigned int m, int mapsize, unsigned short values)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glPixelMapusv(m, mapsize, const_cast<const GLushort*>(&values));
}
void QOpenGLFunctions_1_1_GlPixelStoref2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_1_1_GlPixelStorei2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_1_1_GlPixelTransferf2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glPixelTransferf(pname, param);
}
void QOpenGLFunctions_1_1_GlPixelTransferi2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glPixelTransferi(pname, param);
}
void QOpenGLFunctions_1_1_GlPixelZoom2(void* ptr, float xfactor, float yfactor)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glPixelZoom(xfactor, yfactor);
}
void QOpenGLFunctions_1_1_GlPointSize2(void* ptr, float size)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_1_1_GlPolygonMode2(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_1_1_GlPolygonOffset2(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_1_1_GlPolygonStipple2(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glPolygonStipple(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(mask))));
}
void QOpenGLFunctions_1_1_GlPopAttrib2(void* ptr)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glPopAttrib();
}
void QOpenGLFunctions_1_1_GlPopClientAttrib2(void* ptr)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glPopClientAttrib();
}
void QOpenGLFunctions_1_1_GlPopMatrix2(void* ptr)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glPopMatrix();
}
void QOpenGLFunctions_1_1_GlPopName2(void* ptr)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glPopName();
}
void QOpenGLFunctions_1_1_GlPrioritizeTextures2(void* ptr, int n, unsigned int textures, float priorities)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glPrioritizeTextures(n, const_cast<const GLuint*>(&textures), const_cast<const GLfloat*>(&priorities));
}
void QOpenGLFunctions_1_1_GlPushAttrib2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glPushAttrib(mask);
}
void QOpenGLFunctions_1_1_GlPushClientAttrib2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glPushClientAttrib(mask);
}
void QOpenGLFunctions_1_1_GlPushMatrix2(void* ptr)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glPushMatrix();
}
void QOpenGLFunctions_1_1_GlPushName2(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glPushName(name);
}
void QOpenGLFunctions_1_1_GlRasterPos2f2(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRasterPos2f(x, y);
}
void QOpenGLFunctions_1_1_GlRasterPos2fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRasterPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_1_GlRasterPos2i2(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRasterPos2i(x, y);
}
void QOpenGLFunctions_1_1_GlRasterPos2iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRasterPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_1_GlRasterPos2s2(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRasterPos2s(x, y);
}
void QOpenGLFunctions_1_1_GlRasterPos2sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRasterPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_1_GlRasterPos3f2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRasterPos3f(x, y, z);
}
void QOpenGLFunctions_1_1_GlRasterPos3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRasterPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_1_GlRasterPos3i2(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRasterPos3i(x, y, z);
}
void QOpenGLFunctions_1_1_GlRasterPos3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRasterPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_1_GlRasterPos3s2(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRasterPos3s(x, y, z);
}
void QOpenGLFunctions_1_1_GlRasterPos3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRasterPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_1_GlRasterPos4f2(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRasterPos4f(x, y, z, w);
}
void QOpenGLFunctions_1_1_GlRasterPos4fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRasterPos4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_1_GlRasterPos4i2(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRasterPos4i(x, y, z, w);
}
void QOpenGLFunctions_1_1_GlRasterPos4iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRasterPos4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_1_GlRasterPos4s2(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRasterPos4s(x, y, z, w);
}
void QOpenGLFunctions_1_1_GlRasterPos4sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRasterPos4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_1_GlReadBuffer2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glReadBuffer(mode);
}
void QOpenGLFunctions_1_1_GlReadPixels2(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_1_1_GlRectf2(void* ptr, float x1, float y1, float x2, float y2)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRectf(x1, y1, x2, y2);
}
void QOpenGLFunctions_1_1_GlRectfv2(void* ptr, float v1, float v2)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRectfv(const_cast<const GLfloat*>(&v1), const_cast<const GLfloat*>(&v2));
}
void QOpenGLFunctions_1_1_GlRecti2(void* ptr, int x1, int y1, int x2, int y2)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRecti(x1, y1, x2, y2);
}
void QOpenGLFunctions_1_1_GlRectiv2(void* ptr, int v1, int v2)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRectiv(const_cast<const GLint*>(&v1), const_cast<const GLint*>(&v2));
}
void QOpenGLFunctions_1_1_GlRects2(void* ptr, short x1, short y1, short x2, short y2)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRects(x1, y1, x2, y2);
}
void QOpenGLFunctions_1_1_GlRectsv2(void* ptr, short v1, short v2)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRectsv(const_cast<const GLshort*>(&v1), const_cast<const GLshort*>(&v2));
}
void QOpenGLFunctions_1_1_GlRotatef2(void* ptr, float angle, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glRotatef(angle, x, y, z);
}
void QOpenGLFunctions_1_1_GlScalef2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glScalef(x, y, z);
}
void QOpenGLFunctions_1_1_GlScissor2(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_1_1_GlSelectBuffer2(void* ptr, int size, unsigned int buffer)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glSelectBuffer(size, &buffer);
}
void QOpenGLFunctions_1_1_GlShadeModel2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glShadeModel(mode);
}
void QOpenGLFunctions_1_1_GlStencilFunc2(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_1_1_GlStencilMask2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_1_1_GlStencilOp2(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_1_1_GlTexCoord1f2(void* ptr, float s)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoord1f(s);
}
void QOpenGLFunctions_1_1_GlTexCoord1fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoord1fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_1_GlTexCoord1i2(void* ptr, int s)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoord1i(s);
}
void QOpenGLFunctions_1_1_GlTexCoord1iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoord1iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_1_GlTexCoord1s2(void* ptr, short s)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoord1s(s);
}
void QOpenGLFunctions_1_1_GlTexCoord1sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoord1sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_1_GlTexCoord2f2(void* ptr, float s, float t)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoord2f(s, t);
}
void QOpenGLFunctions_1_1_GlTexCoord2fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoord2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_1_GlTexCoord2i2(void* ptr, int s, int t)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoord2i(s, t);
}
void QOpenGLFunctions_1_1_GlTexCoord2iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoord2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_1_GlTexCoord2s2(void* ptr, short s, short t)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoord2s(s, t);
}
void QOpenGLFunctions_1_1_GlTexCoord2sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoord2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_1_GlTexCoord3f2(void* ptr, float s, float t, float r)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoord3f(s, t, r);
}
void QOpenGLFunctions_1_1_GlTexCoord3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoord3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_1_GlTexCoord3i2(void* ptr, int s, int t, int r)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoord3i(s, t, r);
}
void QOpenGLFunctions_1_1_GlTexCoord3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoord3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_1_GlTexCoord3s2(void* ptr, short s, short t, short r)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoord3s(s, t, r);
}
void QOpenGLFunctions_1_1_GlTexCoord3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoord3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_1_GlTexCoord4f2(void* ptr, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoord4f(s, t, r, q);
}
void QOpenGLFunctions_1_1_GlTexCoord4fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoord4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_1_GlTexCoord4i2(void* ptr, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoord4i(s, t, r, q);
}
void QOpenGLFunctions_1_1_GlTexCoord4iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoord4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_1_GlTexCoord4s2(void* ptr, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoord4s(s, t, r, q);
}
void QOpenGLFunctions_1_1_GlTexCoord4sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoord4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_1_GlTexCoordPointer2(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexCoordPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_1_1_GlTexEnvf2(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexEnvf(target, pname, param);
}
void QOpenGLFunctions_1_1_GlTexEnvfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexEnvfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_1_GlTexEnvi2(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexEnvi(target, pname, param);
}
void QOpenGLFunctions_1_1_GlTexEnviv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexEnviv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_1_GlTexGenf2(void* ptr, unsigned int coord, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexGenf(coord, pname, param);
}
void QOpenGLFunctions_1_1_GlTexGenfv2(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexGenfv(coord, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_1_GlTexGeni2(void* ptr, unsigned int coord, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexGeni(coord, pname, param);
}
void QOpenGLFunctions_1_1_GlTexGeniv2(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexGeniv(coord, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_1_GlTexImage1D2(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_1_1_GlTexImage2D2(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_1_1_GlTexParameterf2(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_1_1_GlTexParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_1_GlTexParameteri2(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_1_1_GlTexParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_1_GlTexSubImage1D2(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_1_1_GlTexSubImage2D2(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_1_1_GlTranslatef2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glTranslatef(x, y, z);
}
void QOpenGLFunctions_1_1_GlVertex2f2(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glVertex2f(x, y);
}
void QOpenGLFunctions_1_1_GlVertex2fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glVertex2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_1_GlVertex2i2(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glVertex2i(x, y);
}
void QOpenGLFunctions_1_1_GlVertex2iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glVertex2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_1_GlVertex2s2(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glVertex2s(x, y);
}
void QOpenGLFunctions_1_1_GlVertex2sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glVertex2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_1_GlVertex3f2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glVertex3f(x, y, z);
}
void QOpenGLFunctions_1_1_GlVertex3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glVertex3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_1_GlVertex3i2(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glVertex3i(x, y, z);
}
void QOpenGLFunctions_1_1_GlVertex3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glVertex3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_1_GlVertex3s2(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glVertex3s(x, y, z);
}
void QOpenGLFunctions_1_1_GlVertex3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glVertex3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_1_GlVertex4f2(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glVertex4f(x, y, z, w);
}
void QOpenGLFunctions_1_1_GlVertex4fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glVertex4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_1_GlVertex4i2(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glVertex4i(x, y, z, w);
}
void QOpenGLFunctions_1_1_GlVertex4iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glVertex4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_1_GlVertex4s2(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glVertex4s(x, y, z, w);
}
void QOpenGLFunctions_1_1_GlVertex4sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glVertex4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_1_GlVertexPointer2(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glVertexPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_1_1_GlViewport2(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_1_1_DestroyQOpenGLFunctions_1_12(void* ptr)
{
static_cast<QOpenGLFunctions_1_1*>(ptr)->~QOpenGLFunctions_1_1();
}
void QOpenGLFunctions_1_1_DestroyQOpenGLFunctions_1_12Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_1_2: public QOpenGLFunctions_1_2
{
public:
MyQOpenGLFunctions_1_2() : QOpenGLFunctions_1_2() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_1_2_InitializeOpenGLFunctions2(this) != 0; };
~MyQOpenGLFunctions_1_2() { callbackQOpenGLFunctions_1_2_DestroyQOpenGLFunctions_1_22(this); };
};
char QOpenGLFunctions_1_2_GlAreTexturesResident2(void* ptr, int n, unsigned int textures, char residences)
{
Q_UNUSED(residences);
return static_cast<QOpenGLFunctions_1_2*>(ptr)->glAreTexturesResident(n, const_cast<const GLuint*>(&textures), NULL);
}
char QOpenGLFunctions_1_2_GlIsEnabled2(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_1_2*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_1_2_GlIsList2(void* ptr, unsigned int list)
{
return static_cast<QOpenGLFunctions_1_2*>(ptr)->glIsList(list);
}
char QOpenGLFunctions_1_2_GlIsTexture2(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_1_2*>(ptr)->glIsTexture(texture);
}
unsigned int QOpenGLFunctions_1_2_GlGetError2(void* ptr)
{
return static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetError();
}
int QOpenGLFunctions_1_2_GlRenderMode2(void* ptr, unsigned int mode)
{
return static_cast<QOpenGLFunctions_1_2*>(ptr)->glRenderMode(mode);
}
unsigned int QOpenGLFunctions_1_2_GlGenLists2(void* ptr, int ran)
{
return static_cast<QOpenGLFunctions_1_2*>(ptr)->glGenLists(ran);
}
void* QOpenGLFunctions_1_2_NewQOpenGLFunctions_1_22()
{
return new MyQOpenGLFunctions_1_2();
}
char QOpenGLFunctions_1_2_InitializeOpenGLFunctions2(void* ptr)
{
return static_cast<QOpenGLFunctions_1_2*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_1_2_InitializeOpenGLFunctions2Default(void* ptr)
{
return static_cast<QOpenGLFunctions_1_2*>(ptr)->QOpenGLFunctions_1_2::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_1_2_GlGetString2(void* ptr, unsigned int name)
{
return ({ char* t553eb8 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetString(name)))); QtGui_PackedString { t553eb8, -1 }; });
}
void QOpenGLFunctions_1_2_GlAccum2(void* ptr, unsigned int op, float value)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glAccum(op, value);
}
void QOpenGLFunctions_1_2_GlAlphaFunc2(void* ptr, unsigned int fu, float ref)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glAlphaFunc(fu, ref);
}
void QOpenGLFunctions_1_2_GlArrayElement2(void* ptr, int i)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glArrayElement(i);
}
void QOpenGLFunctions_1_2_GlBegin2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glBegin(mode);
}
void QOpenGLFunctions_1_2_GlBindTexture2(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_1_2_GlBitmap2(void* ptr, int width, int height, float xorig, float yorig, float xmove, float ymove, char* bitmap)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glBitmap(width, height, xorig, yorig, xmove, ymove, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(bitmap))));
}
void QOpenGLFunctions_1_2_GlBlendColor2(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_1_2_GlBlendEquation2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_1_2_GlBlendFunc2(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_1_2_GlCallList2(void* ptr, unsigned int list)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glCallList(list);
}
void QOpenGLFunctions_1_2_GlCallLists2(void* ptr, int n, unsigned int ty, void* lists)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glCallLists(n, ty, lists);
}
void QOpenGLFunctions_1_2_GlClear2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_1_2_GlClearAccum2(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glClearAccum(red, green, blue, alpha);
}
void QOpenGLFunctions_1_2_GlClearColor2(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_1_2_GlClearIndex2(void* ptr, float c)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glClearIndex(c);
}
void QOpenGLFunctions_1_2_GlClearStencil2(void* ptr, int s)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_1_2_GlColor3f2(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColor3f(red, green, blue);
}
void QOpenGLFunctions_1_2_GlColor3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_2_GlColor3i2(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColor3i(red, green, blue);
}
void QOpenGLFunctions_1_2_GlColor3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_2_GlColor3s2(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColor3s(red, green, blue);
}
void QOpenGLFunctions_1_2_GlColor3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_2_GlColor3ub2(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_1_2_GlColor3ubv2(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_1_2_GlColor3ui2(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColor3ui(red, green, blue);
}
void QOpenGLFunctions_1_2_GlColor3uiv2(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_1_2_GlColor3us2(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColor3us(red, green, blue);
}
void QOpenGLFunctions_1_2_GlColor3usv2(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_1_2_GlColor4f2(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColor4f(red, green, blue, alpha);
}
void QOpenGLFunctions_1_2_GlColor4fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColor4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_2_GlColor4i2(void* ptr, int red, int green, int blue, int alpha)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColor4i(red, green, blue, alpha);
}
void QOpenGLFunctions_1_2_GlColor4iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColor4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_2_GlColor4s2(void* ptr, short red, short green, short blue, short alpha)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColor4s(red, green, blue, alpha);
}
void QOpenGLFunctions_1_2_GlColor4sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColor4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_2_GlColor4ub2(void* ptr, char* red, char* green, char* blue, char* alpha)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColor4ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)), *static_cast<GLubyte*>(static_cast<void*>(alpha)));
}
void QOpenGLFunctions_1_2_GlColor4ubv2(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColor4ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_1_2_GlColor4ui2(void* ptr, unsigned int red, unsigned int green, unsigned int blue, unsigned int alpha)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColor4ui(red, green, blue, alpha);
}
void QOpenGLFunctions_1_2_GlColor4uiv2(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColor4uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_1_2_GlColor4us2(void* ptr, unsigned short red, unsigned short green, unsigned short blue, unsigned short alpha)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColor4us(red, green, blue, alpha);
}
void QOpenGLFunctions_1_2_GlColor4usv2(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColor4usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_1_2_GlColorMask2(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_1_2_GlColorMaterial2(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColorMaterial(face, mode);
}
void QOpenGLFunctions_1_2_GlColorPointer2(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_1_2_GlColorSubTable2(void* ptr, unsigned int target, int start, int count, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColorSubTable(target, start, count, format, ty, data);
}
void QOpenGLFunctions_1_2_GlColorTable2(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColorTable(target, internalformat, width, format, ty, table);
}
void QOpenGLFunctions_1_2_GlColorTableParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColorTableParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_2_GlColorTableParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glColorTableParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_2_GlConvolutionFilter1D2(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glConvolutionFilter1D(target, internalformat, width, format, ty, image);
}
void QOpenGLFunctions_1_2_GlConvolutionFilter2D2(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glConvolutionFilter2D(target, internalformat, width, height, format, ty, image);
}
void QOpenGLFunctions_1_2_GlConvolutionParameterf2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glConvolutionParameterf(target, pname, params);
}
void QOpenGLFunctions_1_2_GlConvolutionParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glConvolutionParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_2_GlConvolutionParameteri2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glConvolutionParameteri(target, pname, params);
}
void QOpenGLFunctions_1_2_GlConvolutionParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glConvolutionParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_2_GlCopyColorSubTable2(void* ptr, unsigned int target, int start, int x, int y, int width)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glCopyColorSubTable(target, start, x, y, width);
}
void QOpenGLFunctions_1_2_GlCopyColorTable2(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glCopyColorTable(target, internalformat, x, y, width);
}
void QOpenGLFunctions_1_2_GlCopyConvolutionFilter1D2(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glCopyConvolutionFilter1D(target, internalformat, x, y, width);
}
void QOpenGLFunctions_1_2_GlCopyConvolutionFilter2D2(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);
}
void QOpenGLFunctions_1_2_GlCopyPixels2(void* ptr, int x, int y, int width, int height, unsigned int ty)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glCopyPixels(x, y, width, height, ty);
}
void QOpenGLFunctions_1_2_GlCopyTexImage1D2(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_1_2_GlCopyTexImage2D2(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_1_2_GlCopyTexSubImage1D2(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_1_2_GlCopyTexSubImage2D2(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_1_2_GlCopyTexSubImage3D2(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_1_2_GlCullFace2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_1_2_GlDeleteLists2(void* ptr, unsigned int list, int ran)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glDeleteLists(list, ran);
}
void QOpenGLFunctions_1_2_GlDeleteTextures2(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_1_2_GlDepthFunc2(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_1_2_GlDepthMask2(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_1_2_GlDisable2(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_1_2_GlDisableClientState2(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glDisableClientState(array);
}
void QOpenGLFunctions_1_2_GlDrawArrays2(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_1_2_GlDrawBuffer2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glDrawBuffer(mode);
}
void QOpenGLFunctions_1_2_GlDrawElements2(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_1_2_GlDrawPixels2(void* ptr, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glDrawPixels(width, height, format, ty, pixels);
}
void QOpenGLFunctions_1_2_GlDrawRangeElements2(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLFunctions_1_2_GlEdgeFlag2(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glEdgeFlag(flag != 0);
}
void QOpenGLFunctions_1_2_GlEdgeFlagPointer2(void* ptr, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glEdgeFlagPointer(stride, pointer);
}
void QOpenGLFunctions_1_2_GlEdgeFlagv2(void* ptr, char flag)
{
Q_UNUSED(flag);
static_cast<QOpenGLFunctions_1_2*>(ptr)->glEdgeFlagv(NULL);
}
void QOpenGLFunctions_1_2_GlEnable2(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_1_2_GlEnableClientState2(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glEnableClientState(array);
}
void QOpenGLFunctions_1_2_GlEnd2(void* ptr)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glEnd();
}
void QOpenGLFunctions_1_2_GlEndList2(void* ptr)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glEndList();
}
void QOpenGLFunctions_1_2_GlEvalCoord1f2(void* ptr, float u)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glEvalCoord1f(u);
}
void QOpenGLFunctions_1_2_GlEvalCoord1fv2(void* ptr, float u)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glEvalCoord1fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_1_2_GlEvalCoord2f2(void* ptr, float u, float v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glEvalCoord2f(u, v);
}
void QOpenGLFunctions_1_2_GlEvalCoord2fv2(void* ptr, float u)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glEvalCoord2fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_1_2_GlEvalMesh12(void* ptr, unsigned int mode, int i1, int i2)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glEvalMesh1(mode, i1, i2);
}
void QOpenGLFunctions_1_2_GlEvalMesh22(void* ptr, unsigned int mode, int i1, int i2, int j1, int j2)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glEvalMesh2(mode, i1, i2, j1, j2);
}
void QOpenGLFunctions_1_2_GlEvalPoint12(void* ptr, int i)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glEvalPoint1(i);
}
void QOpenGLFunctions_1_2_GlEvalPoint22(void* ptr, int i, int j)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glEvalPoint2(i, j);
}
void QOpenGLFunctions_1_2_GlFeedbackBuffer2(void* ptr, int size, unsigned int ty, float buffer)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glFeedbackBuffer(size, ty, &buffer);
}
void QOpenGLFunctions_1_2_GlFinish2(void* ptr)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glFinish();
}
void QOpenGLFunctions_1_2_GlFlush2(void* ptr)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glFlush();
}
void QOpenGLFunctions_1_2_GlFogf2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glFogf(pname, param);
}
void QOpenGLFunctions_1_2_GlFogfv2(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glFogfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_2_GlFogi2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glFogi(pname, param);
}
void QOpenGLFunctions_1_2_GlFogiv2(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glFogiv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_2_GlFrontFace2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_1_2_GlGenTextures2(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_1_2_GlGetBooleanv2(void* ptr, unsigned int pname, char params)
{
Q_UNUSED(params);
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_1_2_GlGetColorTable2(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetColorTable(target, format, ty, table);
}
void QOpenGLFunctions_1_2_GlGetColorTableParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetColorTableParameterfv(target, pname, &params);
}
void QOpenGLFunctions_1_2_GlGetColorTableParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetColorTableParameteriv(target, pname, &params);
}
void QOpenGLFunctions_1_2_GlGetConvolutionFilter2(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetConvolutionFilter(target, format, ty, image);
}
void QOpenGLFunctions_1_2_GlGetConvolutionParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetConvolutionParameterfv(target, pname, &params);
}
void QOpenGLFunctions_1_2_GlGetConvolutionParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetConvolutionParameteriv(target, pname, &params);
}
void QOpenGLFunctions_1_2_GlGetFloatv2(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetFloatv(pname, &params);
}
void QOpenGLFunctions_1_2_GlGetHistogram2(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetHistogram(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_1_2_GlGetHistogramParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetHistogramParameterfv(target, pname, &params);
}
void QOpenGLFunctions_1_2_GlGetHistogramParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetHistogramParameteriv(target, pname, &params);
}
void QOpenGLFunctions_1_2_GlGetIntegerv2(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetIntegerv(pname, &params);
}
void QOpenGLFunctions_1_2_GlGetLightfv2(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetLightfv(light, pname, &params);
}
void QOpenGLFunctions_1_2_GlGetLightiv2(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetLightiv(light, pname, &params);
}
void QOpenGLFunctions_1_2_GlGetMapfv2(void* ptr, unsigned int target, unsigned int query, float v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetMapfv(target, query, &v);
}
void QOpenGLFunctions_1_2_GlGetMapiv2(void* ptr, unsigned int target, unsigned int query, int v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetMapiv(target, query, &v);
}
void QOpenGLFunctions_1_2_GlGetMaterialfv2(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetMaterialfv(face, pname, &params);
}
void QOpenGLFunctions_1_2_GlGetMaterialiv2(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetMaterialiv(face, pname, &params);
}
void QOpenGLFunctions_1_2_GlGetMinmax2(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetMinmax(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_1_2_GlGetMinmaxParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetMinmaxParameterfv(target, pname, &params);
}
void QOpenGLFunctions_1_2_GlGetMinmaxParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetMinmaxParameteriv(target, pname, &params);
}
void QOpenGLFunctions_1_2_GlGetPixelMapfv2(void* ptr, unsigned int m, float values)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetPixelMapfv(m, &values);
}
void QOpenGLFunctions_1_2_GlGetPixelMapuiv2(void* ptr, unsigned int m, unsigned int values)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetPixelMapuiv(m, &values);
}
void QOpenGLFunctions_1_2_GlGetPixelMapusv2(void* ptr, unsigned int m, unsigned short values)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetPixelMapusv(m, &values);
}
void QOpenGLFunctions_1_2_GlGetPointerv2(void* ptr, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetPointerv(pname, &params);
}
void QOpenGLFunctions_1_2_GlGetPolygonStipple2(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetPolygonStipple(static_cast<GLubyte*>(static_cast<void*>(mask)));
}
void QOpenGLFunctions_1_2_GlGetSeparableFilter2(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* row, void* column, void* span)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetSeparableFilter(target, format, ty, row, column, span);
}
void QOpenGLFunctions_1_2_GlGetTexEnvfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetTexEnvfv(target, pname, &params);
}
void QOpenGLFunctions_1_2_GlGetTexEnviv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetTexEnviv(target, pname, &params);
}
void QOpenGLFunctions_1_2_GlGetTexGenfv2(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetTexGenfv(coord, pname, &params);
}
void QOpenGLFunctions_1_2_GlGetTexGeniv2(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetTexGeniv(coord, pname, &params);
}
void QOpenGLFunctions_1_2_GlGetTexImage2(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_1_2_GlGetTexLevelParameterfv2(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_1_2_GlGetTexLevelParameteriv2(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_1_2_GlGetTexParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_1_2_GlGetTexParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_1_2_GlHint2(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_1_2_GlHistogram2(void* ptr, unsigned int target, int width, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glHistogram(target, width, internalformat, sink != 0);
}
void QOpenGLFunctions_1_2_GlIndexMask2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glIndexMask(mask);
}
void QOpenGLFunctions_1_2_GlIndexPointer2(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glIndexPointer(ty, stride, pointer);
}
void QOpenGLFunctions_1_2_GlIndexf2(void* ptr, float c)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glIndexf(c);
}
void QOpenGLFunctions_1_2_GlIndexfv2(void* ptr, float c)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glIndexfv(const_cast<const GLfloat*>(&c));
}
void QOpenGLFunctions_1_2_GlIndexi2(void* ptr, int c)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glIndexi(c);
}
void QOpenGLFunctions_1_2_GlIndexiv2(void* ptr, int c)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glIndexiv(const_cast<const GLint*>(&c));
}
void QOpenGLFunctions_1_2_GlIndexs2(void* ptr, short c)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glIndexs(c);
}
void QOpenGLFunctions_1_2_GlIndexsv2(void* ptr, short c)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glIndexsv(const_cast<const GLshort*>(&c));
}
void QOpenGLFunctions_1_2_GlIndexub2(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glIndexub(*static_cast<GLubyte*>(static_cast<void*>(c)));
}
void QOpenGLFunctions_1_2_GlIndexubv2(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glIndexubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(c))));
}
void QOpenGLFunctions_1_2_GlInitNames2(void* ptr)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glInitNames();
}
void QOpenGLFunctions_1_2_GlInterleavedArrays2(void* ptr, unsigned int format, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glInterleavedArrays(format, stride, pointer);
}
void QOpenGLFunctions_1_2_GlLightModelf2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glLightModelf(pname, param);
}
void QOpenGLFunctions_1_2_GlLightModelfv2(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glLightModelfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_2_GlLightModeli2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glLightModeli(pname, param);
}
void QOpenGLFunctions_1_2_GlLightModeliv2(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glLightModeliv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_2_GlLightf2(void* ptr, unsigned int light, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glLightf(light, pname, param);
}
void QOpenGLFunctions_1_2_GlLightfv2(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glLightfv(light, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_2_GlLighti2(void* ptr, unsigned int light, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glLighti(light, pname, param);
}
void QOpenGLFunctions_1_2_GlLightiv2(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glLightiv(light, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_2_GlLineStipple2(void* ptr, int factor, unsigned short pattern)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glLineStipple(factor, pattern);
}
void QOpenGLFunctions_1_2_GlLineWidth2(void* ptr, float width)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_1_2_GlListBase2(void* ptr, unsigned int base)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glListBase(base);
}
void QOpenGLFunctions_1_2_GlLoadIdentity2(void* ptr)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glLoadIdentity();
}
void QOpenGLFunctions_1_2_GlLoadMatrixf2(void* ptr, float m)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glLoadMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_1_2_GlLoadName2(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glLoadName(name);
}
void QOpenGLFunctions_1_2_GlLogicOp2(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_1_2_GlMap1f2(void* ptr, unsigned int target, float u1, float u2, int stride, int order, float points)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glMap1f(target, u1, u2, stride, order, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_1_2_GlMap2f2(void* ptr, unsigned int target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float points)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_1_2_GlMapGrid1f2(void* ptr, int un, float u1, float u2)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glMapGrid1f(un, u1, u2);
}
void QOpenGLFunctions_1_2_GlMapGrid2f2(void* ptr, int un, float u1, float u2, int vn, float v1, float v2)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glMapGrid2f(un, u1, u2, vn, v1, v2);
}
void QOpenGLFunctions_1_2_GlMaterialf2(void* ptr, unsigned int face, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glMaterialf(face, pname, param);
}
void QOpenGLFunctions_1_2_GlMaterialfv2(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glMaterialfv(face, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_2_GlMateriali2(void* ptr, unsigned int face, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glMateriali(face, pname, param);
}
void QOpenGLFunctions_1_2_GlMaterialiv2(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glMaterialiv(face, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_2_GlMatrixMode2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glMatrixMode(mode);
}
void QOpenGLFunctions_1_2_GlMinmax2(void* ptr, unsigned int target, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glMinmax(target, internalformat, sink != 0);
}
void QOpenGLFunctions_1_2_GlMultMatrixf2(void* ptr, float m)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glMultMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_1_2_GlNewList2(void* ptr, unsigned int list, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glNewList(list, mode);
}
void QOpenGLFunctions_1_2_GlNormal3f2(void* ptr, float nx, float ny, float nz)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glNormal3f(nx, ny, nz);
}
void QOpenGLFunctions_1_2_GlNormal3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glNormal3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_2_GlNormal3i2(void* ptr, int nx, int ny, int nz)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glNormal3i(nx, ny, nz);
}
void QOpenGLFunctions_1_2_GlNormal3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glNormal3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_2_GlNormal3s2(void* ptr, short nx, short ny, short nz)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glNormal3s(nx, ny, nz);
}
void QOpenGLFunctions_1_2_GlNormal3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glNormal3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_2_GlNormalPointer2(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glNormalPointer(ty, stride, pointer);
}
void QOpenGLFunctions_1_2_GlPassThrough2(void* ptr, float token)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glPassThrough(token);
}
void QOpenGLFunctions_1_2_GlPixelMapfv2(void* ptr, unsigned int m, int mapsize, float values)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glPixelMapfv(m, mapsize, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_1_2_GlPixelMapuiv2(void* ptr, unsigned int m, int mapsize, unsigned int values)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glPixelMapuiv(m, mapsize, const_cast<const GLuint*>(&values));
}
void QOpenGLFunctions_1_2_GlPixelMapusv2(void* ptr, unsigned int m, int mapsize, unsigned short values)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glPixelMapusv(m, mapsize, const_cast<const GLushort*>(&values));
}
void QOpenGLFunctions_1_2_GlPixelStoref2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_1_2_GlPixelStorei2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_1_2_GlPixelTransferf2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glPixelTransferf(pname, param);
}
void QOpenGLFunctions_1_2_GlPixelTransferi2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glPixelTransferi(pname, param);
}
void QOpenGLFunctions_1_2_GlPixelZoom2(void* ptr, float xfactor, float yfactor)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glPixelZoom(xfactor, yfactor);
}
void QOpenGLFunctions_1_2_GlPointSize2(void* ptr, float size)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_1_2_GlPolygonMode2(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_1_2_GlPolygonOffset2(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_1_2_GlPolygonStipple2(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glPolygonStipple(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(mask))));
}
void QOpenGLFunctions_1_2_GlPopAttrib2(void* ptr)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glPopAttrib();
}
void QOpenGLFunctions_1_2_GlPopClientAttrib2(void* ptr)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glPopClientAttrib();
}
void QOpenGLFunctions_1_2_GlPopMatrix2(void* ptr)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glPopMatrix();
}
void QOpenGLFunctions_1_2_GlPopName2(void* ptr)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glPopName();
}
void QOpenGLFunctions_1_2_GlPrioritizeTextures2(void* ptr, int n, unsigned int textures, float priorities)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glPrioritizeTextures(n, const_cast<const GLuint*>(&textures), const_cast<const GLfloat*>(&priorities));
}
void QOpenGLFunctions_1_2_GlPushAttrib2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glPushAttrib(mask);
}
void QOpenGLFunctions_1_2_GlPushClientAttrib2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glPushClientAttrib(mask);
}
void QOpenGLFunctions_1_2_GlPushMatrix2(void* ptr)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glPushMatrix();
}
void QOpenGLFunctions_1_2_GlPushName2(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glPushName(name);
}
void QOpenGLFunctions_1_2_GlRasterPos2f2(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRasterPos2f(x, y);
}
void QOpenGLFunctions_1_2_GlRasterPos2fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRasterPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_2_GlRasterPos2i2(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRasterPos2i(x, y);
}
void QOpenGLFunctions_1_2_GlRasterPos2iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRasterPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_2_GlRasterPos2s2(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRasterPos2s(x, y);
}
void QOpenGLFunctions_1_2_GlRasterPos2sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRasterPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_2_GlRasterPos3f2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRasterPos3f(x, y, z);
}
void QOpenGLFunctions_1_2_GlRasterPos3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRasterPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_2_GlRasterPos3i2(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRasterPos3i(x, y, z);
}
void QOpenGLFunctions_1_2_GlRasterPos3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRasterPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_2_GlRasterPos3s2(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRasterPos3s(x, y, z);
}
void QOpenGLFunctions_1_2_GlRasterPos3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRasterPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_2_GlRasterPos4f2(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRasterPos4f(x, y, z, w);
}
void QOpenGLFunctions_1_2_GlRasterPos4fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRasterPos4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_2_GlRasterPos4i2(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRasterPos4i(x, y, z, w);
}
void QOpenGLFunctions_1_2_GlRasterPos4iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRasterPos4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_2_GlRasterPos4s2(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRasterPos4s(x, y, z, w);
}
void QOpenGLFunctions_1_2_GlRasterPos4sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRasterPos4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_2_GlReadBuffer2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glReadBuffer(mode);
}
void QOpenGLFunctions_1_2_GlReadPixels2(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_1_2_GlRectf2(void* ptr, float x1, float y1, float x2, float y2)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRectf(x1, y1, x2, y2);
}
void QOpenGLFunctions_1_2_GlRectfv2(void* ptr, float v1, float v2)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRectfv(const_cast<const GLfloat*>(&v1), const_cast<const GLfloat*>(&v2));
}
void QOpenGLFunctions_1_2_GlRecti2(void* ptr, int x1, int y1, int x2, int y2)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRecti(x1, y1, x2, y2);
}
void QOpenGLFunctions_1_2_GlRectiv2(void* ptr, int v1, int v2)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRectiv(const_cast<const GLint*>(&v1), const_cast<const GLint*>(&v2));
}
void QOpenGLFunctions_1_2_GlRects2(void* ptr, short x1, short y1, short x2, short y2)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRects(x1, y1, x2, y2);
}
void QOpenGLFunctions_1_2_GlRectsv2(void* ptr, short v1, short v2)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRectsv(const_cast<const GLshort*>(&v1), const_cast<const GLshort*>(&v2));
}
void QOpenGLFunctions_1_2_GlResetHistogram2(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glResetHistogram(target);
}
void QOpenGLFunctions_1_2_GlResetMinmax2(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glResetMinmax(target);
}
void QOpenGLFunctions_1_2_GlRotatef2(void* ptr, float angle, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glRotatef(angle, x, y, z);
}
void QOpenGLFunctions_1_2_GlScalef2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glScalef(x, y, z);
}
void QOpenGLFunctions_1_2_GlScissor2(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_1_2_GlSelectBuffer2(void* ptr, int size, unsigned int buffer)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glSelectBuffer(size, &buffer);
}
void QOpenGLFunctions_1_2_GlSeparableFilter2D2(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* row, void* column)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glSeparableFilter2D(target, internalformat, width, height, format, ty, row, column);
}
void QOpenGLFunctions_1_2_GlShadeModel2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glShadeModel(mode);
}
void QOpenGLFunctions_1_2_GlStencilFunc2(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_1_2_GlStencilMask2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_1_2_GlStencilOp2(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_1_2_GlTexCoord1f2(void* ptr, float s)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoord1f(s);
}
void QOpenGLFunctions_1_2_GlTexCoord1fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoord1fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_2_GlTexCoord1i2(void* ptr, int s)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoord1i(s);
}
void QOpenGLFunctions_1_2_GlTexCoord1iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoord1iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_2_GlTexCoord1s2(void* ptr, short s)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoord1s(s);
}
void QOpenGLFunctions_1_2_GlTexCoord1sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoord1sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_2_GlTexCoord2f2(void* ptr, float s, float t)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoord2f(s, t);
}
void QOpenGLFunctions_1_2_GlTexCoord2fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoord2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_2_GlTexCoord2i2(void* ptr, int s, int t)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoord2i(s, t);
}
void QOpenGLFunctions_1_2_GlTexCoord2iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoord2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_2_GlTexCoord2s2(void* ptr, short s, short t)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoord2s(s, t);
}
void QOpenGLFunctions_1_2_GlTexCoord2sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoord2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_2_GlTexCoord3f2(void* ptr, float s, float t, float r)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoord3f(s, t, r);
}
void QOpenGLFunctions_1_2_GlTexCoord3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoord3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_2_GlTexCoord3i2(void* ptr, int s, int t, int r)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoord3i(s, t, r);
}
void QOpenGLFunctions_1_2_GlTexCoord3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoord3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_2_GlTexCoord3s2(void* ptr, short s, short t, short r)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoord3s(s, t, r);
}
void QOpenGLFunctions_1_2_GlTexCoord3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoord3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_2_GlTexCoord4f2(void* ptr, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoord4f(s, t, r, q);
}
void QOpenGLFunctions_1_2_GlTexCoord4fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoord4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_2_GlTexCoord4i2(void* ptr, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoord4i(s, t, r, q);
}
void QOpenGLFunctions_1_2_GlTexCoord4iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoord4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_2_GlTexCoord4s2(void* ptr, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoord4s(s, t, r, q);
}
void QOpenGLFunctions_1_2_GlTexCoord4sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoord4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_2_GlTexCoordPointer2(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexCoordPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_1_2_GlTexEnvf2(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexEnvf(target, pname, param);
}
void QOpenGLFunctions_1_2_GlTexEnvfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexEnvfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_2_GlTexEnvi2(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexEnvi(target, pname, param);
}
void QOpenGLFunctions_1_2_GlTexEnviv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexEnviv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_2_GlTexGenf2(void* ptr, unsigned int coord, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexGenf(coord, pname, param);
}
void QOpenGLFunctions_1_2_GlTexGenfv2(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexGenfv(coord, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_2_GlTexGeni2(void* ptr, unsigned int coord, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexGeni(coord, pname, param);
}
void QOpenGLFunctions_1_2_GlTexGeniv2(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexGeniv(coord, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_2_GlTexImage1D2(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_1_2_GlTexImage2D2(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_1_2_GlTexImage3D2(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLFunctions_1_2_GlTexParameterf2(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_1_2_GlTexParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_2_GlTexParameteri2(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_1_2_GlTexParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_2_GlTexSubImage1D2(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_1_2_GlTexSubImage2D2(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_1_2_GlTexSubImage3D2(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_1_2_GlTranslatef2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glTranslatef(x, y, z);
}
void QOpenGLFunctions_1_2_GlVertex2f2(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glVertex2f(x, y);
}
void QOpenGLFunctions_1_2_GlVertex2fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glVertex2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_2_GlVertex2i2(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glVertex2i(x, y);
}
void QOpenGLFunctions_1_2_GlVertex2iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glVertex2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_2_GlVertex2s2(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glVertex2s(x, y);
}
void QOpenGLFunctions_1_2_GlVertex2sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glVertex2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_2_GlVertex3f2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glVertex3f(x, y, z);
}
void QOpenGLFunctions_1_2_GlVertex3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glVertex3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_2_GlVertex3i2(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glVertex3i(x, y, z);
}
void QOpenGLFunctions_1_2_GlVertex3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glVertex3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_2_GlVertex3s2(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glVertex3s(x, y, z);
}
void QOpenGLFunctions_1_2_GlVertex3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glVertex3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_2_GlVertex4f2(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glVertex4f(x, y, z, w);
}
void QOpenGLFunctions_1_2_GlVertex4fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glVertex4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_2_GlVertex4i2(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glVertex4i(x, y, z, w);
}
void QOpenGLFunctions_1_2_GlVertex4iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glVertex4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_2_GlVertex4s2(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glVertex4s(x, y, z, w);
}
void QOpenGLFunctions_1_2_GlVertex4sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glVertex4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_2_GlVertexPointer2(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glVertexPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_1_2_GlViewport2(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_1_2_DestroyQOpenGLFunctions_1_22(void* ptr)
{
static_cast<QOpenGLFunctions_1_2*>(ptr)->~QOpenGLFunctions_1_2();
}
void QOpenGLFunctions_1_2_DestroyQOpenGLFunctions_1_22Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_1_3: public QOpenGLFunctions_1_3
{
public:
MyQOpenGLFunctions_1_3() : QOpenGLFunctions_1_3() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_1_3_InitializeOpenGLFunctions2(this) != 0; };
~MyQOpenGLFunctions_1_3() { callbackQOpenGLFunctions_1_3_DestroyQOpenGLFunctions_1_32(this); };
};
char QOpenGLFunctions_1_3_GlAreTexturesResident2(void* ptr, int n, unsigned int textures, char residences)
{
Q_UNUSED(residences);
return static_cast<QOpenGLFunctions_1_3*>(ptr)->glAreTexturesResident(n, const_cast<const GLuint*>(&textures), NULL);
}
char QOpenGLFunctions_1_3_GlIsEnabled2(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_1_3*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_1_3_GlIsList2(void* ptr, unsigned int list)
{
return static_cast<QOpenGLFunctions_1_3*>(ptr)->glIsList(list);
}
char QOpenGLFunctions_1_3_GlIsTexture2(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_1_3*>(ptr)->glIsTexture(texture);
}
unsigned int QOpenGLFunctions_1_3_GlGetError2(void* ptr)
{
return static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetError();
}
int QOpenGLFunctions_1_3_GlRenderMode2(void* ptr, unsigned int mode)
{
return static_cast<QOpenGLFunctions_1_3*>(ptr)->glRenderMode(mode);
}
unsigned int QOpenGLFunctions_1_3_GlGenLists2(void* ptr, int ran)
{
return static_cast<QOpenGLFunctions_1_3*>(ptr)->glGenLists(ran);
}
void* QOpenGLFunctions_1_3_NewQOpenGLFunctions_1_32()
{
return new MyQOpenGLFunctions_1_3();
}
char QOpenGLFunctions_1_3_InitializeOpenGLFunctions2(void* ptr)
{
return static_cast<QOpenGLFunctions_1_3*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_1_3_InitializeOpenGLFunctions2Default(void* ptr)
{
return static_cast<QOpenGLFunctions_1_3*>(ptr)->QOpenGLFunctions_1_3::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_1_3_GlGetString2(void* ptr, unsigned int name)
{
return ({ char* t57f4ba = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetString(name)))); QtGui_PackedString { t57f4ba, -1 }; });
}
void QOpenGLFunctions_1_3_GlAccum2(void* ptr, unsigned int op, float value)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glAccum(op, value);
}
void QOpenGLFunctions_1_3_GlActiveTexture2(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glActiveTexture(texture);
}
void QOpenGLFunctions_1_3_GlAlphaFunc2(void* ptr, unsigned int fu, float ref)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glAlphaFunc(fu, ref);
}
void QOpenGLFunctions_1_3_GlArrayElement2(void* ptr, int i)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glArrayElement(i);
}
void QOpenGLFunctions_1_3_GlBegin2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glBegin(mode);
}
void QOpenGLFunctions_1_3_GlBindTexture2(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_1_3_GlBitmap2(void* ptr, int width, int height, float xorig, float yorig, float xmove, float ymove, char* bitmap)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glBitmap(width, height, xorig, yorig, xmove, ymove, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(bitmap))));
}
void QOpenGLFunctions_1_3_GlBlendColor2(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_1_3_GlBlendEquation2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_1_3_GlBlendFunc2(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_1_3_GlCallList2(void* ptr, unsigned int list)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glCallList(list);
}
void QOpenGLFunctions_1_3_GlCallLists2(void* ptr, int n, unsigned int ty, void* lists)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glCallLists(n, ty, lists);
}
void QOpenGLFunctions_1_3_GlClear2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_1_3_GlClearAccum2(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glClearAccum(red, green, blue, alpha);
}
void QOpenGLFunctions_1_3_GlClearColor2(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_1_3_GlClearIndex2(void* ptr, float c)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glClearIndex(c);
}
void QOpenGLFunctions_1_3_GlClearStencil2(void* ptr, int s)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_1_3_GlClientActiveTexture2(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glClientActiveTexture(texture);
}
void QOpenGLFunctions_1_3_GlColor3f2(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColor3f(red, green, blue);
}
void QOpenGLFunctions_1_3_GlColor3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_3_GlColor3i2(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColor3i(red, green, blue);
}
void QOpenGLFunctions_1_3_GlColor3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_3_GlColor3s2(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColor3s(red, green, blue);
}
void QOpenGLFunctions_1_3_GlColor3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_3_GlColor3ub2(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_1_3_GlColor3ubv2(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_1_3_GlColor3ui2(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColor3ui(red, green, blue);
}
void QOpenGLFunctions_1_3_GlColor3uiv2(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_1_3_GlColor3us2(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColor3us(red, green, blue);
}
void QOpenGLFunctions_1_3_GlColor3usv2(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_1_3_GlColor4f2(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColor4f(red, green, blue, alpha);
}
void QOpenGLFunctions_1_3_GlColor4fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColor4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_3_GlColor4i2(void* ptr, int red, int green, int blue, int alpha)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColor4i(red, green, blue, alpha);
}
void QOpenGLFunctions_1_3_GlColor4iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColor4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_3_GlColor4s2(void* ptr, short red, short green, short blue, short alpha)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColor4s(red, green, blue, alpha);
}
void QOpenGLFunctions_1_3_GlColor4sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColor4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_3_GlColor4ub2(void* ptr, char* red, char* green, char* blue, char* alpha)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColor4ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)), *static_cast<GLubyte*>(static_cast<void*>(alpha)));
}
void QOpenGLFunctions_1_3_GlColor4ubv2(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColor4ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_1_3_GlColor4ui2(void* ptr, unsigned int red, unsigned int green, unsigned int blue, unsigned int alpha)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColor4ui(red, green, blue, alpha);
}
void QOpenGLFunctions_1_3_GlColor4uiv2(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColor4uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_1_3_GlColor4us2(void* ptr, unsigned short red, unsigned short green, unsigned short blue, unsigned short alpha)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColor4us(red, green, blue, alpha);
}
void QOpenGLFunctions_1_3_GlColor4usv2(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColor4usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_1_3_GlColorMask2(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_1_3_GlColorMaterial2(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColorMaterial(face, mode);
}
void QOpenGLFunctions_1_3_GlColorPointer2(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_1_3_GlColorSubTable2(void* ptr, unsigned int target, int start, int count, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColorSubTable(target, start, count, format, ty, data);
}
void QOpenGLFunctions_1_3_GlColorTable2(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColorTable(target, internalformat, width, format, ty, table);
}
void QOpenGLFunctions_1_3_GlColorTableParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColorTableParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_3_GlColorTableParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glColorTableParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_3_GlCompressedTexImage1D2(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
void QOpenGLFunctions_1_3_GlCompressedTexImage2D2(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void QOpenGLFunctions_1_3_GlCompressedTexImage3D2(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int depth, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void QOpenGLFunctions_1_3_GlCompressedTexSubImage1D2(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_1_3_GlCompressedTexSubImage2D2(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_1_3_GlCompressedTexSubImage3D2(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_1_3_GlConvolutionFilter1D2(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glConvolutionFilter1D(target, internalformat, width, format, ty, image);
}
void QOpenGLFunctions_1_3_GlConvolutionFilter2D2(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glConvolutionFilter2D(target, internalformat, width, height, format, ty, image);
}
void QOpenGLFunctions_1_3_GlConvolutionParameterf2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glConvolutionParameterf(target, pname, params);
}
void QOpenGLFunctions_1_3_GlConvolutionParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glConvolutionParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_3_GlConvolutionParameteri2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glConvolutionParameteri(target, pname, params);
}
void QOpenGLFunctions_1_3_GlConvolutionParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glConvolutionParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_3_GlCopyColorSubTable2(void* ptr, unsigned int target, int start, int x, int y, int width)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glCopyColorSubTable(target, start, x, y, width);
}
void QOpenGLFunctions_1_3_GlCopyColorTable2(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glCopyColorTable(target, internalformat, x, y, width);
}
void QOpenGLFunctions_1_3_GlCopyConvolutionFilter1D2(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glCopyConvolutionFilter1D(target, internalformat, x, y, width);
}
void QOpenGLFunctions_1_3_GlCopyConvolutionFilter2D2(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);
}
void QOpenGLFunctions_1_3_GlCopyPixels2(void* ptr, int x, int y, int width, int height, unsigned int ty)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glCopyPixels(x, y, width, height, ty);
}
void QOpenGLFunctions_1_3_GlCopyTexImage1D2(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_1_3_GlCopyTexImage2D2(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_1_3_GlCopyTexSubImage1D2(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_1_3_GlCopyTexSubImage2D2(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_1_3_GlCopyTexSubImage3D2(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_1_3_GlCullFace2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_1_3_GlDeleteLists2(void* ptr, unsigned int list, int ran)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glDeleteLists(list, ran);
}
void QOpenGLFunctions_1_3_GlDeleteTextures2(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_1_3_GlDepthFunc2(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_1_3_GlDepthMask2(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_1_3_GlDisable2(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_1_3_GlDisableClientState2(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glDisableClientState(array);
}
void QOpenGLFunctions_1_3_GlDrawArrays2(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_1_3_GlDrawBuffer2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glDrawBuffer(mode);
}
void QOpenGLFunctions_1_3_GlDrawElements2(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_1_3_GlDrawPixels2(void* ptr, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glDrawPixels(width, height, format, ty, pixels);
}
void QOpenGLFunctions_1_3_GlDrawRangeElements2(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLFunctions_1_3_GlEdgeFlag2(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glEdgeFlag(flag != 0);
}
void QOpenGLFunctions_1_3_GlEdgeFlagPointer2(void* ptr, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glEdgeFlagPointer(stride, pointer);
}
void QOpenGLFunctions_1_3_GlEdgeFlagv2(void* ptr, char flag)
{
Q_UNUSED(flag);
static_cast<QOpenGLFunctions_1_3*>(ptr)->glEdgeFlagv(NULL);
}
void QOpenGLFunctions_1_3_GlEnable2(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_1_3_GlEnableClientState2(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glEnableClientState(array);
}
void QOpenGLFunctions_1_3_GlEnd2(void* ptr)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glEnd();
}
void QOpenGLFunctions_1_3_GlEndList2(void* ptr)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glEndList();
}
void QOpenGLFunctions_1_3_GlEvalCoord1f2(void* ptr, float u)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glEvalCoord1f(u);
}
void QOpenGLFunctions_1_3_GlEvalCoord1fv2(void* ptr, float u)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glEvalCoord1fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_1_3_GlEvalCoord2f2(void* ptr, float u, float v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glEvalCoord2f(u, v);
}
void QOpenGLFunctions_1_3_GlEvalCoord2fv2(void* ptr, float u)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glEvalCoord2fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_1_3_GlEvalMesh12(void* ptr, unsigned int mode, int i1, int i2)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glEvalMesh1(mode, i1, i2);
}
void QOpenGLFunctions_1_3_GlEvalMesh22(void* ptr, unsigned int mode, int i1, int i2, int j1, int j2)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glEvalMesh2(mode, i1, i2, j1, j2);
}
void QOpenGLFunctions_1_3_GlEvalPoint12(void* ptr, int i)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glEvalPoint1(i);
}
void QOpenGLFunctions_1_3_GlEvalPoint22(void* ptr, int i, int j)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glEvalPoint2(i, j);
}
void QOpenGLFunctions_1_3_GlFeedbackBuffer2(void* ptr, int size, unsigned int ty, float buffer)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glFeedbackBuffer(size, ty, &buffer);
}
void QOpenGLFunctions_1_3_GlFinish2(void* ptr)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glFinish();
}
void QOpenGLFunctions_1_3_GlFlush2(void* ptr)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glFlush();
}
void QOpenGLFunctions_1_3_GlFogf2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glFogf(pname, param);
}
void QOpenGLFunctions_1_3_GlFogfv2(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glFogfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_3_GlFogi2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glFogi(pname, param);
}
void QOpenGLFunctions_1_3_GlFogiv2(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glFogiv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_3_GlFrontFace2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_1_3_GlGenTextures2(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_1_3_GlGetBooleanv2(void* ptr, unsigned int pname, char params)
{
Q_UNUSED(params);
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_1_3_GlGetColorTable2(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetColorTable(target, format, ty, table);
}
void QOpenGLFunctions_1_3_GlGetColorTableParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetColorTableParameterfv(target, pname, &params);
}
void QOpenGLFunctions_1_3_GlGetColorTableParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetColorTableParameteriv(target, pname, &params);
}
void QOpenGLFunctions_1_3_GlGetCompressedTexImage2(void* ptr, unsigned int target, int level, void* img)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetCompressedTexImage(target, level, img);
}
void QOpenGLFunctions_1_3_GlGetConvolutionFilter2(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetConvolutionFilter(target, format, ty, image);
}
void QOpenGLFunctions_1_3_GlGetConvolutionParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetConvolutionParameterfv(target, pname, &params);
}
void QOpenGLFunctions_1_3_GlGetConvolutionParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetConvolutionParameteriv(target, pname, &params);
}
void QOpenGLFunctions_1_3_GlGetFloatv2(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetFloatv(pname, &params);
}
void QOpenGLFunctions_1_3_GlGetHistogram2(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetHistogram(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_1_3_GlGetHistogramParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetHistogramParameterfv(target, pname, &params);
}
void QOpenGLFunctions_1_3_GlGetHistogramParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetHistogramParameteriv(target, pname, &params);
}
void QOpenGLFunctions_1_3_GlGetIntegerv2(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetIntegerv(pname, &params);
}
void QOpenGLFunctions_1_3_GlGetLightfv2(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetLightfv(light, pname, &params);
}
void QOpenGLFunctions_1_3_GlGetLightiv2(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetLightiv(light, pname, &params);
}
void QOpenGLFunctions_1_3_GlGetMapfv2(void* ptr, unsigned int target, unsigned int query, float v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetMapfv(target, query, &v);
}
void QOpenGLFunctions_1_3_GlGetMapiv2(void* ptr, unsigned int target, unsigned int query, int v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetMapiv(target, query, &v);
}
void QOpenGLFunctions_1_3_GlGetMaterialfv2(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetMaterialfv(face, pname, &params);
}
void QOpenGLFunctions_1_3_GlGetMaterialiv2(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetMaterialiv(face, pname, &params);
}
void QOpenGLFunctions_1_3_GlGetMinmax2(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetMinmax(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_1_3_GlGetMinmaxParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetMinmaxParameterfv(target, pname, &params);
}
void QOpenGLFunctions_1_3_GlGetMinmaxParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetMinmaxParameteriv(target, pname, &params);
}
void QOpenGLFunctions_1_3_GlGetPixelMapfv2(void* ptr, unsigned int m, float values)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetPixelMapfv(m, &values);
}
void QOpenGLFunctions_1_3_GlGetPixelMapuiv2(void* ptr, unsigned int m, unsigned int values)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetPixelMapuiv(m, &values);
}
void QOpenGLFunctions_1_3_GlGetPixelMapusv2(void* ptr, unsigned int m, unsigned short values)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetPixelMapusv(m, &values);
}
void QOpenGLFunctions_1_3_GlGetPointerv2(void* ptr, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetPointerv(pname, &params);
}
void QOpenGLFunctions_1_3_GlGetPolygonStipple2(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetPolygonStipple(static_cast<GLubyte*>(static_cast<void*>(mask)));
}
void QOpenGLFunctions_1_3_GlGetSeparableFilter2(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* row, void* column, void* span)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetSeparableFilter(target, format, ty, row, column, span);
}
void QOpenGLFunctions_1_3_GlGetTexEnvfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetTexEnvfv(target, pname, &params);
}
void QOpenGLFunctions_1_3_GlGetTexEnviv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetTexEnviv(target, pname, &params);
}
void QOpenGLFunctions_1_3_GlGetTexGenfv2(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetTexGenfv(coord, pname, &params);
}
void QOpenGLFunctions_1_3_GlGetTexGeniv2(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetTexGeniv(coord, pname, &params);
}
void QOpenGLFunctions_1_3_GlGetTexImage2(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_1_3_GlGetTexLevelParameterfv2(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_1_3_GlGetTexLevelParameteriv2(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_1_3_GlGetTexParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_1_3_GlGetTexParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_1_3_GlHint2(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_1_3_GlHistogram2(void* ptr, unsigned int target, int width, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glHistogram(target, width, internalformat, sink != 0);
}
void QOpenGLFunctions_1_3_GlIndexMask2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glIndexMask(mask);
}
void QOpenGLFunctions_1_3_GlIndexPointer2(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glIndexPointer(ty, stride, pointer);
}
void QOpenGLFunctions_1_3_GlIndexf2(void* ptr, float c)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glIndexf(c);
}
void QOpenGLFunctions_1_3_GlIndexfv2(void* ptr, float c)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glIndexfv(const_cast<const GLfloat*>(&c));
}
void QOpenGLFunctions_1_3_GlIndexi2(void* ptr, int c)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glIndexi(c);
}
void QOpenGLFunctions_1_3_GlIndexiv2(void* ptr, int c)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glIndexiv(const_cast<const GLint*>(&c));
}
void QOpenGLFunctions_1_3_GlIndexs2(void* ptr, short c)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glIndexs(c);
}
void QOpenGLFunctions_1_3_GlIndexsv2(void* ptr, short c)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glIndexsv(const_cast<const GLshort*>(&c));
}
void QOpenGLFunctions_1_3_GlIndexub2(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glIndexub(*static_cast<GLubyte*>(static_cast<void*>(c)));
}
void QOpenGLFunctions_1_3_GlIndexubv2(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glIndexubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(c))));
}
void QOpenGLFunctions_1_3_GlInitNames2(void* ptr)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glInitNames();
}
void QOpenGLFunctions_1_3_GlInterleavedArrays2(void* ptr, unsigned int format, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glInterleavedArrays(format, stride, pointer);
}
void QOpenGLFunctions_1_3_GlLightModelf2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glLightModelf(pname, param);
}
void QOpenGLFunctions_1_3_GlLightModelfv2(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glLightModelfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_3_GlLightModeli2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glLightModeli(pname, param);
}
void QOpenGLFunctions_1_3_GlLightModeliv2(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glLightModeliv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_3_GlLightf2(void* ptr, unsigned int light, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glLightf(light, pname, param);
}
void QOpenGLFunctions_1_3_GlLightfv2(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glLightfv(light, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_3_GlLighti2(void* ptr, unsigned int light, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glLighti(light, pname, param);
}
void QOpenGLFunctions_1_3_GlLightiv2(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glLightiv(light, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_3_GlLineStipple2(void* ptr, int factor, unsigned short pattern)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glLineStipple(factor, pattern);
}
void QOpenGLFunctions_1_3_GlLineWidth2(void* ptr, float width)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_1_3_GlListBase2(void* ptr, unsigned int base)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glListBase(base);
}
void QOpenGLFunctions_1_3_GlLoadIdentity2(void* ptr)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glLoadIdentity();
}
void QOpenGLFunctions_1_3_GlLoadMatrixf2(void* ptr, float m)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glLoadMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_1_3_GlLoadName2(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glLoadName(name);
}
void QOpenGLFunctions_1_3_GlLoadTransposeMatrixf2(void* ptr, float m)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glLoadTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_1_3_GlLogicOp2(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_1_3_GlMap1f2(void* ptr, unsigned int target, float u1, float u2, int stride, int order, float points)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMap1f(target, u1, u2, stride, order, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_1_3_GlMap2f2(void* ptr, unsigned int target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float points)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_1_3_GlMapGrid1f2(void* ptr, int un, float u1, float u2)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMapGrid1f(un, u1, u2);
}
void QOpenGLFunctions_1_3_GlMapGrid2f2(void* ptr, int un, float u1, float u2, int vn, float v1, float v2)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMapGrid2f(un, u1, u2, vn, v1, v2);
}
void QOpenGLFunctions_1_3_GlMaterialf2(void* ptr, unsigned int face, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMaterialf(face, pname, param);
}
void QOpenGLFunctions_1_3_GlMaterialfv2(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMaterialfv(face, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_3_GlMateriali2(void* ptr, unsigned int face, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMateriali(face, pname, param);
}
void QOpenGLFunctions_1_3_GlMaterialiv2(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMaterialiv(face, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_3_GlMatrixMode2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMatrixMode(mode);
}
void QOpenGLFunctions_1_3_GlMinmax2(void* ptr, unsigned int target, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMinmax(target, internalformat, sink != 0);
}
void QOpenGLFunctions_1_3_GlMultMatrixf2(void* ptr, float m)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_1_3_GlMultTransposeMatrixf2(void* ptr, float m)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_1_3_GlMultiTexCoord1f2(void* ptr, unsigned int target, float s)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultiTexCoord1f(target, s);
}
void QOpenGLFunctions_1_3_GlMultiTexCoord1fv2(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultiTexCoord1fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_3_GlMultiTexCoord1i2(void* ptr, unsigned int target, int s)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultiTexCoord1i(target, s);
}
void QOpenGLFunctions_1_3_GlMultiTexCoord1iv2(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultiTexCoord1iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_3_GlMultiTexCoord1s2(void* ptr, unsigned int target, short s)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultiTexCoord1s(target, s);
}
void QOpenGLFunctions_1_3_GlMultiTexCoord1sv2(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultiTexCoord1sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_3_GlMultiTexCoord2f2(void* ptr, unsigned int target, float s, float t)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultiTexCoord2f(target, s, t);
}
void QOpenGLFunctions_1_3_GlMultiTexCoord2fv2(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultiTexCoord2fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_3_GlMultiTexCoord2i2(void* ptr, unsigned int target, int s, int t)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultiTexCoord2i(target, s, t);
}
void QOpenGLFunctions_1_3_GlMultiTexCoord2iv2(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultiTexCoord2iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_3_GlMultiTexCoord2s2(void* ptr, unsigned int target, short s, short t)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultiTexCoord2s(target, s, t);
}
void QOpenGLFunctions_1_3_GlMultiTexCoord2sv2(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultiTexCoord2sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_3_GlMultiTexCoord3f2(void* ptr, unsigned int target, float s, float t, float r)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultiTexCoord3f(target, s, t, r);
}
void QOpenGLFunctions_1_3_GlMultiTexCoord3fv2(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultiTexCoord3fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_3_GlMultiTexCoord3i2(void* ptr, unsigned int target, int s, int t, int r)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultiTexCoord3i(target, s, t, r);
}
void QOpenGLFunctions_1_3_GlMultiTexCoord3iv2(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultiTexCoord3iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_3_GlMultiTexCoord3s2(void* ptr, unsigned int target, short s, short t, short r)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultiTexCoord3s(target, s, t, r);
}
void QOpenGLFunctions_1_3_GlMultiTexCoord3sv2(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultiTexCoord3sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_3_GlMultiTexCoord4f2(void* ptr, unsigned int target, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultiTexCoord4f(target, s, t, r, q);
}
void QOpenGLFunctions_1_3_GlMultiTexCoord4fv2(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultiTexCoord4fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_3_GlMultiTexCoord4i2(void* ptr, unsigned int target, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultiTexCoord4i(target, s, t, r, q);
}
void QOpenGLFunctions_1_3_GlMultiTexCoord4iv2(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultiTexCoord4iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_3_GlMultiTexCoord4s2(void* ptr, unsigned int target, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultiTexCoord4s(target, s, t, r, q);
}
void QOpenGLFunctions_1_3_GlMultiTexCoord4sv2(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glMultiTexCoord4sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_3_GlNewList2(void* ptr, unsigned int list, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glNewList(list, mode);
}
void QOpenGLFunctions_1_3_GlNormal3f2(void* ptr, float nx, float ny, float nz)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glNormal3f(nx, ny, nz);
}
void QOpenGLFunctions_1_3_GlNormal3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glNormal3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_3_GlNormal3i2(void* ptr, int nx, int ny, int nz)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glNormal3i(nx, ny, nz);
}
void QOpenGLFunctions_1_3_GlNormal3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glNormal3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_3_GlNormal3s2(void* ptr, short nx, short ny, short nz)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glNormal3s(nx, ny, nz);
}
void QOpenGLFunctions_1_3_GlNormal3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glNormal3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_3_GlNormalPointer2(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glNormalPointer(ty, stride, pointer);
}
void QOpenGLFunctions_1_3_GlPassThrough2(void* ptr, float token)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glPassThrough(token);
}
void QOpenGLFunctions_1_3_GlPixelMapfv2(void* ptr, unsigned int m, int mapsize, float values)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glPixelMapfv(m, mapsize, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_1_3_GlPixelMapuiv2(void* ptr, unsigned int m, int mapsize, unsigned int values)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glPixelMapuiv(m, mapsize, const_cast<const GLuint*>(&values));
}
void QOpenGLFunctions_1_3_GlPixelMapusv2(void* ptr, unsigned int m, int mapsize, unsigned short values)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glPixelMapusv(m, mapsize, const_cast<const GLushort*>(&values));
}
void QOpenGLFunctions_1_3_GlPixelStoref2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_1_3_GlPixelStorei2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_1_3_GlPixelTransferf2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glPixelTransferf(pname, param);
}
void QOpenGLFunctions_1_3_GlPixelTransferi2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glPixelTransferi(pname, param);
}
void QOpenGLFunctions_1_3_GlPixelZoom2(void* ptr, float xfactor, float yfactor)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glPixelZoom(xfactor, yfactor);
}
void QOpenGLFunctions_1_3_GlPointSize2(void* ptr, float size)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_1_3_GlPolygonMode2(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_1_3_GlPolygonOffset2(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_1_3_GlPolygonStipple2(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glPolygonStipple(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(mask))));
}
void QOpenGLFunctions_1_3_GlPopAttrib2(void* ptr)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glPopAttrib();
}
void QOpenGLFunctions_1_3_GlPopClientAttrib2(void* ptr)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glPopClientAttrib();
}
void QOpenGLFunctions_1_3_GlPopMatrix2(void* ptr)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glPopMatrix();
}
void QOpenGLFunctions_1_3_GlPopName2(void* ptr)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glPopName();
}
void QOpenGLFunctions_1_3_GlPrioritizeTextures2(void* ptr, int n, unsigned int textures, float priorities)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glPrioritizeTextures(n, const_cast<const GLuint*>(&textures), const_cast<const GLfloat*>(&priorities));
}
void QOpenGLFunctions_1_3_GlPushAttrib2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glPushAttrib(mask);
}
void QOpenGLFunctions_1_3_GlPushClientAttrib2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glPushClientAttrib(mask);
}
void QOpenGLFunctions_1_3_GlPushMatrix2(void* ptr)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glPushMatrix();
}
void QOpenGLFunctions_1_3_GlPushName2(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glPushName(name);
}
void QOpenGLFunctions_1_3_GlRasterPos2f2(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRasterPos2f(x, y);
}
void QOpenGLFunctions_1_3_GlRasterPos2fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRasterPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_3_GlRasterPos2i2(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRasterPos2i(x, y);
}
void QOpenGLFunctions_1_3_GlRasterPos2iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRasterPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_3_GlRasterPos2s2(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRasterPos2s(x, y);
}
void QOpenGLFunctions_1_3_GlRasterPos2sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRasterPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_3_GlRasterPos3f2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRasterPos3f(x, y, z);
}
void QOpenGLFunctions_1_3_GlRasterPos3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRasterPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_3_GlRasterPos3i2(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRasterPos3i(x, y, z);
}
void QOpenGLFunctions_1_3_GlRasterPos3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRasterPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_3_GlRasterPos3s2(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRasterPos3s(x, y, z);
}
void QOpenGLFunctions_1_3_GlRasterPos3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRasterPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_3_GlRasterPos4f2(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRasterPos4f(x, y, z, w);
}
void QOpenGLFunctions_1_3_GlRasterPos4fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRasterPos4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_3_GlRasterPos4i2(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRasterPos4i(x, y, z, w);
}
void QOpenGLFunctions_1_3_GlRasterPos4iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRasterPos4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_3_GlRasterPos4s2(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRasterPos4s(x, y, z, w);
}
void QOpenGLFunctions_1_3_GlRasterPos4sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRasterPos4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_3_GlReadBuffer2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glReadBuffer(mode);
}
void QOpenGLFunctions_1_3_GlReadPixels2(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_1_3_GlRectf2(void* ptr, float x1, float y1, float x2, float y2)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRectf(x1, y1, x2, y2);
}
void QOpenGLFunctions_1_3_GlRectfv2(void* ptr, float v1, float v2)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRectfv(const_cast<const GLfloat*>(&v1), const_cast<const GLfloat*>(&v2));
}
void QOpenGLFunctions_1_3_GlRecti2(void* ptr, int x1, int y1, int x2, int y2)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRecti(x1, y1, x2, y2);
}
void QOpenGLFunctions_1_3_GlRectiv2(void* ptr, int v1, int v2)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRectiv(const_cast<const GLint*>(&v1), const_cast<const GLint*>(&v2));
}
void QOpenGLFunctions_1_3_GlRects2(void* ptr, short x1, short y1, short x2, short y2)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRects(x1, y1, x2, y2);
}
void QOpenGLFunctions_1_3_GlRectsv2(void* ptr, short v1, short v2)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRectsv(const_cast<const GLshort*>(&v1), const_cast<const GLshort*>(&v2));
}
void QOpenGLFunctions_1_3_GlResetHistogram2(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glResetHistogram(target);
}
void QOpenGLFunctions_1_3_GlResetMinmax2(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glResetMinmax(target);
}
void QOpenGLFunctions_1_3_GlRotatef2(void* ptr, float angle, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glRotatef(angle, x, y, z);
}
void QOpenGLFunctions_1_3_GlSampleCoverage2(void* ptr, float value, char invert)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glSampleCoverage(value, invert != 0);
}
void QOpenGLFunctions_1_3_GlScalef2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glScalef(x, y, z);
}
void QOpenGLFunctions_1_3_GlScissor2(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_1_3_GlSelectBuffer2(void* ptr, int size, unsigned int buffer)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glSelectBuffer(size, &buffer);
}
void QOpenGLFunctions_1_3_GlSeparableFilter2D2(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* row, void* column)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glSeparableFilter2D(target, internalformat, width, height, format, ty, row, column);
}
void QOpenGLFunctions_1_3_GlShadeModel2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glShadeModel(mode);
}
void QOpenGLFunctions_1_3_GlStencilFunc2(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_1_3_GlStencilMask2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_1_3_GlStencilOp2(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_1_3_GlTexCoord1f2(void* ptr, float s)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoord1f(s);
}
void QOpenGLFunctions_1_3_GlTexCoord1fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoord1fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_3_GlTexCoord1i2(void* ptr, int s)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoord1i(s);
}
void QOpenGLFunctions_1_3_GlTexCoord1iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoord1iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_3_GlTexCoord1s2(void* ptr, short s)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoord1s(s);
}
void QOpenGLFunctions_1_3_GlTexCoord1sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoord1sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_3_GlTexCoord2f2(void* ptr, float s, float t)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoord2f(s, t);
}
void QOpenGLFunctions_1_3_GlTexCoord2fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoord2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_3_GlTexCoord2i2(void* ptr, int s, int t)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoord2i(s, t);
}
void QOpenGLFunctions_1_3_GlTexCoord2iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoord2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_3_GlTexCoord2s2(void* ptr, short s, short t)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoord2s(s, t);
}
void QOpenGLFunctions_1_3_GlTexCoord2sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoord2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_3_GlTexCoord3f2(void* ptr, float s, float t, float r)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoord3f(s, t, r);
}
void QOpenGLFunctions_1_3_GlTexCoord3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoord3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_3_GlTexCoord3i2(void* ptr, int s, int t, int r)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoord3i(s, t, r);
}
void QOpenGLFunctions_1_3_GlTexCoord3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoord3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_3_GlTexCoord3s2(void* ptr, short s, short t, short r)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoord3s(s, t, r);
}
void QOpenGLFunctions_1_3_GlTexCoord3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoord3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_3_GlTexCoord4f2(void* ptr, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoord4f(s, t, r, q);
}
void QOpenGLFunctions_1_3_GlTexCoord4fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoord4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_3_GlTexCoord4i2(void* ptr, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoord4i(s, t, r, q);
}
void QOpenGLFunctions_1_3_GlTexCoord4iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoord4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_3_GlTexCoord4s2(void* ptr, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoord4s(s, t, r, q);
}
void QOpenGLFunctions_1_3_GlTexCoord4sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoord4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_3_GlTexCoordPointer2(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexCoordPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_1_3_GlTexEnvf2(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexEnvf(target, pname, param);
}
void QOpenGLFunctions_1_3_GlTexEnvfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexEnvfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_3_GlTexEnvi2(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexEnvi(target, pname, param);
}
void QOpenGLFunctions_1_3_GlTexEnviv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexEnviv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_3_GlTexGenf2(void* ptr, unsigned int coord, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexGenf(coord, pname, param);
}
void QOpenGLFunctions_1_3_GlTexGenfv2(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexGenfv(coord, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_3_GlTexGeni2(void* ptr, unsigned int coord, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexGeni(coord, pname, param);
}
void QOpenGLFunctions_1_3_GlTexGeniv2(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexGeniv(coord, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_3_GlTexImage1D2(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_1_3_GlTexImage2D2(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_1_3_GlTexImage3D2(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLFunctions_1_3_GlTexParameterf2(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_1_3_GlTexParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_3_GlTexParameteri2(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_1_3_GlTexParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_3_GlTexSubImage1D2(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_1_3_GlTexSubImage2D2(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_1_3_GlTexSubImage3D2(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_1_3_GlTranslatef2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glTranslatef(x, y, z);
}
void QOpenGLFunctions_1_3_GlVertex2f2(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glVertex2f(x, y);
}
void QOpenGLFunctions_1_3_GlVertex2fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glVertex2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_3_GlVertex2i2(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glVertex2i(x, y);
}
void QOpenGLFunctions_1_3_GlVertex2iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glVertex2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_3_GlVertex2s2(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glVertex2s(x, y);
}
void QOpenGLFunctions_1_3_GlVertex2sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glVertex2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_3_GlVertex3f2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glVertex3f(x, y, z);
}
void QOpenGLFunctions_1_3_GlVertex3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glVertex3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_3_GlVertex3i2(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glVertex3i(x, y, z);
}
void QOpenGLFunctions_1_3_GlVertex3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glVertex3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_3_GlVertex3s2(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glVertex3s(x, y, z);
}
void QOpenGLFunctions_1_3_GlVertex3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glVertex3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_3_GlVertex4f2(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glVertex4f(x, y, z, w);
}
void QOpenGLFunctions_1_3_GlVertex4fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glVertex4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_3_GlVertex4i2(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glVertex4i(x, y, z, w);
}
void QOpenGLFunctions_1_3_GlVertex4iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glVertex4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_3_GlVertex4s2(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glVertex4s(x, y, z, w);
}
void QOpenGLFunctions_1_3_GlVertex4sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glVertex4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_3_GlVertexPointer2(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glVertexPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_1_3_GlViewport2(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_1_3_DestroyQOpenGLFunctions_1_32(void* ptr)
{
static_cast<QOpenGLFunctions_1_3*>(ptr)->~QOpenGLFunctions_1_3();
}
void QOpenGLFunctions_1_3_DestroyQOpenGLFunctions_1_32Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_1_4: public QOpenGLFunctions_1_4
{
public:
MyQOpenGLFunctions_1_4() : QOpenGLFunctions_1_4() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_1_4_InitializeOpenGLFunctions2(this) != 0; };
~MyQOpenGLFunctions_1_4() { callbackQOpenGLFunctions_1_4_DestroyQOpenGLFunctions_1_42(this); };
};
char QOpenGLFunctions_1_4_GlAreTexturesResident2(void* ptr, int n, unsigned int textures, char residences)
{
Q_UNUSED(residences);
return static_cast<QOpenGLFunctions_1_4*>(ptr)->glAreTexturesResident(n, const_cast<const GLuint*>(&textures), NULL);
}
char QOpenGLFunctions_1_4_GlIsEnabled2(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_1_4*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_1_4_GlIsList2(void* ptr, unsigned int list)
{
return static_cast<QOpenGLFunctions_1_4*>(ptr)->glIsList(list);
}
char QOpenGLFunctions_1_4_GlIsTexture2(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_1_4*>(ptr)->glIsTexture(texture);
}
unsigned int QOpenGLFunctions_1_4_GlGetError2(void* ptr)
{
return static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetError();
}
int QOpenGLFunctions_1_4_GlRenderMode2(void* ptr, unsigned int mode)
{
return static_cast<QOpenGLFunctions_1_4*>(ptr)->glRenderMode(mode);
}
unsigned int QOpenGLFunctions_1_4_GlGenLists2(void* ptr, int ran)
{
return static_cast<QOpenGLFunctions_1_4*>(ptr)->glGenLists(ran);
}
void* QOpenGLFunctions_1_4_NewQOpenGLFunctions_1_42()
{
return new MyQOpenGLFunctions_1_4();
}
char QOpenGLFunctions_1_4_InitializeOpenGLFunctions2(void* ptr)
{
return static_cast<QOpenGLFunctions_1_4*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_1_4_InitializeOpenGLFunctions2Default(void* ptr)
{
return static_cast<QOpenGLFunctions_1_4*>(ptr)->QOpenGLFunctions_1_4::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_1_4_GlGetString2(void* ptr, unsigned int name)
{
return ({ char* t2e577d = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetString(name)))); QtGui_PackedString { t2e577d, -1 }; });
}
void QOpenGLFunctions_1_4_GlAccum2(void* ptr, unsigned int op, float value)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glAccum(op, value);
}
void QOpenGLFunctions_1_4_GlActiveTexture2(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glActiveTexture(texture);
}
void QOpenGLFunctions_1_4_GlAlphaFunc2(void* ptr, unsigned int fu, float ref)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glAlphaFunc(fu, ref);
}
void QOpenGLFunctions_1_4_GlArrayElement2(void* ptr, int i)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glArrayElement(i);
}
void QOpenGLFunctions_1_4_GlBegin2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glBegin(mode);
}
void QOpenGLFunctions_1_4_GlBindTexture2(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_1_4_GlBitmap2(void* ptr, int width, int height, float xorig, float yorig, float xmove, float ymove, char* bitmap)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glBitmap(width, height, xorig, yorig, xmove, ymove, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(bitmap))));
}
void QOpenGLFunctions_1_4_GlBlendColor2(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_1_4_GlBlendEquation2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_1_4_GlBlendFunc2(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_1_4_GlBlendFuncSeparate2(void* ptr, unsigned int sfactorRGB, unsigned int dfactorRGB, unsigned int sfactorAlpha, unsigned int dfactorAlpha)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void QOpenGLFunctions_1_4_GlCallList2(void* ptr, unsigned int list)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glCallList(list);
}
void QOpenGLFunctions_1_4_GlCallLists2(void* ptr, int n, unsigned int ty, void* lists)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glCallLists(n, ty, lists);
}
void QOpenGLFunctions_1_4_GlClear2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_1_4_GlClearAccum2(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glClearAccum(red, green, blue, alpha);
}
void QOpenGLFunctions_1_4_GlClearColor2(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_1_4_GlClearIndex2(void* ptr, float c)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glClearIndex(c);
}
void QOpenGLFunctions_1_4_GlClearStencil2(void* ptr, int s)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_1_4_GlClientActiveTexture2(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glClientActiveTexture(texture);
}
void QOpenGLFunctions_1_4_GlColor3f2(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColor3f(red, green, blue);
}
void QOpenGLFunctions_1_4_GlColor3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_4_GlColor3i2(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColor3i(red, green, blue);
}
void QOpenGLFunctions_1_4_GlColor3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_4_GlColor3s2(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColor3s(red, green, blue);
}
void QOpenGLFunctions_1_4_GlColor3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_4_GlColor3ub2(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_1_4_GlColor3ubv2(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_1_4_GlColor3ui2(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColor3ui(red, green, blue);
}
void QOpenGLFunctions_1_4_GlColor3uiv2(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_1_4_GlColor3us2(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColor3us(red, green, blue);
}
void QOpenGLFunctions_1_4_GlColor3usv2(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_1_4_GlColor4f2(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColor4f(red, green, blue, alpha);
}
void QOpenGLFunctions_1_4_GlColor4fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColor4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_4_GlColor4i2(void* ptr, int red, int green, int blue, int alpha)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColor4i(red, green, blue, alpha);
}
void QOpenGLFunctions_1_4_GlColor4iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColor4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_4_GlColor4s2(void* ptr, short red, short green, short blue, short alpha)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColor4s(red, green, blue, alpha);
}
void QOpenGLFunctions_1_4_GlColor4sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColor4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_4_GlColor4ub2(void* ptr, char* red, char* green, char* blue, char* alpha)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColor4ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)), *static_cast<GLubyte*>(static_cast<void*>(alpha)));
}
void QOpenGLFunctions_1_4_GlColor4ubv2(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColor4ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_1_4_GlColor4ui2(void* ptr, unsigned int red, unsigned int green, unsigned int blue, unsigned int alpha)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColor4ui(red, green, blue, alpha);
}
void QOpenGLFunctions_1_4_GlColor4uiv2(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColor4uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_1_4_GlColor4us2(void* ptr, unsigned short red, unsigned short green, unsigned short blue, unsigned short alpha)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColor4us(red, green, blue, alpha);
}
void QOpenGLFunctions_1_4_GlColor4usv2(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColor4usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_1_4_GlColorMask2(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_1_4_GlColorMaterial2(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColorMaterial(face, mode);
}
void QOpenGLFunctions_1_4_GlColorPointer2(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_1_4_GlColorSubTable2(void* ptr, unsigned int target, int start, int count, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColorSubTable(target, start, count, format, ty, data);
}
void QOpenGLFunctions_1_4_GlColorTable2(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColorTable(target, internalformat, width, format, ty, table);
}
void QOpenGLFunctions_1_4_GlColorTableParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColorTableParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_4_GlColorTableParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glColorTableParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_4_GlCompressedTexImage1D2(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
void QOpenGLFunctions_1_4_GlCompressedTexImage2D2(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void QOpenGLFunctions_1_4_GlCompressedTexImage3D2(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int depth, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void QOpenGLFunctions_1_4_GlCompressedTexSubImage1D2(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_1_4_GlCompressedTexSubImage2D2(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_1_4_GlCompressedTexSubImage3D2(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_1_4_GlConvolutionFilter1D2(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glConvolutionFilter1D(target, internalformat, width, format, ty, image);
}
void QOpenGLFunctions_1_4_GlConvolutionFilter2D2(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glConvolutionFilter2D(target, internalformat, width, height, format, ty, image);
}
void QOpenGLFunctions_1_4_GlConvolutionParameterf2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glConvolutionParameterf(target, pname, params);
}
void QOpenGLFunctions_1_4_GlConvolutionParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glConvolutionParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_4_GlConvolutionParameteri2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glConvolutionParameteri(target, pname, params);
}
void QOpenGLFunctions_1_4_GlConvolutionParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glConvolutionParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_4_GlCopyColorSubTable2(void* ptr, unsigned int target, int start, int x, int y, int width)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glCopyColorSubTable(target, start, x, y, width);
}
void QOpenGLFunctions_1_4_GlCopyColorTable2(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glCopyColorTable(target, internalformat, x, y, width);
}
void QOpenGLFunctions_1_4_GlCopyConvolutionFilter1D2(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glCopyConvolutionFilter1D(target, internalformat, x, y, width);
}
void QOpenGLFunctions_1_4_GlCopyConvolutionFilter2D2(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);
}
void QOpenGLFunctions_1_4_GlCopyPixels2(void* ptr, int x, int y, int width, int height, unsigned int ty)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glCopyPixels(x, y, width, height, ty);
}
void QOpenGLFunctions_1_4_GlCopyTexImage1D2(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_1_4_GlCopyTexImage2D2(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_1_4_GlCopyTexSubImage1D2(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_1_4_GlCopyTexSubImage2D2(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_1_4_GlCopyTexSubImage3D2(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_1_4_GlCullFace2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_1_4_GlDeleteLists2(void* ptr, unsigned int list, int ran)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glDeleteLists(list, ran);
}
void QOpenGLFunctions_1_4_GlDeleteTextures2(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_1_4_GlDepthFunc2(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_1_4_GlDepthMask2(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_1_4_GlDisable2(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_1_4_GlDisableClientState2(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glDisableClientState(array);
}
void QOpenGLFunctions_1_4_GlDrawArrays2(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_1_4_GlDrawBuffer2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glDrawBuffer(mode);
}
void QOpenGLFunctions_1_4_GlDrawElements2(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_1_4_GlDrawPixels2(void* ptr, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glDrawPixels(width, height, format, ty, pixels);
}
void QOpenGLFunctions_1_4_GlDrawRangeElements2(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLFunctions_1_4_GlEdgeFlag2(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glEdgeFlag(flag != 0);
}
void QOpenGLFunctions_1_4_GlEdgeFlagPointer2(void* ptr, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glEdgeFlagPointer(stride, pointer);
}
void QOpenGLFunctions_1_4_GlEdgeFlagv2(void* ptr, char flag)
{
Q_UNUSED(flag);
static_cast<QOpenGLFunctions_1_4*>(ptr)->glEdgeFlagv(NULL);
}
void QOpenGLFunctions_1_4_GlEnable2(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_1_4_GlEnableClientState2(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glEnableClientState(array);
}
void QOpenGLFunctions_1_4_GlEnd2(void* ptr)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glEnd();
}
void QOpenGLFunctions_1_4_GlEndList2(void* ptr)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glEndList();
}
void QOpenGLFunctions_1_4_GlEvalCoord1f2(void* ptr, float u)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glEvalCoord1f(u);
}
void QOpenGLFunctions_1_4_GlEvalCoord1fv2(void* ptr, float u)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glEvalCoord1fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_1_4_GlEvalCoord2f2(void* ptr, float u, float v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glEvalCoord2f(u, v);
}
void QOpenGLFunctions_1_4_GlEvalCoord2fv2(void* ptr, float u)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glEvalCoord2fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_1_4_GlEvalMesh12(void* ptr, unsigned int mode, int i1, int i2)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glEvalMesh1(mode, i1, i2);
}
void QOpenGLFunctions_1_4_GlEvalMesh22(void* ptr, unsigned int mode, int i1, int i2, int j1, int j2)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glEvalMesh2(mode, i1, i2, j1, j2);
}
void QOpenGLFunctions_1_4_GlEvalPoint12(void* ptr, int i)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glEvalPoint1(i);
}
void QOpenGLFunctions_1_4_GlEvalPoint22(void* ptr, int i, int j)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glEvalPoint2(i, j);
}
void QOpenGLFunctions_1_4_GlFeedbackBuffer2(void* ptr, int size, unsigned int ty, float buffer)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glFeedbackBuffer(size, ty, &buffer);
}
void QOpenGLFunctions_1_4_GlFinish2(void* ptr)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glFinish();
}
void QOpenGLFunctions_1_4_GlFlush2(void* ptr)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glFlush();
}
void QOpenGLFunctions_1_4_GlFogCoordPointer2(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glFogCoordPointer(ty, stride, pointer);
}
void QOpenGLFunctions_1_4_GlFogCoordf2(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glFogCoordf(coord);
}
void QOpenGLFunctions_1_4_GlFogCoordfv2(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glFogCoordfv(const_cast<const GLfloat*>(&coord));
}
void QOpenGLFunctions_1_4_GlFogf2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glFogf(pname, param);
}
void QOpenGLFunctions_1_4_GlFogfv2(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glFogfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_4_GlFogi2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glFogi(pname, param);
}
void QOpenGLFunctions_1_4_GlFogiv2(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glFogiv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_4_GlFrontFace2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_1_4_GlGenTextures2(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_1_4_GlGetBooleanv2(void* ptr, unsigned int pname, char params)
{
Q_UNUSED(params);
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_1_4_GlGetColorTable2(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetColorTable(target, format, ty, table);
}
void QOpenGLFunctions_1_4_GlGetColorTableParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetColorTableParameterfv(target, pname, &params);
}
void QOpenGLFunctions_1_4_GlGetColorTableParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetColorTableParameteriv(target, pname, &params);
}
void QOpenGLFunctions_1_4_GlGetCompressedTexImage2(void* ptr, unsigned int target, int level, void* img)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetCompressedTexImage(target, level, img);
}
void QOpenGLFunctions_1_4_GlGetConvolutionFilter2(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetConvolutionFilter(target, format, ty, image);
}
void QOpenGLFunctions_1_4_GlGetConvolutionParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetConvolutionParameterfv(target, pname, &params);
}
void QOpenGLFunctions_1_4_GlGetConvolutionParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetConvolutionParameteriv(target, pname, &params);
}
void QOpenGLFunctions_1_4_GlGetFloatv2(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetFloatv(pname, &params);
}
void QOpenGLFunctions_1_4_GlGetHistogram2(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetHistogram(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_1_4_GlGetHistogramParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetHistogramParameterfv(target, pname, &params);
}
void QOpenGLFunctions_1_4_GlGetHistogramParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetHistogramParameteriv(target, pname, &params);
}
void QOpenGLFunctions_1_4_GlGetIntegerv2(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetIntegerv(pname, &params);
}
void QOpenGLFunctions_1_4_GlGetLightfv2(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetLightfv(light, pname, &params);
}
void QOpenGLFunctions_1_4_GlGetLightiv2(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetLightiv(light, pname, &params);
}
void QOpenGLFunctions_1_4_GlGetMapfv2(void* ptr, unsigned int target, unsigned int query, float v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetMapfv(target, query, &v);
}
void QOpenGLFunctions_1_4_GlGetMapiv2(void* ptr, unsigned int target, unsigned int query, int v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetMapiv(target, query, &v);
}
void QOpenGLFunctions_1_4_GlGetMaterialfv2(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetMaterialfv(face, pname, &params);
}
void QOpenGLFunctions_1_4_GlGetMaterialiv2(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetMaterialiv(face, pname, &params);
}
void QOpenGLFunctions_1_4_GlGetMinmax2(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetMinmax(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_1_4_GlGetMinmaxParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetMinmaxParameterfv(target, pname, &params);
}
void QOpenGLFunctions_1_4_GlGetMinmaxParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetMinmaxParameteriv(target, pname, &params);
}
void QOpenGLFunctions_1_4_GlGetPixelMapfv2(void* ptr, unsigned int m, float values)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetPixelMapfv(m, &values);
}
void QOpenGLFunctions_1_4_GlGetPixelMapuiv2(void* ptr, unsigned int m, unsigned int values)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetPixelMapuiv(m, &values);
}
void QOpenGLFunctions_1_4_GlGetPixelMapusv2(void* ptr, unsigned int m, unsigned short values)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetPixelMapusv(m, &values);
}
void QOpenGLFunctions_1_4_GlGetPointerv2(void* ptr, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetPointerv(pname, &params);
}
void QOpenGLFunctions_1_4_GlGetPolygonStipple2(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetPolygonStipple(static_cast<GLubyte*>(static_cast<void*>(mask)));
}
void QOpenGLFunctions_1_4_GlGetSeparableFilter2(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* row, void* column, void* span)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetSeparableFilter(target, format, ty, row, column, span);
}
void QOpenGLFunctions_1_4_GlGetTexEnvfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetTexEnvfv(target, pname, &params);
}
void QOpenGLFunctions_1_4_GlGetTexEnviv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetTexEnviv(target, pname, &params);
}
void QOpenGLFunctions_1_4_GlGetTexGenfv2(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetTexGenfv(coord, pname, &params);
}
void QOpenGLFunctions_1_4_GlGetTexGeniv2(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetTexGeniv(coord, pname, &params);
}
void QOpenGLFunctions_1_4_GlGetTexImage2(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_1_4_GlGetTexLevelParameterfv2(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_1_4_GlGetTexLevelParameteriv2(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_1_4_GlGetTexParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_1_4_GlGetTexParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_1_4_GlHint2(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_1_4_GlHistogram2(void* ptr, unsigned int target, int width, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glHistogram(target, width, internalformat, sink != 0);
}
void QOpenGLFunctions_1_4_GlIndexMask2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glIndexMask(mask);
}
void QOpenGLFunctions_1_4_GlIndexPointer2(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glIndexPointer(ty, stride, pointer);
}
void QOpenGLFunctions_1_4_GlIndexf2(void* ptr, float c)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glIndexf(c);
}
void QOpenGLFunctions_1_4_GlIndexfv2(void* ptr, float c)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glIndexfv(const_cast<const GLfloat*>(&c));
}
void QOpenGLFunctions_1_4_GlIndexi2(void* ptr, int c)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glIndexi(c);
}
void QOpenGLFunctions_1_4_GlIndexiv2(void* ptr, int c)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glIndexiv(const_cast<const GLint*>(&c));
}
void QOpenGLFunctions_1_4_GlIndexs2(void* ptr, short c)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glIndexs(c);
}
void QOpenGLFunctions_1_4_GlIndexsv2(void* ptr, short c)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glIndexsv(const_cast<const GLshort*>(&c));
}
void QOpenGLFunctions_1_4_GlIndexub2(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glIndexub(*static_cast<GLubyte*>(static_cast<void*>(c)));
}
void QOpenGLFunctions_1_4_GlIndexubv2(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glIndexubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(c))));
}
void QOpenGLFunctions_1_4_GlInitNames2(void* ptr)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glInitNames();
}
void QOpenGLFunctions_1_4_GlInterleavedArrays2(void* ptr, unsigned int format, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glInterleavedArrays(format, stride, pointer);
}
void QOpenGLFunctions_1_4_GlLightModelf2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glLightModelf(pname, param);
}
void QOpenGLFunctions_1_4_GlLightModelfv2(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glLightModelfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_4_GlLightModeli2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glLightModeli(pname, param);
}
void QOpenGLFunctions_1_4_GlLightModeliv2(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glLightModeliv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_4_GlLightf2(void* ptr, unsigned int light, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glLightf(light, pname, param);
}
void QOpenGLFunctions_1_4_GlLightfv2(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glLightfv(light, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_4_GlLighti2(void* ptr, unsigned int light, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glLighti(light, pname, param);
}
void QOpenGLFunctions_1_4_GlLightiv2(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glLightiv(light, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_4_GlLineStipple2(void* ptr, int factor, unsigned short pattern)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glLineStipple(factor, pattern);
}
void QOpenGLFunctions_1_4_GlLineWidth2(void* ptr, float width)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_1_4_GlListBase2(void* ptr, unsigned int base)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glListBase(base);
}
void QOpenGLFunctions_1_4_GlLoadIdentity2(void* ptr)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glLoadIdentity();
}
void QOpenGLFunctions_1_4_GlLoadMatrixf2(void* ptr, float m)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glLoadMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_1_4_GlLoadName2(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glLoadName(name);
}
void QOpenGLFunctions_1_4_GlLoadTransposeMatrixf2(void* ptr, float m)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glLoadTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_1_4_GlLogicOp2(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_1_4_GlMap1f2(void* ptr, unsigned int target, float u1, float u2, int stride, int order, float points)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMap1f(target, u1, u2, stride, order, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_1_4_GlMap2f2(void* ptr, unsigned int target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float points)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_1_4_GlMapGrid1f2(void* ptr, int un, float u1, float u2)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMapGrid1f(un, u1, u2);
}
void QOpenGLFunctions_1_4_GlMapGrid2f2(void* ptr, int un, float u1, float u2, int vn, float v1, float v2)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMapGrid2f(un, u1, u2, vn, v1, v2);
}
void QOpenGLFunctions_1_4_GlMaterialf2(void* ptr, unsigned int face, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMaterialf(face, pname, param);
}
void QOpenGLFunctions_1_4_GlMaterialfv2(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMaterialfv(face, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_4_GlMateriali2(void* ptr, unsigned int face, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMateriali(face, pname, param);
}
void QOpenGLFunctions_1_4_GlMaterialiv2(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMaterialiv(face, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_4_GlMatrixMode2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMatrixMode(mode);
}
void QOpenGLFunctions_1_4_GlMinmax2(void* ptr, unsigned int target, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMinmax(target, internalformat, sink != 0);
}
void QOpenGLFunctions_1_4_GlMultMatrixf2(void* ptr, float m)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_1_4_GlMultTransposeMatrixf2(void* ptr, float m)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_1_4_GlMultiDrawArrays2(void* ptr, unsigned int mode, int first, int count, int drawcount)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiDrawArrays(mode, const_cast<const GLint*>(&first), const_cast<const GLsizei*>(&count), drawcount);
}
void QOpenGLFunctions_1_4_GlMultiTexCoord1f2(void* ptr, unsigned int target, float s)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiTexCoord1f(target, s);
}
void QOpenGLFunctions_1_4_GlMultiTexCoord1fv2(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiTexCoord1fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_4_GlMultiTexCoord1i2(void* ptr, unsigned int target, int s)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiTexCoord1i(target, s);
}
void QOpenGLFunctions_1_4_GlMultiTexCoord1iv2(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiTexCoord1iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_4_GlMultiTexCoord1s2(void* ptr, unsigned int target, short s)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiTexCoord1s(target, s);
}
void QOpenGLFunctions_1_4_GlMultiTexCoord1sv2(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiTexCoord1sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_4_GlMultiTexCoord2f2(void* ptr, unsigned int target, float s, float t)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiTexCoord2f(target, s, t);
}
void QOpenGLFunctions_1_4_GlMultiTexCoord2fv2(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiTexCoord2fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_4_GlMultiTexCoord2i2(void* ptr, unsigned int target, int s, int t)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiTexCoord2i(target, s, t);
}
void QOpenGLFunctions_1_4_GlMultiTexCoord2iv2(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiTexCoord2iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_4_GlMultiTexCoord2s2(void* ptr, unsigned int target, short s, short t)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiTexCoord2s(target, s, t);
}
void QOpenGLFunctions_1_4_GlMultiTexCoord2sv2(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiTexCoord2sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_4_GlMultiTexCoord3f2(void* ptr, unsigned int target, float s, float t, float r)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiTexCoord3f(target, s, t, r);
}
void QOpenGLFunctions_1_4_GlMultiTexCoord3fv2(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiTexCoord3fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_4_GlMultiTexCoord3i2(void* ptr, unsigned int target, int s, int t, int r)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiTexCoord3i(target, s, t, r);
}
void QOpenGLFunctions_1_4_GlMultiTexCoord3iv2(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiTexCoord3iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_4_GlMultiTexCoord3s2(void* ptr, unsigned int target, short s, short t, short r)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiTexCoord3s(target, s, t, r);
}
void QOpenGLFunctions_1_4_GlMultiTexCoord3sv2(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiTexCoord3sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_4_GlMultiTexCoord4f2(void* ptr, unsigned int target, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiTexCoord4f(target, s, t, r, q);
}
void QOpenGLFunctions_1_4_GlMultiTexCoord4fv2(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiTexCoord4fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_4_GlMultiTexCoord4i2(void* ptr, unsigned int target, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiTexCoord4i(target, s, t, r, q);
}
void QOpenGLFunctions_1_4_GlMultiTexCoord4iv2(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiTexCoord4iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_4_GlMultiTexCoord4s2(void* ptr, unsigned int target, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiTexCoord4s(target, s, t, r, q);
}
void QOpenGLFunctions_1_4_GlMultiTexCoord4sv2(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glMultiTexCoord4sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_4_GlNewList2(void* ptr, unsigned int list, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glNewList(list, mode);
}
void QOpenGLFunctions_1_4_GlNormal3f2(void* ptr, float nx, float ny, float nz)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glNormal3f(nx, ny, nz);
}
void QOpenGLFunctions_1_4_GlNormal3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glNormal3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_4_GlNormal3i2(void* ptr, int nx, int ny, int nz)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glNormal3i(nx, ny, nz);
}
void QOpenGLFunctions_1_4_GlNormal3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glNormal3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_4_GlNormal3s2(void* ptr, short nx, short ny, short nz)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glNormal3s(nx, ny, nz);
}
void QOpenGLFunctions_1_4_GlNormal3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glNormal3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_4_GlNormalPointer2(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glNormalPointer(ty, stride, pointer);
}
void QOpenGLFunctions_1_4_GlPassThrough2(void* ptr, float token)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPassThrough(token);
}
void QOpenGLFunctions_1_4_GlPixelMapfv2(void* ptr, unsigned int m, int mapsize, float values)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPixelMapfv(m, mapsize, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_1_4_GlPixelMapuiv2(void* ptr, unsigned int m, int mapsize, unsigned int values)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPixelMapuiv(m, mapsize, const_cast<const GLuint*>(&values));
}
void QOpenGLFunctions_1_4_GlPixelMapusv2(void* ptr, unsigned int m, int mapsize, unsigned short values)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPixelMapusv(m, mapsize, const_cast<const GLushort*>(&values));
}
void QOpenGLFunctions_1_4_GlPixelStoref2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_1_4_GlPixelStorei2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_1_4_GlPixelTransferf2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPixelTransferf(pname, param);
}
void QOpenGLFunctions_1_4_GlPixelTransferi2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPixelTransferi(pname, param);
}
void QOpenGLFunctions_1_4_GlPixelZoom2(void* ptr, float xfactor, float yfactor)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPixelZoom(xfactor, yfactor);
}
void QOpenGLFunctions_1_4_GlPointParameterf2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPointParameterf(pname, param);
}
void QOpenGLFunctions_1_4_GlPointParameterfv2(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPointParameterfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_4_GlPointParameteri2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPointParameteri(pname, param);
}
void QOpenGLFunctions_1_4_GlPointParameteriv2(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPointParameteriv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_4_GlPointSize2(void* ptr, float size)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_1_4_GlPolygonMode2(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_1_4_GlPolygonOffset2(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_1_4_GlPolygonStipple2(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPolygonStipple(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(mask))));
}
void QOpenGLFunctions_1_4_GlPopAttrib2(void* ptr)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPopAttrib();
}
void QOpenGLFunctions_1_4_GlPopClientAttrib2(void* ptr)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPopClientAttrib();
}
void QOpenGLFunctions_1_4_GlPopMatrix2(void* ptr)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPopMatrix();
}
void QOpenGLFunctions_1_4_GlPopName2(void* ptr)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPopName();
}
void QOpenGLFunctions_1_4_GlPrioritizeTextures2(void* ptr, int n, unsigned int textures, float priorities)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPrioritizeTextures(n, const_cast<const GLuint*>(&textures), const_cast<const GLfloat*>(&priorities));
}
void QOpenGLFunctions_1_4_GlPushAttrib2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPushAttrib(mask);
}
void QOpenGLFunctions_1_4_GlPushClientAttrib2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPushClientAttrib(mask);
}
void QOpenGLFunctions_1_4_GlPushMatrix2(void* ptr)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPushMatrix();
}
void QOpenGLFunctions_1_4_GlPushName2(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glPushName(name);
}
void QOpenGLFunctions_1_4_GlRasterPos2f2(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRasterPos2f(x, y);
}
void QOpenGLFunctions_1_4_GlRasterPos2fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRasterPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_4_GlRasterPos2i2(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRasterPos2i(x, y);
}
void QOpenGLFunctions_1_4_GlRasterPos2iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRasterPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_4_GlRasterPos2s2(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRasterPos2s(x, y);
}
void QOpenGLFunctions_1_4_GlRasterPos2sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRasterPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_4_GlRasterPos3f2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRasterPos3f(x, y, z);
}
void QOpenGLFunctions_1_4_GlRasterPos3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRasterPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_4_GlRasterPos3i2(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRasterPos3i(x, y, z);
}
void QOpenGLFunctions_1_4_GlRasterPos3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRasterPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_4_GlRasterPos3s2(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRasterPos3s(x, y, z);
}
void QOpenGLFunctions_1_4_GlRasterPos3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRasterPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_4_GlRasterPos4f2(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRasterPos4f(x, y, z, w);
}
void QOpenGLFunctions_1_4_GlRasterPos4fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRasterPos4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_4_GlRasterPos4i2(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRasterPos4i(x, y, z, w);
}
void QOpenGLFunctions_1_4_GlRasterPos4iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRasterPos4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_4_GlRasterPos4s2(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRasterPos4s(x, y, z, w);
}
void QOpenGLFunctions_1_4_GlRasterPos4sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRasterPos4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_4_GlReadBuffer2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glReadBuffer(mode);
}
void QOpenGLFunctions_1_4_GlReadPixels2(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_1_4_GlRectf2(void* ptr, float x1, float y1, float x2, float y2)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRectf(x1, y1, x2, y2);
}
void QOpenGLFunctions_1_4_GlRectfv2(void* ptr, float v1, float v2)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRectfv(const_cast<const GLfloat*>(&v1), const_cast<const GLfloat*>(&v2));
}
void QOpenGLFunctions_1_4_GlRecti2(void* ptr, int x1, int y1, int x2, int y2)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRecti(x1, y1, x2, y2);
}
void QOpenGLFunctions_1_4_GlRectiv2(void* ptr, int v1, int v2)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRectiv(const_cast<const GLint*>(&v1), const_cast<const GLint*>(&v2));
}
void QOpenGLFunctions_1_4_GlRects2(void* ptr, short x1, short y1, short x2, short y2)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRects(x1, y1, x2, y2);
}
void QOpenGLFunctions_1_4_GlRectsv2(void* ptr, short v1, short v2)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRectsv(const_cast<const GLshort*>(&v1), const_cast<const GLshort*>(&v2));
}
void QOpenGLFunctions_1_4_GlResetHistogram2(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glResetHistogram(target);
}
void QOpenGLFunctions_1_4_GlResetMinmax2(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glResetMinmax(target);
}
void QOpenGLFunctions_1_4_GlRotatef2(void* ptr, float angle, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glRotatef(angle, x, y, z);
}
void QOpenGLFunctions_1_4_GlSampleCoverage2(void* ptr, float value, char invert)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glSampleCoverage(value, invert != 0);
}
void QOpenGLFunctions_1_4_GlScalef2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glScalef(x, y, z);
}
void QOpenGLFunctions_1_4_GlScissor2(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_1_4_GlSecondaryColor3f2(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glSecondaryColor3f(red, green, blue);
}
void QOpenGLFunctions_1_4_GlSecondaryColor3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glSecondaryColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_4_GlSecondaryColor3i2(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glSecondaryColor3i(red, green, blue);
}
void QOpenGLFunctions_1_4_GlSecondaryColor3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glSecondaryColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_4_GlSecondaryColor3s2(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glSecondaryColor3s(red, green, blue);
}
void QOpenGLFunctions_1_4_GlSecondaryColor3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glSecondaryColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_4_GlSecondaryColor3ub2(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glSecondaryColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_1_4_GlSecondaryColor3ubv2(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glSecondaryColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_1_4_GlSecondaryColor3ui2(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glSecondaryColor3ui(red, green, blue);
}
void QOpenGLFunctions_1_4_GlSecondaryColor3uiv2(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glSecondaryColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_1_4_GlSecondaryColor3us2(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glSecondaryColor3us(red, green, blue);
}
void QOpenGLFunctions_1_4_GlSecondaryColor3usv2(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glSecondaryColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_1_4_GlSecondaryColorPointer2(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glSecondaryColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_1_4_GlSelectBuffer2(void* ptr, int size, unsigned int buffer)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glSelectBuffer(size, &buffer);
}
void QOpenGLFunctions_1_4_GlSeparableFilter2D2(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* row, void* column)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glSeparableFilter2D(target, internalformat, width, height, format, ty, row, column);
}
void QOpenGLFunctions_1_4_GlShadeModel2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glShadeModel(mode);
}
void QOpenGLFunctions_1_4_GlStencilFunc2(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_1_4_GlStencilMask2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_1_4_GlStencilOp2(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_1_4_GlTexCoord1f2(void* ptr, float s)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoord1f(s);
}
void QOpenGLFunctions_1_4_GlTexCoord1fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoord1fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_4_GlTexCoord1i2(void* ptr, int s)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoord1i(s);
}
void QOpenGLFunctions_1_4_GlTexCoord1iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoord1iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_4_GlTexCoord1s2(void* ptr, short s)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoord1s(s);
}
void QOpenGLFunctions_1_4_GlTexCoord1sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoord1sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_4_GlTexCoord2f2(void* ptr, float s, float t)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoord2f(s, t);
}
void QOpenGLFunctions_1_4_GlTexCoord2fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoord2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_4_GlTexCoord2i2(void* ptr, int s, int t)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoord2i(s, t);
}
void QOpenGLFunctions_1_4_GlTexCoord2iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoord2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_4_GlTexCoord2s2(void* ptr, short s, short t)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoord2s(s, t);
}
void QOpenGLFunctions_1_4_GlTexCoord2sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoord2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_4_GlTexCoord3f2(void* ptr, float s, float t, float r)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoord3f(s, t, r);
}
void QOpenGLFunctions_1_4_GlTexCoord3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoord3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_4_GlTexCoord3i2(void* ptr, int s, int t, int r)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoord3i(s, t, r);
}
void QOpenGLFunctions_1_4_GlTexCoord3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoord3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_4_GlTexCoord3s2(void* ptr, short s, short t, short r)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoord3s(s, t, r);
}
void QOpenGLFunctions_1_4_GlTexCoord3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoord3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_4_GlTexCoord4f2(void* ptr, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoord4f(s, t, r, q);
}
void QOpenGLFunctions_1_4_GlTexCoord4fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoord4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_4_GlTexCoord4i2(void* ptr, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoord4i(s, t, r, q);
}
void QOpenGLFunctions_1_4_GlTexCoord4iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoord4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_4_GlTexCoord4s2(void* ptr, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoord4s(s, t, r, q);
}
void QOpenGLFunctions_1_4_GlTexCoord4sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoord4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_4_GlTexCoordPointer2(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexCoordPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_1_4_GlTexEnvf2(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexEnvf(target, pname, param);
}
void QOpenGLFunctions_1_4_GlTexEnvfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexEnvfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_4_GlTexEnvi2(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexEnvi(target, pname, param);
}
void QOpenGLFunctions_1_4_GlTexEnviv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexEnviv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_4_GlTexGenf2(void* ptr, unsigned int coord, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexGenf(coord, pname, param);
}
void QOpenGLFunctions_1_4_GlTexGenfv2(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexGenfv(coord, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_4_GlTexGeni2(void* ptr, unsigned int coord, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexGeni(coord, pname, param);
}
void QOpenGLFunctions_1_4_GlTexGeniv2(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexGeniv(coord, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_4_GlTexImage1D2(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_1_4_GlTexImage2D2(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_1_4_GlTexImage3D2(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLFunctions_1_4_GlTexParameterf2(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_1_4_GlTexParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_4_GlTexParameteri2(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_1_4_GlTexParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_4_GlTexSubImage1D2(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_1_4_GlTexSubImage2D2(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_1_4_GlTexSubImage3D2(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_1_4_GlTranslatef2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glTranslatef(x, y, z);
}
void QOpenGLFunctions_1_4_GlVertex2f2(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glVertex2f(x, y);
}
void QOpenGLFunctions_1_4_GlVertex2fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glVertex2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_4_GlVertex2i2(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glVertex2i(x, y);
}
void QOpenGLFunctions_1_4_GlVertex2iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glVertex2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_4_GlVertex2s2(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glVertex2s(x, y);
}
void QOpenGLFunctions_1_4_GlVertex2sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glVertex2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_4_GlVertex3f2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glVertex3f(x, y, z);
}
void QOpenGLFunctions_1_4_GlVertex3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glVertex3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_4_GlVertex3i2(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glVertex3i(x, y, z);
}
void QOpenGLFunctions_1_4_GlVertex3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glVertex3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_4_GlVertex3s2(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glVertex3s(x, y, z);
}
void QOpenGLFunctions_1_4_GlVertex3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glVertex3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_4_GlVertex4f2(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glVertex4f(x, y, z, w);
}
void QOpenGLFunctions_1_4_GlVertex4fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glVertex4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_4_GlVertex4i2(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glVertex4i(x, y, z, w);
}
void QOpenGLFunctions_1_4_GlVertex4iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glVertex4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_4_GlVertex4s2(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glVertex4s(x, y, z, w);
}
void QOpenGLFunctions_1_4_GlVertex4sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glVertex4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_4_GlVertexPointer2(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glVertexPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_1_4_GlViewport2(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_1_4_GlWindowPos2f2(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glWindowPos2f(x, y);
}
void QOpenGLFunctions_1_4_GlWindowPos2fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glWindowPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_4_GlWindowPos2i2(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glWindowPos2i(x, y);
}
void QOpenGLFunctions_1_4_GlWindowPos2iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glWindowPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_4_GlWindowPos2s2(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glWindowPos2s(x, y);
}
void QOpenGLFunctions_1_4_GlWindowPos2sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glWindowPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_4_GlWindowPos3f2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glWindowPos3f(x, y, z);
}
void QOpenGLFunctions_1_4_GlWindowPos3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glWindowPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_4_GlWindowPos3i2(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glWindowPos3i(x, y, z);
}
void QOpenGLFunctions_1_4_GlWindowPos3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glWindowPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_4_GlWindowPos3s2(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glWindowPos3s(x, y, z);
}
void QOpenGLFunctions_1_4_GlWindowPos3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->glWindowPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_4_DestroyQOpenGLFunctions_1_42(void* ptr)
{
static_cast<QOpenGLFunctions_1_4*>(ptr)->~QOpenGLFunctions_1_4();
}
void QOpenGLFunctions_1_4_DestroyQOpenGLFunctions_1_42Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_1_5: public QOpenGLFunctions_1_5
{
public:
MyQOpenGLFunctions_1_5() : QOpenGLFunctions_1_5() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_1_5_InitializeOpenGLFunctions2(this) != 0; };
~MyQOpenGLFunctions_1_5() { callbackQOpenGLFunctions_1_5_DestroyQOpenGLFunctions_1_52(this); };
};
char QOpenGLFunctions_1_5_GlAreTexturesResident2(void* ptr, int n, unsigned int textures, char residences)
{
Q_UNUSED(residences);
return static_cast<QOpenGLFunctions_1_5*>(ptr)->glAreTexturesResident(n, const_cast<const GLuint*>(&textures), NULL);
}
char QOpenGLFunctions_1_5_GlIsBuffer2(void* ptr, unsigned int buffer)
{
return static_cast<QOpenGLFunctions_1_5*>(ptr)->glIsBuffer(buffer);
}
char QOpenGLFunctions_1_5_GlIsEnabled2(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_1_5*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_1_5_GlIsList2(void* ptr, unsigned int list)
{
return static_cast<QOpenGLFunctions_1_5*>(ptr)->glIsList(list);
}
char QOpenGLFunctions_1_5_GlIsQuery2(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_1_5*>(ptr)->glIsQuery(id);
}
char QOpenGLFunctions_1_5_GlIsTexture2(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_1_5*>(ptr)->glIsTexture(texture);
}
char QOpenGLFunctions_1_5_GlUnmapBuffer2(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_1_5*>(ptr)->glUnmapBuffer(target);
}
unsigned int QOpenGLFunctions_1_5_GlGetError2(void* ptr)
{
return static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetError();
}
int QOpenGLFunctions_1_5_GlRenderMode2(void* ptr, unsigned int mode)
{
return static_cast<QOpenGLFunctions_1_5*>(ptr)->glRenderMode(mode);
}
unsigned int QOpenGLFunctions_1_5_GlGenLists2(void* ptr, int ran)
{
return static_cast<QOpenGLFunctions_1_5*>(ptr)->glGenLists(ran);
}
void* QOpenGLFunctions_1_5_GlMapBuffer2(void* ptr, unsigned int target, unsigned int access)
{
return static_cast<QOpenGLFunctions_1_5*>(ptr)->glMapBuffer(target, access);
}
void* QOpenGLFunctions_1_5_NewQOpenGLFunctions_1_52()
{
return new MyQOpenGLFunctions_1_5();
}
char QOpenGLFunctions_1_5_InitializeOpenGLFunctions2(void* ptr)
{
return static_cast<QOpenGLFunctions_1_5*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_1_5_InitializeOpenGLFunctions2Default(void* ptr)
{
return static_cast<QOpenGLFunctions_1_5*>(ptr)->QOpenGLFunctions_1_5::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_1_5_GlGetString2(void* ptr, unsigned int name)
{
return ({ char* t7c2819 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetString(name)))); QtGui_PackedString { t7c2819, -1 }; });
}
void QOpenGLFunctions_1_5_GlAccum2(void* ptr, unsigned int op, float value)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glAccum(op, value);
}
void QOpenGLFunctions_1_5_GlActiveTexture2(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glActiveTexture(texture);
}
void QOpenGLFunctions_1_5_GlAlphaFunc2(void* ptr, unsigned int fu, float ref)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glAlphaFunc(fu, ref);
}
void QOpenGLFunctions_1_5_GlArrayElement2(void* ptr, int i)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glArrayElement(i);
}
void QOpenGLFunctions_1_5_GlBegin2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glBegin(mode);
}
void QOpenGLFunctions_1_5_GlBeginQuery2(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glBeginQuery(target, id);
}
void QOpenGLFunctions_1_5_GlBindBuffer2(void* ptr, unsigned int target, unsigned int buffer)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glBindBuffer(target, buffer);
}
void QOpenGLFunctions_1_5_GlBindTexture2(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_1_5_GlBitmap2(void* ptr, int width, int height, float xorig, float yorig, float xmove, float ymove, char* bitmap)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glBitmap(width, height, xorig, yorig, xmove, ymove, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(bitmap))));
}
void QOpenGLFunctions_1_5_GlBlendColor2(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_1_5_GlBlendEquation2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_1_5_GlBlendFunc2(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_1_5_GlBlendFuncSeparate2(void* ptr, unsigned int sfactorRGB, unsigned int dfactorRGB, unsigned int sfactorAlpha, unsigned int dfactorAlpha)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void QOpenGLFunctions_1_5_GlCallList2(void* ptr, unsigned int list)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glCallList(list);
}
void QOpenGLFunctions_1_5_GlCallLists2(void* ptr, int n, unsigned int ty, void* lists)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glCallLists(n, ty, lists);
}
void QOpenGLFunctions_1_5_GlClear2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_1_5_GlClearAccum2(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glClearAccum(red, green, blue, alpha);
}
void QOpenGLFunctions_1_5_GlClearColor2(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_1_5_GlClearIndex2(void* ptr, float c)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glClearIndex(c);
}
void QOpenGLFunctions_1_5_GlClearStencil2(void* ptr, int s)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_1_5_GlClientActiveTexture2(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glClientActiveTexture(texture);
}
void QOpenGLFunctions_1_5_GlColor3f2(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColor3f(red, green, blue);
}
void QOpenGLFunctions_1_5_GlColor3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_5_GlColor3i2(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColor3i(red, green, blue);
}
void QOpenGLFunctions_1_5_GlColor3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_5_GlColor3s2(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColor3s(red, green, blue);
}
void QOpenGLFunctions_1_5_GlColor3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_5_GlColor3ub2(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_1_5_GlColor3ubv2(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_1_5_GlColor3ui2(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColor3ui(red, green, blue);
}
void QOpenGLFunctions_1_5_GlColor3uiv2(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_1_5_GlColor3us2(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColor3us(red, green, blue);
}
void QOpenGLFunctions_1_5_GlColor3usv2(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_1_5_GlColor4f2(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColor4f(red, green, blue, alpha);
}
void QOpenGLFunctions_1_5_GlColor4fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColor4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_5_GlColor4i2(void* ptr, int red, int green, int blue, int alpha)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColor4i(red, green, blue, alpha);
}
void QOpenGLFunctions_1_5_GlColor4iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColor4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_5_GlColor4s2(void* ptr, short red, short green, short blue, short alpha)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColor4s(red, green, blue, alpha);
}
void QOpenGLFunctions_1_5_GlColor4sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColor4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_5_GlColor4ub2(void* ptr, char* red, char* green, char* blue, char* alpha)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColor4ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)), *static_cast<GLubyte*>(static_cast<void*>(alpha)));
}
void QOpenGLFunctions_1_5_GlColor4ubv2(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColor4ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_1_5_GlColor4ui2(void* ptr, unsigned int red, unsigned int green, unsigned int blue, unsigned int alpha)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColor4ui(red, green, blue, alpha);
}
void QOpenGLFunctions_1_5_GlColor4uiv2(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColor4uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_1_5_GlColor4us2(void* ptr, unsigned short red, unsigned short green, unsigned short blue, unsigned short alpha)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColor4us(red, green, blue, alpha);
}
void QOpenGLFunctions_1_5_GlColor4usv2(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColor4usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_1_5_GlColorMask2(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_1_5_GlColorMaterial2(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColorMaterial(face, mode);
}
void QOpenGLFunctions_1_5_GlColorPointer2(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_1_5_GlColorSubTable2(void* ptr, unsigned int target, int start, int count, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColorSubTable(target, start, count, format, ty, data);
}
void QOpenGLFunctions_1_5_GlColorTable2(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColorTable(target, internalformat, width, format, ty, table);
}
void QOpenGLFunctions_1_5_GlColorTableParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColorTableParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_5_GlColorTableParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glColorTableParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_5_GlCompressedTexImage1D2(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
void QOpenGLFunctions_1_5_GlCompressedTexImage2D2(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void QOpenGLFunctions_1_5_GlCompressedTexImage3D2(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int depth, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void QOpenGLFunctions_1_5_GlCompressedTexSubImage1D2(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_1_5_GlCompressedTexSubImage2D2(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_1_5_GlCompressedTexSubImage3D2(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_1_5_GlConvolutionFilter1D2(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glConvolutionFilter1D(target, internalformat, width, format, ty, image);
}
void QOpenGLFunctions_1_5_GlConvolutionFilter2D2(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glConvolutionFilter2D(target, internalformat, width, height, format, ty, image);
}
void QOpenGLFunctions_1_5_GlConvolutionParameterf2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glConvolutionParameterf(target, pname, params);
}
void QOpenGLFunctions_1_5_GlConvolutionParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glConvolutionParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_5_GlConvolutionParameteri2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glConvolutionParameteri(target, pname, params);
}
void QOpenGLFunctions_1_5_GlConvolutionParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glConvolutionParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_5_GlCopyColorSubTable2(void* ptr, unsigned int target, int start, int x, int y, int width)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glCopyColorSubTable(target, start, x, y, width);
}
void QOpenGLFunctions_1_5_GlCopyColorTable2(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glCopyColorTable(target, internalformat, x, y, width);
}
void QOpenGLFunctions_1_5_GlCopyConvolutionFilter1D2(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glCopyConvolutionFilter1D(target, internalformat, x, y, width);
}
void QOpenGLFunctions_1_5_GlCopyConvolutionFilter2D2(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);
}
void QOpenGLFunctions_1_5_GlCopyPixels2(void* ptr, int x, int y, int width, int height, unsigned int ty)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glCopyPixels(x, y, width, height, ty);
}
void QOpenGLFunctions_1_5_GlCopyTexImage1D2(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_1_5_GlCopyTexImage2D2(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_1_5_GlCopyTexSubImage1D2(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_1_5_GlCopyTexSubImage2D2(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_1_5_GlCopyTexSubImage3D2(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_1_5_GlCullFace2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_1_5_GlDeleteBuffers2(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glDeleteBuffers(n, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_1_5_GlDeleteLists2(void* ptr, unsigned int list, int ran)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glDeleteLists(list, ran);
}
void QOpenGLFunctions_1_5_GlDeleteQueries2(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glDeleteQueries(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_1_5_GlDeleteTextures2(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_1_5_GlDepthFunc2(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_1_5_GlDepthMask2(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_1_5_GlDisable2(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_1_5_GlDisableClientState2(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glDisableClientState(array);
}
void QOpenGLFunctions_1_5_GlDrawArrays2(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_1_5_GlDrawBuffer2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glDrawBuffer(mode);
}
void QOpenGLFunctions_1_5_GlDrawElements2(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_1_5_GlDrawPixels2(void* ptr, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glDrawPixels(width, height, format, ty, pixels);
}
void QOpenGLFunctions_1_5_GlDrawRangeElements2(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLFunctions_1_5_GlEdgeFlag2(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glEdgeFlag(flag != 0);
}
void QOpenGLFunctions_1_5_GlEdgeFlagPointer2(void* ptr, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glEdgeFlagPointer(stride, pointer);
}
void QOpenGLFunctions_1_5_GlEdgeFlagv2(void* ptr, char flag)
{
Q_UNUSED(flag);
static_cast<QOpenGLFunctions_1_5*>(ptr)->glEdgeFlagv(NULL);
}
void QOpenGLFunctions_1_5_GlEnable2(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_1_5_GlEnableClientState2(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glEnableClientState(array);
}
void QOpenGLFunctions_1_5_GlEnd2(void* ptr)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glEnd();
}
void QOpenGLFunctions_1_5_GlEndList2(void* ptr)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glEndList();
}
void QOpenGLFunctions_1_5_GlEndQuery2(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glEndQuery(target);
}
void QOpenGLFunctions_1_5_GlEvalCoord1f2(void* ptr, float u)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glEvalCoord1f(u);
}
void QOpenGLFunctions_1_5_GlEvalCoord1fv2(void* ptr, float u)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glEvalCoord1fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_1_5_GlEvalCoord2f2(void* ptr, float u, float v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glEvalCoord2f(u, v);
}
void QOpenGLFunctions_1_5_GlEvalCoord2fv2(void* ptr, float u)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glEvalCoord2fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_1_5_GlEvalMesh12(void* ptr, unsigned int mode, int i1, int i2)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glEvalMesh1(mode, i1, i2);
}
void QOpenGLFunctions_1_5_GlEvalMesh22(void* ptr, unsigned int mode, int i1, int i2, int j1, int j2)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glEvalMesh2(mode, i1, i2, j1, j2);
}
void QOpenGLFunctions_1_5_GlEvalPoint12(void* ptr, int i)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glEvalPoint1(i);
}
void QOpenGLFunctions_1_5_GlEvalPoint22(void* ptr, int i, int j)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glEvalPoint2(i, j);
}
void QOpenGLFunctions_1_5_GlFeedbackBuffer2(void* ptr, int size, unsigned int ty, float buffer)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glFeedbackBuffer(size, ty, &buffer);
}
void QOpenGLFunctions_1_5_GlFinish2(void* ptr)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glFinish();
}
void QOpenGLFunctions_1_5_GlFlush2(void* ptr)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glFlush();
}
void QOpenGLFunctions_1_5_GlFogCoordPointer2(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glFogCoordPointer(ty, stride, pointer);
}
void QOpenGLFunctions_1_5_GlFogCoordf2(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glFogCoordf(coord);
}
void QOpenGLFunctions_1_5_GlFogCoordfv2(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glFogCoordfv(const_cast<const GLfloat*>(&coord));
}
void QOpenGLFunctions_1_5_GlFogf2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glFogf(pname, param);
}
void QOpenGLFunctions_1_5_GlFogfv2(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glFogfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_5_GlFogi2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glFogi(pname, param);
}
void QOpenGLFunctions_1_5_GlFogiv2(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glFogiv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_5_GlFrontFace2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_1_5_GlGenBuffers2(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGenBuffers(n, &buffers);
}
void QOpenGLFunctions_1_5_GlGenQueries2(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGenQueries(n, &ids);
}
void QOpenGLFunctions_1_5_GlGenTextures2(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_1_5_GlGetBooleanv2(void* ptr, unsigned int pname, char params)
{
Q_UNUSED(params);
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_1_5_GlGetBufferParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetBufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_1_5_GlGetBufferPointerv2(void* ptr, unsigned int target, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetBufferPointerv(target, pname, &params);
}
void QOpenGLFunctions_1_5_GlGetColorTable2(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetColorTable(target, format, ty, table);
}
void QOpenGLFunctions_1_5_GlGetColorTableParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetColorTableParameterfv(target, pname, &params);
}
void QOpenGLFunctions_1_5_GlGetColorTableParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetColorTableParameteriv(target, pname, &params);
}
void QOpenGLFunctions_1_5_GlGetCompressedTexImage2(void* ptr, unsigned int target, int level, void* img)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetCompressedTexImage(target, level, img);
}
void QOpenGLFunctions_1_5_GlGetConvolutionFilter2(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetConvolutionFilter(target, format, ty, image);
}
void QOpenGLFunctions_1_5_GlGetConvolutionParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetConvolutionParameterfv(target, pname, &params);
}
void QOpenGLFunctions_1_5_GlGetConvolutionParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetConvolutionParameteriv(target, pname, &params);
}
void QOpenGLFunctions_1_5_GlGetFloatv2(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetFloatv(pname, &params);
}
void QOpenGLFunctions_1_5_GlGetHistogram2(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetHistogram(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_1_5_GlGetHistogramParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetHistogramParameterfv(target, pname, &params);
}
void QOpenGLFunctions_1_5_GlGetHistogramParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetHistogramParameteriv(target, pname, &params);
}
void QOpenGLFunctions_1_5_GlGetIntegerv2(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetIntegerv(pname, &params);
}
void QOpenGLFunctions_1_5_GlGetLightfv2(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetLightfv(light, pname, &params);
}
void QOpenGLFunctions_1_5_GlGetLightiv2(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetLightiv(light, pname, &params);
}
void QOpenGLFunctions_1_5_GlGetMapfv2(void* ptr, unsigned int target, unsigned int query, float v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetMapfv(target, query, &v);
}
void QOpenGLFunctions_1_5_GlGetMapiv2(void* ptr, unsigned int target, unsigned int query, int v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetMapiv(target, query, &v);
}
void QOpenGLFunctions_1_5_GlGetMaterialfv2(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetMaterialfv(face, pname, &params);
}
void QOpenGLFunctions_1_5_GlGetMaterialiv2(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetMaterialiv(face, pname, &params);
}
void QOpenGLFunctions_1_5_GlGetMinmax2(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetMinmax(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_1_5_GlGetMinmaxParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetMinmaxParameterfv(target, pname, &params);
}
void QOpenGLFunctions_1_5_GlGetMinmaxParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetMinmaxParameteriv(target, pname, &params);
}
void QOpenGLFunctions_1_5_GlGetPixelMapfv2(void* ptr, unsigned int m, float values)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetPixelMapfv(m, &values);
}
void QOpenGLFunctions_1_5_GlGetPixelMapuiv2(void* ptr, unsigned int m, unsigned int values)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetPixelMapuiv(m, &values);
}
void QOpenGLFunctions_1_5_GlGetPixelMapusv2(void* ptr, unsigned int m, unsigned short values)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetPixelMapusv(m, &values);
}
void QOpenGLFunctions_1_5_GlGetPointerv2(void* ptr, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetPointerv(pname, &params);
}
void QOpenGLFunctions_1_5_GlGetPolygonStipple2(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetPolygonStipple(static_cast<GLubyte*>(static_cast<void*>(mask)));
}
void QOpenGLFunctions_1_5_GlGetQueryObjectiv2(void* ptr, unsigned int id, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetQueryObjectiv(id, pname, &params);
}
void QOpenGLFunctions_1_5_GlGetQueryObjectuiv2(void* ptr, unsigned int id, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetQueryObjectuiv(id, pname, &params);
}
void QOpenGLFunctions_1_5_GlGetQueryiv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetQueryiv(target, pname, &params);
}
void QOpenGLFunctions_1_5_GlGetSeparableFilter2(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* row, void* column, void* span)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetSeparableFilter(target, format, ty, row, column, span);
}
void QOpenGLFunctions_1_5_GlGetTexEnvfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetTexEnvfv(target, pname, &params);
}
void QOpenGLFunctions_1_5_GlGetTexEnviv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetTexEnviv(target, pname, &params);
}
void QOpenGLFunctions_1_5_GlGetTexGenfv2(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetTexGenfv(coord, pname, &params);
}
void QOpenGLFunctions_1_5_GlGetTexGeniv2(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetTexGeniv(coord, pname, &params);
}
void QOpenGLFunctions_1_5_GlGetTexImage2(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_1_5_GlGetTexLevelParameterfv2(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_1_5_GlGetTexLevelParameteriv2(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_1_5_GlGetTexParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_1_5_GlGetTexParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_1_5_GlHint2(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_1_5_GlHistogram2(void* ptr, unsigned int target, int width, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glHistogram(target, width, internalformat, sink != 0);
}
void QOpenGLFunctions_1_5_GlIndexMask2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glIndexMask(mask);
}
void QOpenGLFunctions_1_5_GlIndexPointer2(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glIndexPointer(ty, stride, pointer);
}
void QOpenGLFunctions_1_5_GlIndexf2(void* ptr, float c)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glIndexf(c);
}
void QOpenGLFunctions_1_5_GlIndexfv2(void* ptr, float c)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glIndexfv(const_cast<const GLfloat*>(&c));
}
void QOpenGLFunctions_1_5_GlIndexi2(void* ptr, int c)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glIndexi(c);
}
void QOpenGLFunctions_1_5_GlIndexiv2(void* ptr, int c)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glIndexiv(const_cast<const GLint*>(&c));
}
void QOpenGLFunctions_1_5_GlIndexs2(void* ptr, short c)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glIndexs(c);
}
void QOpenGLFunctions_1_5_GlIndexsv2(void* ptr, short c)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glIndexsv(const_cast<const GLshort*>(&c));
}
void QOpenGLFunctions_1_5_GlIndexub2(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glIndexub(*static_cast<GLubyte*>(static_cast<void*>(c)));
}
void QOpenGLFunctions_1_5_GlIndexubv2(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glIndexubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(c))));
}
void QOpenGLFunctions_1_5_GlInitNames2(void* ptr)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glInitNames();
}
void QOpenGLFunctions_1_5_GlInterleavedArrays2(void* ptr, unsigned int format, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glInterleavedArrays(format, stride, pointer);
}
void QOpenGLFunctions_1_5_GlLightModelf2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glLightModelf(pname, param);
}
void QOpenGLFunctions_1_5_GlLightModelfv2(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glLightModelfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_5_GlLightModeli2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glLightModeli(pname, param);
}
void QOpenGLFunctions_1_5_GlLightModeliv2(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glLightModeliv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_5_GlLightf2(void* ptr, unsigned int light, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glLightf(light, pname, param);
}
void QOpenGLFunctions_1_5_GlLightfv2(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glLightfv(light, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_5_GlLighti2(void* ptr, unsigned int light, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glLighti(light, pname, param);
}
void QOpenGLFunctions_1_5_GlLightiv2(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glLightiv(light, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_5_GlLineStipple2(void* ptr, int factor, unsigned short pattern)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glLineStipple(factor, pattern);
}
void QOpenGLFunctions_1_5_GlLineWidth2(void* ptr, float width)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_1_5_GlListBase2(void* ptr, unsigned int base)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glListBase(base);
}
void QOpenGLFunctions_1_5_GlLoadIdentity2(void* ptr)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glLoadIdentity();
}
void QOpenGLFunctions_1_5_GlLoadMatrixf2(void* ptr, float m)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glLoadMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_1_5_GlLoadName2(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glLoadName(name);
}
void QOpenGLFunctions_1_5_GlLoadTransposeMatrixf2(void* ptr, float m)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glLoadTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_1_5_GlLogicOp2(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_1_5_GlMap1f2(void* ptr, unsigned int target, float u1, float u2, int stride, int order, float points)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMap1f(target, u1, u2, stride, order, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_1_5_GlMap2f2(void* ptr, unsigned int target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float points)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_1_5_GlMapGrid1f2(void* ptr, int un, float u1, float u2)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMapGrid1f(un, u1, u2);
}
void QOpenGLFunctions_1_5_GlMapGrid2f2(void* ptr, int un, float u1, float u2, int vn, float v1, float v2)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMapGrid2f(un, u1, u2, vn, v1, v2);
}
void QOpenGLFunctions_1_5_GlMaterialf2(void* ptr, unsigned int face, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMaterialf(face, pname, param);
}
void QOpenGLFunctions_1_5_GlMaterialfv2(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMaterialfv(face, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_5_GlMateriali2(void* ptr, unsigned int face, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMateriali(face, pname, param);
}
void QOpenGLFunctions_1_5_GlMaterialiv2(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMaterialiv(face, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_5_GlMatrixMode2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMatrixMode(mode);
}
void QOpenGLFunctions_1_5_GlMinmax2(void* ptr, unsigned int target, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMinmax(target, internalformat, sink != 0);
}
void QOpenGLFunctions_1_5_GlMultMatrixf2(void* ptr, float m)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_1_5_GlMultTransposeMatrixf2(void* ptr, float m)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_1_5_GlMultiDrawArrays2(void* ptr, unsigned int mode, int first, int count, int drawcount)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiDrawArrays(mode, const_cast<const GLint*>(&first), const_cast<const GLsizei*>(&count), drawcount);
}
void QOpenGLFunctions_1_5_GlMultiTexCoord1f2(void* ptr, unsigned int target, float s)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiTexCoord1f(target, s);
}
void QOpenGLFunctions_1_5_GlMultiTexCoord1fv2(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiTexCoord1fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_5_GlMultiTexCoord1i2(void* ptr, unsigned int target, int s)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiTexCoord1i(target, s);
}
void QOpenGLFunctions_1_5_GlMultiTexCoord1iv2(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiTexCoord1iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_5_GlMultiTexCoord1s2(void* ptr, unsigned int target, short s)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiTexCoord1s(target, s);
}
void QOpenGLFunctions_1_5_GlMultiTexCoord1sv2(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiTexCoord1sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_5_GlMultiTexCoord2f2(void* ptr, unsigned int target, float s, float t)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiTexCoord2f(target, s, t);
}
void QOpenGLFunctions_1_5_GlMultiTexCoord2fv2(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiTexCoord2fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_5_GlMultiTexCoord2i2(void* ptr, unsigned int target, int s, int t)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiTexCoord2i(target, s, t);
}
void QOpenGLFunctions_1_5_GlMultiTexCoord2iv2(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiTexCoord2iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_5_GlMultiTexCoord2s2(void* ptr, unsigned int target, short s, short t)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiTexCoord2s(target, s, t);
}
void QOpenGLFunctions_1_5_GlMultiTexCoord2sv2(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiTexCoord2sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_5_GlMultiTexCoord3f2(void* ptr, unsigned int target, float s, float t, float r)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiTexCoord3f(target, s, t, r);
}
void QOpenGLFunctions_1_5_GlMultiTexCoord3fv2(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiTexCoord3fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_5_GlMultiTexCoord3i2(void* ptr, unsigned int target, int s, int t, int r)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiTexCoord3i(target, s, t, r);
}
void QOpenGLFunctions_1_5_GlMultiTexCoord3iv2(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiTexCoord3iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_5_GlMultiTexCoord3s2(void* ptr, unsigned int target, short s, short t, short r)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiTexCoord3s(target, s, t, r);
}
void QOpenGLFunctions_1_5_GlMultiTexCoord3sv2(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiTexCoord3sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_5_GlMultiTexCoord4f2(void* ptr, unsigned int target, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiTexCoord4f(target, s, t, r, q);
}
void QOpenGLFunctions_1_5_GlMultiTexCoord4fv2(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiTexCoord4fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_5_GlMultiTexCoord4i2(void* ptr, unsigned int target, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiTexCoord4i(target, s, t, r, q);
}
void QOpenGLFunctions_1_5_GlMultiTexCoord4iv2(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiTexCoord4iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_5_GlMultiTexCoord4s2(void* ptr, unsigned int target, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiTexCoord4s(target, s, t, r, q);
}
void QOpenGLFunctions_1_5_GlMultiTexCoord4sv2(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glMultiTexCoord4sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_5_GlNewList2(void* ptr, unsigned int list, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glNewList(list, mode);
}
void QOpenGLFunctions_1_5_GlNormal3f2(void* ptr, float nx, float ny, float nz)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glNormal3f(nx, ny, nz);
}
void QOpenGLFunctions_1_5_GlNormal3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glNormal3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_5_GlNormal3i2(void* ptr, int nx, int ny, int nz)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glNormal3i(nx, ny, nz);
}
void QOpenGLFunctions_1_5_GlNormal3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glNormal3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_5_GlNormal3s2(void* ptr, short nx, short ny, short nz)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glNormal3s(nx, ny, nz);
}
void QOpenGLFunctions_1_5_GlNormal3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glNormal3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_5_GlNormalPointer2(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glNormalPointer(ty, stride, pointer);
}
void QOpenGLFunctions_1_5_GlPassThrough2(void* ptr, float token)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPassThrough(token);
}
void QOpenGLFunctions_1_5_GlPixelMapfv2(void* ptr, unsigned int m, int mapsize, float values)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPixelMapfv(m, mapsize, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_1_5_GlPixelMapuiv2(void* ptr, unsigned int m, int mapsize, unsigned int values)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPixelMapuiv(m, mapsize, const_cast<const GLuint*>(&values));
}
void QOpenGLFunctions_1_5_GlPixelMapusv2(void* ptr, unsigned int m, int mapsize, unsigned short values)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPixelMapusv(m, mapsize, const_cast<const GLushort*>(&values));
}
void QOpenGLFunctions_1_5_GlPixelStoref2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_1_5_GlPixelStorei2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_1_5_GlPixelTransferf2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPixelTransferf(pname, param);
}
void QOpenGLFunctions_1_5_GlPixelTransferi2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPixelTransferi(pname, param);
}
void QOpenGLFunctions_1_5_GlPixelZoom2(void* ptr, float xfactor, float yfactor)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPixelZoom(xfactor, yfactor);
}
void QOpenGLFunctions_1_5_GlPointParameterf2(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPointParameterf(pname, param);
}
void QOpenGLFunctions_1_5_GlPointParameterfv2(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPointParameterfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_5_GlPointParameteri2(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPointParameteri(pname, param);
}
void QOpenGLFunctions_1_5_GlPointParameteriv2(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPointParameteriv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_5_GlPointSize2(void* ptr, float size)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_1_5_GlPolygonMode2(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_1_5_GlPolygonOffset2(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_1_5_GlPolygonStipple2(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPolygonStipple(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(mask))));
}
void QOpenGLFunctions_1_5_GlPopAttrib2(void* ptr)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPopAttrib();
}
void QOpenGLFunctions_1_5_GlPopClientAttrib2(void* ptr)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPopClientAttrib();
}
void QOpenGLFunctions_1_5_GlPopMatrix2(void* ptr)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPopMatrix();
}
void QOpenGLFunctions_1_5_GlPopName2(void* ptr)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPopName();
}
void QOpenGLFunctions_1_5_GlPrioritizeTextures2(void* ptr, int n, unsigned int textures, float priorities)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPrioritizeTextures(n, const_cast<const GLuint*>(&textures), const_cast<const GLfloat*>(&priorities));
}
void QOpenGLFunctions_1_5_GlPushAttrib2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPushAttrib(mask);
}
void QOpenGLFunctions_1_5_GlPushClientAttrib2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPushClientAttrib(mask);
}
void QOpenGLFunctions_1_5_GlPushMatrix2(void* ptr)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPushMatrix();
}
void QOpenGLFunctions_1_5_GlPushName2(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glPushName(name);
}
void QOpenGLFunctions_1_5_GlRasterPos2f2(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRasterPos2f(x, y);
}
void QOpenGLFunctions_1_5_GlRasterPos2fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRasterPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_5_GlRasterPos2i2(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRasterPos2i(x, y);
}
void QOpenGLFunctions_1_5_GlRasterPos2iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRasterPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_5_GlRasterPos2s2(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRasterPos2s(x, y);
}
void QOpenGLFunctions_1_5_GlRasterPos2sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRasterPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_5_GlRasterPos3f2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRasterPos3f(x, y, z);
}
void QOpenGLFunctions_1_5_GlRasterPos3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRasterPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_5_GlRasterPos3i2(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRasterPos3i(x, y, z);
}
void QOpenGLFunctions_1_5_GlRasterPos3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRasterPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_5_GlRasterPos3s2(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRasterPos3s(x, y, z);
}
void QOpenGLFunctions_1_5_GlRasterPos3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRasterPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_5_GlRasterPos4f2(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRasterPos4f(x, y, z, w);
}
void QOpenGLFunctions_1_5_GlRasterPos4fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRasterPos4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_5_GlRasterPos4i2(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRasterPos4i(x, y, z, w);
}
void QOpenGLFunctions_1_5_GlRasterPos4iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRasterPos4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_5_GlRasterPos4s2(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRasterPos4s(x, y, z, w);
}
void QOpenGLFunctions_1_5_GlRasterPos4sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRasterPos4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_5_GlReadBuffer2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glReadBuffer(mode);
}
void QOpenGLFunctions_1_5_GlReadPixels2(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_1_5_GlRectf2(void* ptr, float x1, float y1, float x2, float y2)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRectf(x1, y1, x2, y2);
}
void QOpenGLFunctions_1_5_GlRectfv2(void* ptr, float v1, float v2)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRectfv(const_cast<const GLfloat*>(&v1), const_cast<const GLfloat*>(&v2));
}
void QOpenGLFunctions_1_5_GlRecti2(void* ptr, int x1, int y1, int x2, int y2)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRecti(x1, y1, x2, y2);
}
void QOpenGLFunctions_1_5_GlRectiv2(void* ptr, int v1, int v2)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRectiv(const_cast<const GLint*>(&v1), const_cast<const GLint*>(&v2));
}
void QOpenGLFunctions_1_5_GlRects2(void* ptr, short x1, short y1, short x2, short y2)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRects(x1, y1, x2, y2);
}
void QOpenGLFunctions_1_5_GlRectsv2(void* ptr, short v1, short v2)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRectsv(const_cast<const GLshort*>(&v1), const_cast<const GLshort*>(&v2));
}
void QOpenGLFunctions_1_5_GlResetHistogram2(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glResetHistogram(target);
}
void QOpenGLFunctions_1_5_GlResetMinmax2(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glResetMinmax(target);
}
void QOpenGLFunctions_1_5_GlRotatef2(void* ptr, float angle, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glRotatef(angle, x, y, z);
}
void QOpenGLFunctions_1_5_GlSampleCoverage2(void* ptr, float value, char invert)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glSampleCoverage(value, invert != 0);
}
void QOpenGLFunctions_1_5_GlScalef2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glScalef(x, y, z);
}
void QOpenGLFunctions_1_5_GlScissor2(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_1_5_GlSecondaryColor3f2(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glSecondaryColor3f(red, green, blue);
}
void QOpenGLFunctions_1_5_GlSecondaryColor3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glSecondaryColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_5_GlSecondaryColor3i2(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glSecondaryColor3i(red, green, blue);
}
void QOpenGLFunctions_1_5_GlSecondaryColor3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glSecondaryColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_5_GlSecondaryColor3s2(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glSecondaryColor3s(red, green, blue);
}
void QOpenGLFunctions_1_5_GlSecondaryColor3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glSecondaryColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_5_GlSecondaryColor3ub2(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glSecondaryColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_1_5_GlSecondaryColor3ubv2(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glSecondaryColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_1_5_GlSecondaryColor3ui2(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glSecondaryColor3ui(red, green, blue);
}
void QOpenGLFunctions_1_5_GlSecondaryColor3uiv2(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glSecondaryColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_1_5_GlSecondaryColor3us2(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glSecondaryColor3us(red, green, blue);
}
void QOpenGLFunctions_1_5_GlSecondaryColor3usv2(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glSecondaryColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_1_5_GlSecondaryColorPointer2(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glSecondaryColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_1_5_GlSelectBuffer2(void* ptr, int size, unsigned int buffer)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glSelectBuffer(size, &buffer);
}
void QOpenGLFunctions_1_5_GlSeparableFilter2D2(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* row, void* column)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glSeparableFilter2D(target, internalformat, width, height, format, ty, row, column);
}
void QOpenGLFunctions_1_5_GlShadeModel2(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glShadeModel(mode);
}
void QOpenGLFunctions_1_5_GlStencilFunc2(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_1_5_GlStencilMask2(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_1_5_GlStencilOp2(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_1_5_GlTexCoord1f2(void* ptr, float s)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoord1f(s);
}
void QOpenGLFunctions_1_5_GlTexCoord1fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoord1fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_5_GlTexCoord1i2(void* ptr, int s)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoord1i(s);
}
void QOpenGLFunctions_1_5_GlTexCoord1iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoord1iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_5_GlTexCoord1s2(void* ptr, short s)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoord1s(s);
}
void QOpenGLFunctions_1_5_GlTexCoord1sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoord1sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_5_GlTexCoord2f2(void* ptr, float s, float t)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoord2f(s, t);
}
void QOpenGLFunctions_1_5_GlTexCoord2fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoord2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_5_GlTexCoord2i2(void* ptr, int s, int t)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoord2i(s, t);
}
void QOpenGLFunctions_1_5_GlTexCoord2iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoord2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_5_GlTexCoord2s2(void* ptr, short s, short t)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoord2s(s, t);
}
void QOpenGLFunctions_1_5_GlTexCoord2sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoord2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_5_GlTexCoord3f2(void* ptr, float s, float t, float r)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoord3f(s, t, r);
}
void QOpenGLFunctions_1_5_GlTexCoord3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoord3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_5_GlTexCoord3i2(void* ptr, int s, int t, int r)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoord3i(s, t, r);
}
void QOpenGLFunctions_1_5_GlTexCoord3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoord3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_5_GlTexCoord3s2(void* ptr, short s, short t, short r)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoord3s(s, t, r);
}
void QOpenGLFunctions_1_5_GlTexCoord3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoord3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_5_GlTexCoord4f2(void* ptr, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoord4f(s, t, r, q);
}
void QOpenGLFunctions_1_5_GlTexCoord4fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoord4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_5_GlTexCoord4i2(void* ptr, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoord4i(s, t, r, q);
}
void QOpenGLFunctions_1_5_GlTexCoord4iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoord4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_5_GlTexCoord4s2(void* ptr, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoord4s(s, t, r, q);
}
void QOpenGLFunctions_1_5_GlTexCoord4sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoord4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_5_GlTexCoordPointer2(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexCoordPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_1_5_GlTexEnvf2(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexEnvf(target, pname, param);
}
void QOpenGLFunctions_1_5_GlTexEnvfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexEnvfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_5_GlTexEnvi2(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexEnvi(target, pname, param);
}
void QOpenGLFunctions_1_5_GlTexEnviv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexEnviv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_5_GlTexGenf2(void* ptr, unsigned int coord, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexGenf(coord, pname, param);
}
void QOpenGLFunctions_1_5_GlTexGenfv2(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexGenfv(coord, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_5_GlTexGeni2(void* ptr, unsigned int coord, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexGeni(coord, pname, param);
}
void QOpenGLFunctions_1_5_GlTexGeniv2(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexGeniv(coord, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_5_GlTexImage1D2(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_1_5_GlTexImage2D2(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_1_5_GlTexImage3D2(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLFunctions_1_5_GlTexParameterf2(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_1_5_GlTexParameterfv2(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_1_5_GlTexParameteri2(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_1_5_GlTexParameteriv2(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_1_5_GlTexSubImage1D2(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_1_5_GlTexSubImage2D2(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_1_5_GlTexSubImage3D2(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_1_5_GlTranslatef2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glTranslatef(x, y, z);
}
void QOpenGLFunctions_1_5_GlVertex2f2(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glVertex2f(x, y);
}
void QOpenGLFunctions_1_5_GlVertex2fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glVertex2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_5_GlVertex2i2(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glVertex2i(x, y);
}
void QOpenGLFunctions_1_5_GlVertex2iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glVertex2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_5_GlVertex2s2(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glVertex2s(x, y);
}
void QOpenGLFunctions_1_5_GlVertex2sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glVertex2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_5_GlVertex3f2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glVertex3f(x, y, z);
}
void QOpenGLFunctions_1_5_GlVertex3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glVertex3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_5_GlVertex3i2(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glVertex3i(x, y, z);
}
void QOpenGLFunctions_1_5_GlVertex3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glVertex3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_5_GlVertex3s2(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glVertex3s(x, y, z);
}
void QOpenGLFunctions_1_5_GlVertex3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glVertex3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_5_GlVertex4f2(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glVertex4f(x, y, z, w);
}
void QOpenGLFunctions_1_5_GlVertex4fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glVertex4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_5_GlVertex4i2(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glVertex4i(x, y, z, w);
}
void QOpenGLFunctions_1_5_GlVertex4iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glVertex4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_5_GlVertex4s2(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glVertex4s(x, y, z, w);
}
void QOpenGLFunctions_1_5_GlVertex4sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glVertex4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_5_GlVertexPointer2(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glVertexPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_1_5_GlViewport2(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_1_5_GlWindowPos2f2(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glWindowPos2f(x, y);
}
void QOpenGLFunctions_1_5_GlWindowPos2fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glWindowPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_5_GlWindowPos2i2(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glWindowPos2i(x, y);
}
void QOpenGLFunctions_1_5_GlWindowPos2iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glWindowPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_5_GlWindowPos2s2(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glWindowPos2s(x, y);
}
void QOpenGLFunctions_1_5_GlWindowPos2sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glWindowPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_5_GlWindowPos3f2(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glWindowPos3f(x, y, z);
}
void QOpenGLFunctions_1_5_GlWindowPos3fv2(void* ptr, float v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glWindowPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_1_5_GlWindowPos3i2(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glWindowPos3i(x, y, z);
}
void QOpenGLFunctions_1_5_GlWindowPos3iv2(void* ptr, int v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glWindowPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_1_5_GlWindowPos3s2(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glWindowPos3s(x, y, z);
}
void QOpenGLFunctions_1_5_GlWindowPos3sv2(void* ptr, short v)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->glWindowPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_1_5_DestroyQOpenGLFunctions_1_52(void* ptr)
{
static_cast<QOpenGLFunctions_1_5*>(ptr)->~QOpenGLFunctions_1_5();
}
void QOpenGLFunctions_1_5_DestroyQOpenGLFunctions_1_52Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_2_0: public QOpenGLFunctions_2_0
{
public:
MyQOpenGLFunctions_2_0() : QOpenGLFunctions_2_0() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_2_0_InitializeOpenGLFunctions3(this) != 0; };
~MyQOpenGLFunctions_2_0() { callbackQOpenGLFunctions_2_0_DestroyQOpenGLFunctions_2_03(this); };
};
char QOpenGLFunctions_2_0_GlAreTexturesResident3(void* ptr, int n, unsigned int textures, char residences)
{
Q_UNUSED(residences);
return static_cast<QOpenGLFunctions_2_0*>(ptr)->glAreTexturesResident(n, const_cast<const GLuint*>(&textures), NULL);
}
char QOpenGLFunctions_2_0_GlIsBuffer3(void* ptr, unsigned int buffer)
{
return static_cast<QOpenGLFunctions_2_0*>(ptr)->glIsBuffer(buffer);
}
char QOpenGLFunctions_2_0_GlIsEnabled3(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_2_0*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_2_0_GlIsList3(void* ptr, unsigned int list)
{
return static_cast<QOpenGLFunctions_2_0*>(ptr)->glIsList(list);
}
char QOpenGLFunctions_2_0_GlIsProgram3(void* ptr, unsigned int program)
{
return static_cast<QOpenGLFunctions_2_0*>(ptr)->glIsProgram(program);
}
char QOpenGLFunctions_2_0_GlIsQuery3(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_2_0*>(ptr)->glIsQuery(id);
}
char QOpenGLFunctions_2_0_GlIsShader3(void* ptr, unsigned int shader)
{
return static_cast<QOpenGLFunctions_2_0*>(ptr)->glIsShader(shader);
}
char QOpenGLFunctions_2_0_GlIsTexture3(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_2_0*>(ptr)->glIsTexture(texture);
}
char QOpenGLFunctions_2_0_GlUnmapBuffer3(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_2_0*>(ptr)->glUnmapBuffer(target);
}
unsigned int QOpenGLFunctions_2_0_GlGetError3(void* ptr)
{
return static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetError();
}
int QOpenGLFunctions_2_0_GlRenderMode3(void* ptr, unsigned int mode)
{
return static_cast<QOpenGLFunctions_2_0*>(ptr)->glRenderMode(mode);
}
unsigned int QOpenGLFunctions_2_0_GlCreateProgram3(void* ptr)
{
return static_cast<QOpenGLFunctions_2_0*>(ptr)->glCreateProgram();
}
unsigned int QOpenGLFunctions_2_0_GlCreateShader3(void* ptr, unsigned int ty)
{
return static_cast<QOpenGLFunctions_2_0*>(ptr)->glCreateShader(ty);
}
unsigned int QOpenGLFunctions_2_0_GlGenLists3(void* ptr, int ran)
{
return static_cast<QOpenGLFunctions_2_0*>(ptr)->glGenLists(ran);
}
void* QOpenGLFunctions_2_0_GlMapBuffer3(void* ptr, unsigned int target, unsigned int access)
{
return static_cast<QOpenGLFunctions_2_0*>(ptr)->glMapBuffer(target, access);
}
void* QOpenGLFunctions_2_0_NewQOpenGLFunctions_2_03()
{
return new MyQOpenGLFunctions_2_0();
}
char QOpenGLFunctions_2_0_InitializeOpenGLFunctions3(void* ptr)
{
return static_cast<QOpenGLFunctions_2_0*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_2_0_InitializeOpenGLFunctions3Default(void* ptr)
{
return static_cast<QOpenGLFunctions_2_0*>(ptr)->QOpenGLFunctions_2_0::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_2_0_GlGetString3(void* ptr, unsigned int name)
{
return ({ char* tb7cb67 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetString(name)))); QtGui_PackedString { tb7cb67, -1 }; });
}
void QOpenGLFunctions_2_0_GlAccum3(void* ptr, unsigned int op, float value)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glAccum(op, value);
}
void QOpenGLFunctions_2_0_GlActiveTexture3(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glActiveTexture(texture);
}
void QOpenGLFunctions_2_0_GlAlphaFunc3(void* ptr, unsigned int fu, float ref)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glAlphaFunc(fu, ref);
}
void QOpenGLFunctions_2_0_GlArrayElement3(void* ptr, int i)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glArrayElement(i);
}
void QOpenGLFunctions_2_0_GlAttachShader3(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glAttachShader(program, shader);
}
void QOpenGLFunctions_2_0_GlBegin3(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glBegin(mode);
}
void QOpenGLFunctions_2_0_GlBeginQuery3(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glBeginQuery(target, id);
}
void QOpenGLFunctions_2_0_GlBindBuffer3(void* ptr, unsigned int target, unsigned int buffer)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glBindBuffer(target, buffer);
}
void QOpenGLFunctions_2_0_GlBindTexture3(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_2_0_GlBitmap3(void* ptr, int width, int height, float xorig, float yorig, float xmove, float ymove, char* bitmap)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glBitmap(width, height, xorig, yorig, xmove, ymove, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(bitmap))));
}
void QOpenGLFunctions_2_0_GlBlendColor3(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_2_0_GlBlendEquation3(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_2_0_GlBlendEquationSeparate3(void* ptr, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glBlendEquationSeparate(modeRGB, modeAlpha);
}
void QOpenGLFunctions_2_0_GlBlendFunc3(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_2_0_GlBlendFuncSeparate3(void* ptr, unsigned int sfactorRGB, unsigned int dfactorRGB, unsigned int sfactorAlpha, unsigned int dfactorAlpha)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void QOpenGLFunctions_2_0_GlCallList3(void* ptr, unsigned int list)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glCallList(list);
}
void QOpenGLFunctions_2_0_GlCallLists3(void* ptr, int n, unsigned int ty, void* lists)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glCallLists(n, ty, lists);
}
void QOpenGLFunctions_2_0_GlClear3(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_2_0_GlClearAccum3(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glClearAccum(red, green, blue, alpha);
}
void QOpenGLFunctions_2_0_GlClearColor3(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_2_0_GlClearIndex3(void* ptr, float c)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glClearIndex(c);
}
void QOpenGLFunctions_2_0_GlClearStencil3(void* ptr, int s)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_2_0_GlClientActiveTexture3(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glClientActiveTexture(texture);
}
void QOpenGLFunctions_2_0_GlColor3f3(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColor3f(red, green, blue);
}
void QOpenGLFunctions_2_0_GlColor3fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_0_GlColor3i3(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColor3i(red, green, blue);
}
void QOpenGLFunctions_2_0_GlColor3iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_0_GlColor3s3(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColor3s(red, green, blue);
}
void QOpenGLFunctions_2_0_GlColor3sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_GlColor3ub3(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_2_0_GlColor3ubv3(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_2_0_GlColor3ui3(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColor3ui(red, green, blue);
}
void QOpenGLFunctions_2_0_GlColor3uiv3(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_2_0_GlColor3us3(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColor3us(red, green, blue);
}
void QOpenGLFunctions_2_0_GlColor3usv3(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_2_0_GlColor4f3(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColor4f(red, green, blue, alpha);
}
void QOpenGLFunctions_2_0_GlColor4fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColor4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_0_GlColor4i3(void* ptr, int red, int green, int blue, int alpha)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColor4i(red, green, blue, alpha);
}
void QOpenGLFunctions_2_0_GlColor4iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColor4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_0_GlColor4s3(void* ptr, short red, short green, short blue, short alpha)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColor4s(red, green, blue, alpha);
}
void QOpenGLFunctions_2_0_GlColor4sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColor4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_GlColor4ub3(void* ptr, char* red, char* green, char* blue, char* alpha)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColor4ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)), *static_cast<GLubyte*>(static_cast<void*>(alpha)));
}
void QOpenGLFunctions_2_0_GlColor4ubv3(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColor4ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_2_0_GlColor4ui3(void* ptr, unsigned int red, unsigned int green, unsigned int blue, unsigned int alpha)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColor4ui(red, green, blue, alpha);
}
void QOpenGLFunctions_2_0_GlColor4uiv3(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColor4uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_2_0_GlColor4us3(void* ptr, unsigned short red, unsigned short green, unsigned short blue, unsigned short alpha)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColor4us(red, green, blue, alpha);
}
void QOpenGLFunctions_2_0_GlColor4usv3(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColor4usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_2_0_GlColorMask3(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_2_0_GlColorMaterial3(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColorMaterial(face, mode);
}
void QOpenGLFunctions_2_0_GlColorPointer3(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_2_0_GlColorSubTable3(void* ptr, unsigned int target, int start, int count, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColorSubTable(target, start, count, format, ty, data);
}
void QOpenGLFunctions_2_0_GlColorTable3(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColorTable(target, internalformat, width, format, ty, table);
}
void QOpenGLFunctions_2_0_GlColorTableParameterfv3(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColorTableParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_2_0_GlColorTableParameteriv3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glColorTableParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_2_0_GlCompileShader3(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glCompileShader(shader);
}
void QOpenGLFunctions_2_0_GlCompressedTexImage1D3(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
void QOpenGLFunctions_2_0_GlCompressedTexImage2D3(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void QOpenGLFunctions_2_0_GlCompressedTexImage3D3(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int depth, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void QOpenGLFunctions_2_0_GlCompressedTexSubImage1D3(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_2_0_GlCompressedTexSubImage2D3(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_2_0_GlCompressedTexSubImage3D3(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_2_0_GlConvolutionFilter1D3(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glConvolutionFilter1D(target, internalformat, width, format, ty, image);
}
void QOpenGLFunctions_2_0_GlConvolutionFilter2D3(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glConvolutionFilter2D(target, internalformat, width, height, format, ty, image);
}
void QOpenGLFunctions_2_0_GlConvolutionParameterf3(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glConvolutionParameterf(target, pname, params);
}
void QOpenGLFunctions_2_0_GlConvolutionParameterfv3(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glConvolutionParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_2_0_GlConvolutionParameteri3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glConvolutionParameteri(target, pname, params);
}
void QOpenGLFunctions_2_0_GlConvolutionParameteriv3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glConvolutionParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_2_0_GlCopyColorSubTable3(void* ptr, unsigned int target, int start, int x, int y, int width)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glCopyColorSubTable(target, start, x, y, width);
}
void QOpenGLFunctions_2_0_GlCopyColorTable3(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glCopyColorTable(target, internalformat, x, y, width);
}
void QOpenGLFunctions_2_0_GlCopyConvolutionFilter1D3(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glCopyConvolutionFilter1D(target, internalformat, x, y, width);
}
void QOpenGLFunctions_2_0_GlCopyConvolutionFilter2D3(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);
}
void QOpenGLFunctions_2_0_GlCopyPixels3(void* ptr, int x, int y, int width, int height, unsigned int ty)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glCopyPixels(x, y, width, height, ty);
}
void QOpenGLFunctions_2_0_GlCopyTexImage1D3(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_2_0_GlCopyTexImage2D3(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_2_0_GlCopyTexSubImage1D3(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_2_0_GlCopyTexSubImage2D3(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_2_0_GlCopyTexSubImage3D3(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_2_0_GlCullFace3(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_2_0_GlDeleteBuffers3(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glDeleteBuffers(n, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_2_0_GlDeleteLists3(void* ptr, unsigned int list, int ran)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glDeleteLists(list, ran);
}
void QOpenGLFunctions_2_0_GlDeleteProgram3(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glDeleteProgram(program);
}
void QOpenGLFunctions_2_0_GlDeleteQueries3(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glDeleteQueries(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_2_0_GlDeleteShader3(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glDeleteShader(shader);
}
void QOpenGLFunctions_2_0_GlDeleteTextures3(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_2_0_GlDepthFunc3(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_2_0_GlDepthMask3(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_2_0_GlDetachShader3(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glDetachShader(program, shader);
}
void QOpenGLFunctions_2_0_GlDisable3(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_2_0_GlDisableClientState3(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glDisableClientState(array);
}
void QOpenGLFunctions_2_0_GlDisableVertexAttribArray3(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glDisableVertexAttribArray(index);
}
void QOpenGLFunctions_2_0_GlDrawArrays3(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_2_0_GlDrawBuffer3(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glDrawBuffer(mode);
}
void QOpenGLFunctions_2_0_GlDrawBuffers3(void* ptr, int n, unsigned int bufs)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glDrawBuffers(n, const_cast<const GLenum*>(&bufs));
}
void QOpenGLFunctions_2_0_GlDrawElements3(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_2_0_GlDrawPixels3(void* ptr, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glDrawPixels(width, height, format, ty, pixels);
}
void QOpenGLFunctions_2_0_GlDrawRangeElements3(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLFunctions_2_0_GlEdgeFlag3(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glEdgeFlag(flag != 0);
}
void QOpenGLFunctions_2_0_GlEdgeFlagPointer3(void* ptr, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glEdgeFlagPointer(stride, pointer);
}
void QOpenGLFunctions_2_0_GlEdgeFlagv3(void* ptr, char flag)
{
Q_UNUSED(flag);
static_cast<QOpenGLFunctions_2_0*>(ptr)->glEdgeFlagv(NULL);
}
void QOpenGLFunctions_2_0_GlEnable3(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_2_0_GlEnableClientState3(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glEnableClientState(array);
}
void QOpenGLFunctions_2_0_GlEnableVertexAttribArray3(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glEnableVertexAttribArray(index);
}
void QOpenGLFunctions_2_0_GlEnd3(void* ptr)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glEnd();
}
void QOpenGLFunctions_2_0_GlEndList3(void* ptr)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glEndList();
}
void QOpenGLFunctions_2_0_GlEndQuery3(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glEndQuery(target);
}
void QOpenGLFunctions_2_0_GlEvalCoord1f3(void* ptr, float u)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glEvalCoord1f(u);
}
void QOpenGLFunctions_2_0_GlEvalCoord1fv3(void* ptr, float u)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glEvalCoord1fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_2_0_GlEvalCoord2f3(void* ptr, float u, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glEvalCoord2f(u, v);
}
void QOpenGLFunctions_2_0_GlEvalCoord2fv3(void* ptr, float u)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glEvalCoord2fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_2_0_GlEvalMesh13(void* ptr, unsigned int mode, int i1, int i2)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glEvalMesh1(mode, i1, i2);
}
void QOpenGLFunctions_2_0_GlEvalMesh23(void* ptr, unsigned int mode, int i1, int i2, int j1, int j2)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glEvalMesh2(mode, i1, i2, j1, j2);
}
void QOpenGLFunctions_2_0_GlEvalPoint13(void* ptr, int i)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glEvalPoint1(i);
}
void QOpenGLFunctions_2_0_GlEvalPoint23(void* ptr, int i, int j)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glEvalPoint2(i, j);
}
void QOpenGLFunctions_2_0_GlFeedbackBuffer3(void* ptr, int size, unsigned int ty, float buffer)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glFeedbackBuffer(size, ty, &buffer);
}
void QOpenGLFunctions_2_0_GlFinish3(void* ptr)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glFinish();
}
void QOpenGLFunctions_2_0_GlFlush3(void* ptr)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glFlush();
}
void QOpenGLFunctions_2_0_GlFogCoordPointer3(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glFogCoordPointer(ty, stride, pointer);
}
void QOpenGLFunctions_2_0_GlFogCoordf3(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glFogCoordf(coord);
}
void QOpenGLFunctions_2_0_GlFogCoordfv3(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glFogCoordfv(const_cast<const GLfloat*>(&coord));
}
void QOpenGLFunctions_2_0_GlFogf3(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glFogf(pname, param);
}
void QOpenGLFunctions_2_0_GlFogfv3(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glFogfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_2_0_GlFogi3(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glFogi(pname, param);
}
void QOpenGLFunctions_2_0_GlFogiv3(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glFogiv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_2_0_GlFrontFace3(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_2_0_GlGenBuffers3(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGenBuffers(n, &buffers);
}
void QOpenGLFunctions_2_0_GlGenQueries3(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGenQueries(n, &ids);
}
void QOpenGLFunctions_2_0_GlGenTextures3(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_2_0_GlGetAttachedShaders3(void* ptr, unsigned int program, int maxCount, int count, unsigned int obj)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetAttachedShaders(program, maxCount, &count, &obj);
}
void QOpenGLFunctions_2_0_GlGetBooleanv3(void* ptr, unsigned int pname, char params)
{
Q_UNUSED(params);
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_2_0_GlGetBufferParameteriv3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetBufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetBufferPointerv3(void* ptr, unsigned int target, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetBufferPointerv(target, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetColorTable3(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetColorTable(target, format, ty, table);
}
void QOpenGLFunctions_2_0_GlGetColorTableParameterfv3(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetColorTableParameterfv(target, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetColorTableParameteriv3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetColorTableParameteriv(target, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetCompressedTexImage3(void* ptr, unsigned int target, int level, void* img)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetCompressedTexImage(target, level, img);
}
void QOpenGLFunctions_2_0_GlGetConvolutionFilter3(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetConvolutionFilter(target, format, ty, image);
}
void QOpenGLFunctions_2_0_GlGetConvolutionParameterfv3(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetConvolutionParameterfv(target, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetConvolutionParameteriv3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetConvolutionParameteriv(target, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetFloatv3(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetFloatv(pname, &params);
}
void QOpenGLFunctions_2_0_GlGetHistogram3(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetHistogram(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_2_0_GlGetHistogramParameterfv3(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetHistogramParameterfv(target, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetHistogramParameteriv3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetHistogramParameteriv(target, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetIntegerv3(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetIntegerv(pname, &params);
}
void QOpenGLFunctions_2_0_GlGetLightfv3(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetLightfv(light, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetLightiv3(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetLightiv(light, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetMapfv3(void* ptr, unsigned int target, unsigned int query, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetMapfv(target, query, &v);
}
void QOpenGLFunctions_2_0_GlGetMapiv3(void* ptr, unsigned int target, unsigned int query, int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetMapiv(target, query, &v);
}
void QOpenGLFunctions_2_0_GlGetMaterialfv3(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetMaterialfv(face, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetMaterialiv3(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetMaterialiv(face, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetMinmax3(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetMinmax(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_2_0_GlGetMinmaxParameterfv3(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetMinmaxParameterfv(target, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetMinmaxParameteriv3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetMinmaxParameteriv(target, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetPixelMapfv3(void* ptr, unsigned int m, float values)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetPixelMapfv(m, &values);
}
void QOpenGLFunctions_2_0_GlGetPixelMapuiv3(void* ptr, unsigned int m, unsigned int values)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetPixelMapuiv(m, &values);
}
void QOpenGLFunctions_2_0_GlGetPixelMapusv3(void* ptr, unsigned int m, unsigned short values)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetPixelMapusv(m, &values);
}
void QOpenGLFunctions_2_0_GlGetPointerv3(void* ptr, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetPointerv(pname, &params);
}
void QOpenGLFunctions_2_0_GlGetPolygonStipple3(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetPolygonStipple(static_cast<GLubyte*>(static_cast<void*>(mask)));
}
void QOpenGLFunctions_2_0_GlGetProgramiv3(void* ptr, unsigned int program, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetProgramiv(program, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetQueryObjectiv3(void* ptr, unsigned int id, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetQueryObjectiv(id, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetQueryObjectuiv3(void* ptr, unsigned int id, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetQueryObjectuiv(id, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetQueryiv3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetQueryiv(target, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetSeparableFilter3(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* row, void* column, void* span)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetSeparableFilter(target, format, ty, row, column, span);
}
void QOpenGLFunctions_2_0_GlGetShaderiv3(void* ptr, unsigned int shader, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetShaderiv(shader, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetTexEnvfv3(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetTexEnvfv(target, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetTexEnviv3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetTexEnviv(target, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetTexGenfv3(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetTexGenfv(coord, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetTexGeniv3(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetTexGeniv(coord, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetTexImage3(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_2_0_GlGetTexLevelParameterfv3(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetTexLevelParameteriv3(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetTexParameterfv3(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetTexParameteriv3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetUniformfv3(void* ptr, unsigned int program, int location, float params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetUniformfv(program, location, &params);
}
void QOpenGLFunctions_2_0_GlGetUniformiv3(void* ptr, unsigned int program, int location, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetUniformiv(program, location, &params);
}
void QOpenGLFunctions_2_0_GlGetVertexAttribPointerv3(void* ptr, unsigned int index, unsigned int pname, void* pointer)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetVertexAttribPointerv(index, pname, &pointer);
}
void QOpenGLFunctions_2_0_GlGetVertexAttribfv3(void* ptr, unsigned int index, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetVertexAttribfv(index, pname, &params);
}
void QOpenGLFunctions_2_0_GlGetVertexAttribiv3(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glGetVertexAttribiv(index, pname, &params);
}
void QOpenGLFunctions_2_0_GlHint3(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_2_0_GlHistogram3(void* ptr, unsigned int target, int width, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glHistogram(target, width, internalformat, sink != 0);
}
void QOpenGLFunctions_2_0_GlIndexMask3(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glIndexMask(mask);
}
void QOpenGLFunctions_2_0_GlIndexPointer3(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glIndexPointer(ty, stride, pointer);
}
void QOpenGLFunctions_2_0_GlIndexf3(void* ptr, float c)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glIndexf(c);
}
void QOpenGLFunctions_2_0_GlIndexfv3(void* ptr, float c)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glIndexfv(const_cast<const GLfloat*>(&c));
}
void QOpenGLFunctions_2_0_GlIndexi3(void* ptr, int c)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glIndexi(c);
}
void QOpenGLFunctions_2_0_GlIndexiv3(void* ptr, int c)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glIndexiv(const_cast<const GLint*>(&c));
}
void QOpenGLFunctions_2_0_GlIndexs3(void* ptr, short c)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glIndexs(c);
}
void QOpenGLFunctions_2_0_GlIndexsv3(void* ptr, short c)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glIndexsv(const_cast<const GLshort*>(&c));
}
void QOpenGLFunctions_2_0_GlIndexub3(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glIndexub(*static_cast<GLubyte*>(static_cast<void*>(c)));
}
void QOpenGLFunctions_2_0_GlIndexubv3(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glIndexubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(c))));
}
void QOpenGLFunctions_2_0_GlInitNames3(void* ptr)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glInitNames();
}
void QOpenGLFunctions_2_0_GlInterleavedArrays3(void* ptr, unsigned int format, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glInterleavedArrays(format, stride, pointer);
}
void QOpenGLFunctions_2_0_GlLightModelf3(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glLightModelf(pname, param);
}
void QOpenGLFunctions_2_0_GlLightModelfv3(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glLightModelfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_2_0_GlLightModeli3(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glLightModeli(pname, param);
}
void QOpenGLFunctions_2_0_GlLightModeliv3(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glLightModeliv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_2_0_GlLightf3(void* ptr, unsigned int light, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glLightf(light, pname, param);
}
void QOpenGLFunctions_2_0_GlLightfv3(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glLightfv(light, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_2_0_GlLighti3(void* ptr, unsigned int light, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glLighti(light, pname, param);
}
void QOpenGLFunctions_2_0_GlLightiv3(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glLightiv(light, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_2_0_GlLineStipple3(void* ptr, int factor, unsigned short pattern)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glLineStipple(factor, pattern);
}
void QOpenGLFunctions_2_0_GlLineWidth3(void* ptr, float width)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_2_0_GlLinkProgram3(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glLinkProgram(program);
}
void QOpenGLFunctions_2_0_GlListBase3(void* ptr, unsigned int base)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glListBase(base);
}
void QOpenGLFunctions_2_0_GlLoadIdentity3(void* ptr)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glLoadIdentity();
}
void QOpenGLFunctions_2_0_GlLoadMatrixf3(void* ptr, float m)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glLoadMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_2_0_GlLoadName3(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glLoadName(name);
}
void QOpenGLFunctions_2_0_GlLoadTransposeMatrixf3(void* ptr, float m)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glLoadTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_2_0_GlLogicOp3(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_2_0_GlMap1f3(void* ptr, unsigned int target, float u1, float u2, int stride, int order, float points)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMap1f(target, u1, u2, stride, order, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_2_0_GlMap2f3(void* ptr, unsigned int target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float points)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_2_0_GlMapGrid1f3(void* ptr, int un, float u1, float u2)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMapGrid1f(un, u1, u2);
}
void QOpenGLFunctions_2_0_GlMapGrid2f3(void* ptr, int un, float u1, float u2, int vn, float v1, float v2)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMapGrid2f(un, u1, u2, vn, v1, v2);
}
void QOpenGLFunctions_2_0_GlMaterialf3(void* ptr, unsigned int face, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMaterialf(face, pname, param);
}
void QOpenGLFunctions_2_0_GlMaterialfv3(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMaterialfv(face, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_2_0_GlMateriali3(void* ptr, unsigned int face, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMateriali(face, pname, param);
}
void QOpenGLFunctions_2_0_GlMaterialiv3(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMaterialiv(face, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_2_0_GlMatrixMode3(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMatrixMode(mode);
}
void QOpenGLFunctions_2_0_GlMinmax3(void* ptr, unsigned int target, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMinmax(target, internalformat, sink != 0);
}
void QOpenGLFunctions_2_0_GlMultMatrixf3(void* ptr, float m)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_2_0_GlMultTransposeMatrixf3(void* ptr, float m)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_2_0_GlMultiDrawArrays3(void* ptr, unsigned int mode, int first, int count, int drawcount)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiDrawArrays(mode, const_cast<const GLint*>(&first), const_cast<const GLsizei*>(&count), drawcount);
}
void QOpenGLFunctions_2_0_GlMultiTexCoord1f3(void* ptr, unsigned int target, float s)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiTexCoord1f(target, s);
}
void QOpenGLFunctions_2_0_GlMultiTexCoord1fv3(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiTexCoord1fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_0_GlMultiTexCoord1i3(void* ptr, unsigned int target, int s)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiTexCoord1i(target, s);
}
void QOpenGLFunctions_2_0_GlMultiTexCoord1iv3(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiTexCoord1iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_0_GlMultiTexCoord1s3(void* ptr, unsigned int target, short s)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiTexCoord1s(target, s);
}
void QOpenGLFunctions_2_0_GlMultiTexCoord1sv3(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiTexCoord1sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_GlMultiTexCoord2f3(void* ptr, unsigned int target, float s, float t)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiTexCoord2f(target, s, t);
}
void QOpenGLFunctions_2_0_GlMultiTexCoord2fv3(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiTexCoord2fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_0_GlMultiTexCoord2i3(void* ptr, unsigned int target, int s, int t)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiTexCoord2i(target, s, t);
}
void QOpenGLFunctions_2_0_GlMultiTexCoord2iv3(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiTexCoord2iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_0_GlMultiTexCoord2s3(void* ptr, unsigned int target, short s, short t)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiTexCoord2s(target, s, t);
}
void QOpenGLFunctions_2_0_GlMultiTexCoord2sv3(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiTexCoord2sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_GlMultiTexCoord3f3(void* ptr, unsigned int target, float s, float t, float r)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiTexCoord3f(target, s, t, r);
}
void QOpenGLFunctions_2_0_GlMultiTexCoord3fv3(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiTexCoord3fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_0_GlMultiTexCoord3i3(void* ptr, unsigned int target, int s, int t, int r)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiTexCoord3i(target, s, t, r);
}
void QOpenGLFunctions_2_0_GlMultiTexCoord3iv3(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiTexCoord3iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_0_GlMultiTexCoord3s3(void* ptr, unsigned int target, short s, short t, short r)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiTexCoord3s(target, s, t, r);
}
void QOpenGLFunctions_2_0_GlMultiTexCoord3sv3(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiTexCoord3sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_GlMultiTexCoord4f3(void* ptr, unsigned int target, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiTexCoord4f(target, s, t, r, q);
}
void QOpenGLFunctions_2_0_GlMultiTexCoord4fv3(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiTexCoord4fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_0_GlMultiTexCoord4i3(void* ptr, unsigned int target, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiTexCoord4i(target, s, t, r, q);
}
void QOpenGLFunctions_2_0_GlMultiTexCoord4iv3(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiTexCoord4iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_0_GlMultiTexCoord4s3(void* ptr, unsigned int target, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiTexCoord4s(target, s, t, r, q);
}
void QOpenGLFunctions_2_0_GlMultiTexCoord4sv3(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glMultiTexCoord4sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_GlNewList3(void* ptr, unsigned int list, unsigned int mode)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glNewList(list, mode);
}
void QOpenGLFunctions_2_0_GlNormal3f3(void* ptr, float nx, float ny, float nz)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glNormal3f(nx, ny, nz);
}
void QOpenGLFunctions_2_0_GlNormal3fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glNormal3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_0_GlNormal3i3(void* ptr, int nx, int ny, int nz)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glNormal3i(nx, ny, nz);
}
void QOpenGLFunctions_2_0_GlNormal3iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glNormal3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_0_GlNormal3s3(void* ptr, short nx, short ny, short nz)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glNormal3s(nx, ny, nz);
}
void QOpenGLFunctions_2_0_GlNormal3sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glNormal3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_GlNormalPointer3(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glNormalPointer(ty, stride, pointer);
}
void QOpenGLFunctions_2_0_GlPassThrough3(void* ptr, float token)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPassThrough(token);
}
void QOpenGLFunctions_2_0_GlPixelMapfv3(void* ptr, unsigned int m, int mapsize, float values)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPixelMapfv(m, mapsize, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_2_0_GlPixelMapuiv3(void* ptr, unsigned int m, int mapsize, unsigned int values)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPixelMapuiv(m, mapsize, const_cast<const GLuint*>(&values));
}
void QOpenGLFunctions_2_0_GlPixelMapusv3(void* ptr, unsigned int m, int mapsize, unsigned short values)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPixelMapusv(m, mapsize, const_cast<const GLushort*>(&values));
}
void QOpenGLFunctions_2_0_GlPixelStoref3(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_2_0_GlPixelStorei3(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_2_0_GlPixelTransferf3(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPixelTransferf(pname, param);
}
void QOpenGLFunctions_2_0_GlPixelTransferi3(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPixelTransferi(pname, param);
}
void QOpenGLFunctions_2_0_GlPixelZoom3(void* ptr, float xfactor, float yfactor)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPixelZoom(xfactor, yfactor);
}
void QOpenGLFunctions_2_0_GlPointParameterf3(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPointParameterf(pname, param);
}
void QOpenGLFunctions_2_0_GlPointParameterfv3(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPointParameterfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_2_0_GlPointParameteri3(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPointParameteri(pname, param);
}
void QOpenGLFunctions_2_0_GlPointParameteriv3(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPointParameteriv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_2_0_GlPointSize3(void* ptr, float size)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_2_0_GlPolygonMode3(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_2_0_GlPolygonOffset3(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_2_0_GlPolygonStipple3(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPolygonStipple(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(mask))));
}
void QOpenGLFunctions_2_0_GlPopAttrib3(void* ptr)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPopAttrib();
}
void QOpenGLFunctions_2_0_GlPopClientAttrib3(void* ptr)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPopClientAttrib();
}
void QOpenGLFunctions_2_0_GlPopMatrix3(void* ptr)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPopMatrix();
}
void QOpenGLFunctions_2_0_GlPopName3(void* ptr)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPopName();
}
void QOpenGLFunctions_2_0_GlPrioritizeTextures3(void* ptr, int n, unsigned int textures, float priorities)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPrioritizeTextures(n, const_cast<const GLuint*>(&textures), const_cast<const GLfloat*>(&priorities));
}
void QOpenGLFunctions_2_0_GlPushAttrib3(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPushAttrib(mask);
}
void QOpenGLFunctions_2_0_GlPushClientAttrib3(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPushClientAttrib(mask);
}
void QOpenGLFunctions_2_0_GlPushMatrix3(void* ptr)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPushMatrix();
}
void QOpenGLFunctions_2_0_GlPushName3(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glPushName(name);
}
void QOpenGLFunctions_2_0_GlRasterPos2f3(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRasterPos2f(x, y);
}
void QOpenGLFunctions_2_0_GlRasterPos2fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRasterPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_0_GlRasterPos2i3(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRasterPos2i(x, y);
}
void QOpenGLFunctions_2_0_GlRasterPos2iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRasterPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_0_GlRasterPos2s3(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRasterPos2s(x, y);
}
void QOpenGLFunctions_2_0_GlRasterPos2sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRasterPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_GlRasterPos3f3(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRasterPos3f(x, y, z);
}
void QOpenGLFunctions_2_0_GlRasterPos3fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRasterPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_0_GlRasterPos3i3(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRasterPos3i(x, y, z);
}
void QOpenGLFunctions_2_0_GlRasterPos3iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRasterPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_0_GlRasterPos3s3(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRasterPos3s(x, y, z);
}
void QOpenGLFunctions_2_0_GlRasterPos3sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRasterPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_GlRasterPos4f3(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRasterPos4f(x, y, z, w);
}
void QOpenGLFunctions_2_0_GlRasterPos4fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRasterPos4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_0_GlRasterPos4i3(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRasterPos4i(x, y, z, w);
}
void QOpenGLFunctions_2_0_GlRasterPos4iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRasterPos4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_0_GlRasterPos4s3(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRasterPos4s(x, y, z, w);
}
void QOpenGLFunctions_2_0_GlRasterPos4sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRasterPos4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_GlReadBuffer3(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glReadBuffer(mode);
}
void QOpenGLFunctions_2_0_GlReadPixels3(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_2_0_GlRectf3(void* ptr, float x1, float y1, float x2, float y2)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRectf(x1, y1, x2, y2);
}
void QOpenGLFunctions_2_0_GlRectfv3(void* ptr, float v1, float v2)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRectfv(const_cast<const GLfloat*>(&v1), const_cast<const GLfloat*>(&v2));
}
void QOpenGLFunctions_2_0_GlRecti3(void* ptr, int x1, int y1, int x2, int y2)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRecti(x1, y1, x2, y2);
}
void QOpenGLFunctions_2_0_GlRectiv3(void* ptr, int v1, int v2)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRectiv(const_cast<const GLint*>(&v1), const_cast<const GLint*>(&v2));
}
void QOpenGLFunctions_2_0_GlRects3(void* ptr, short x1, short y1, short x2, short y2)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRects(x1, y1, x2, y2);
}
void QOpenGLFunctions_2_0_GlRectsv3(void* ptr, short v1, short v2)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRectsv(const_cast<const GLshort*>(&v1), const_cast<const GLshort*>(&v2));
}
void QOpenGLFunctions_2_0_GlResetHistogram3(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glResetHistogram(target);
}
void QOpenGLFunctions_2_0_GlResetMinmax3(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glResetMinmax(target);
}
void QOpenGLFunctions_2_0_GlRotatef3(void* ptr, float angle, float x, float y, float z)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glRotatef(angle, x, y, z);
}
void QOpenGLFunctions_2_0_GlSampleCoverage3(void* ptr, float value, char invert)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glSampleCoverage(value, invert != 0);
}
void QOpenGLFunctions_2_0_GlScalef3(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glScalef(x, y, z);
}
void QOpenGLFunctions_2_0_GlScissor3(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_2_0_GlSecondaryColor3f3(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glSecondaryColor3f(red, green, blue);
}
void QOpenGLFunctions_2_0_GlSecondaryColor3fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glSecondaryColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_0_GlSecondaryColor3i3(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glSecondaryColor3i(red, green, blue);
}
void QOpenGLFunctions_2_0_GlSecondaryColor3iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glSecondaryColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_0_GlSecondaryColor3s3(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glSecondaryColor3s(red, green, blue);
}
void QOpenGLFunctions_2_0_GlSecondaryColor3sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glSecondaryColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_GlSecondaryColor3ub3(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glSecondaryColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_2_0_GlSecondaryColor3ubv3(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glSecondaryColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_2_0_GlSecondaryColor3ui3(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glSecondaryColor3ui(red, green, blue);
}
void QOpenGLFunctions_2_0_GlSecondaryColor3uiv3(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glSecondaryColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_2_0_GlSecondaryColor3us3(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glSecondaryColor3us(red, green, blue);
}
void QOpenGLFunctions_2_0_GlSecondaryColor3usv3(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glSecondaryColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_2_0_GlSecondaryColorPointer3(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glSecondaryColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_2_0_GlSelectBuffer3(void* ptr, int size, unsigned int buffer)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glSelectBuffer(size, &buffer);
}
void QOpenGLFunctions_2_0_GlSeparableFilter2D3(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* row, void* column)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glSeparableFilter2D(target, internalformat, width, height, format, ty, row, column);
}
void QOpenGLFunctions_2_0_GlShadeModel3(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glShadeModel(mode);
}
void QOpenGLFunctions_2_0_GlStencilFunc3(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_2_0_GlStencilFuncSeparate3(void* ptr, unsigned int face, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glStencilFuncSeparate(face, fu, ref, mask);
}
void QOpenGLFunctions_2_0_GlStencilMask3(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_2_0_GlStencilMaskSeparate3(void* ptr, unsigned int face, unsigned int mask)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glStencilMaskSeparate(face, mask);
}
void QOpenGLFunctions_2_0_GlStencilOp3(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_2_0_GlStencilOpSeparate3(void* ptr, unsigned int face, unsigned int sfail, unsigned int dpfail, unsigned int dppass)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glStencilOpSeparate(face, sfail, dpfail, dppass);
}
void QOpenGLFunctions_2_0_GlTexCoord1f3(void* ptr, float s)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoord1f(s);
}
void QOpenGLFunctions_2_0_GlTexCoord1fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoord1fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_0_GlTexCoord1i3(void* ptr, int s)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoord1i(s);
}
void QOpenGLFunctions_2_0_GlTexCoord1iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoord1iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_0_GlTexCoord1s3(void* ptr, short s)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoord1s(s);
}
void QOpenGLFunctions_2_0_GlTexCoord1sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoord1sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_GlTexCoord2f3(void* ptr, float s, float t)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoord2f(s, t);
}
void QOpenGLFunctions_2_0_GlTexCoord2fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoord2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_0_GlTexCoord2i3(void* ptr, int s, int t)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoord2i(s, t);
}
void QOpenGLFunctions_2_0_GlTexCoord2iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoord2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_0_GlTexCoord2s3(void* ptr, short s, short t)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoord2s(s, t);
}
void QOpenGLFunctions_2_0_GlTexCoord2sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoord2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_GlTexCoord3f3(void* ptr, float s, float t, float r)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoord3f(s, t, r);
}
void QOpenGLFunctions_2_0_GlTexCoord3fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoord3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_0_GlTexCoord3i3(void* ptr, int s, int t, int r)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoord3i(s, t, r);
}
void QOpenGLFunctions_2_0_GlTexCoord3iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoord3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_0_GlTexCoord3s3(void* ptr, short s, short t, short r)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoord3s(s, t, r);
}
void QOpenGLFunctions_2_0_GlTexCoord3sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoord3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_GlTexCoord4f3(void* ptr, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoord4f(s, t, r, q);
}
void QOpenGLFunctions_2_0_GlTexCoord4fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoord4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_0_GlTexCoord4i3(void* ptr, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoord4i(s, t, r, q);
}
void QOpenGLFunctions_2_0_GlTexCoord4iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoord4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_0_GlTexCoord4s3(void* ptr, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoord4s(s, t, r, q);
}
void QOpenGLFunctions_2_0_GlTexCoord4sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoord4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_GlTexCoordPointer3(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexCoordPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_2_0_GlTexEnvf3(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexEnvf(target, pname, param);
}
void QOpenGLFunctions_2_0_GlTexEnvfv3(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexEnvfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_2_0_GlTexEnvi3(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexEnvi(target, pname, param);
}
void QOpenGLFunctions_2_0_GlTexEnviv3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexEnviv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_2_0_GlTexGenf3(void* ptr, unsigned int coord, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexGenf(coord, pname, param);
}
void QOpenGLFunctions_2_0_GlTexGenfv3(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexGenfv(coord, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_2_0_GlTexGeni3(void* ptr, unsigned int coord, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexGeni(coord, pname, param);
}
void QOpenGLFunctions_2_0_GlTexGeniv3(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexGeniv(coord, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_2_0_GlTexImage1D3(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_2_0_GlTexImage2D3(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_2_0_GlTexImage3D3(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLFunctions_2_0_GlTexParameterf3(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_2_0_GlTexParameterfv3(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_2_0_GlTexParameteri3(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_2_0_GlTexParameteriv3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_2_0_GlTexSubImage1D3(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_2_0_GlTexSubImage2D3(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_2_0_GlTexSubImage3D3(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_2_0_GlTranslatef3(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glTranslatef(x, y, z);
}
void QOpenGLFunctions_2_0_GlUniform1f3(void* ptr, int location, float v0)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glUniform1f(location, v0);
}
void QOpenGLFunctions_2_0_GlUniform1fv3(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glUniform1fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_2_0_GlUniform1i3(void* ptr, int location, int v0)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glUniform1i(location, v0);
}
void QOpenGLFunctions_2_0_GlUniform1iv3(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glUniform1iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_2_0_GlUniform2f3(void* ptr, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glUniform2f(location, v0, v1);
}
void QOpenGLFunctions_2_0_GlUniform2fv3(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glUniform2fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_2_0_GlUniform2i3(void* ptr, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glUniform2i(location, v0, v1);
}
void QOpenGLFunctions_2_0_GlUniform2iv3(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glUniform2iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_2_0_GlUniform3f3(void* ptr, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glUniform3f(location, v0, v1, v2);
}
void QOpenGLFunctions_2_0_GlUniform3fv3(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glUniform3fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_2_0_GlUniform3i3(void* ptr, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glUniform3i(location, v0, v1, v2);
}
void QOpenGLFunctions_2_0_GlUniform3iv3(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glUniform3iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_2_0_GlUniform4f3(void* ptr, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glUniform4f(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_2_0_GlUniform4fv3(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glUniform4fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_2_0_GlUniform4i3(void* ptr, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glUniform4i(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_2_0_GlUniform4iv3(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glUniform4iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_2_0_GlUniformMatrix2fv3(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glUniformMatrix2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_2_0_GlUniformMatrix3fv3(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glUniformMatrix3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_2_0_GlUniformMatrix4fv3(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glUniformMatrix4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_2_0_GlUseProgram3(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glUseProgram(program);
}
void QOpenGLFunctions_2_0_GlValidateProgram3(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glValidateProgram(program);
}
void QOpenGLFunctions_2_0_GlVertex2f3(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertex2f(x, y);
}
void QOpenGLFunctions_2_0_GlVertex2fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertex2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_0_GlVertex2i3(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertex2i(x, y);
}
void QOpenGLFunctions_2_0_GlVertex2iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertex2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_0_GlVertex2s3(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertex2s(x, y);
}
void QOpenGLFunctions_2_0_GlVertex2sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertex2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_GlVertex3f3(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertex3f(x, y, z);
}
void QOpenGLFunctions_2_0_GlVertex3fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertex3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_0_GlVertex3i3(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertex3i(x, y, z);
}
void QOpenGLFunctions_2_0_GlVertex3iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertex3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_0_GlVertex3s3(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertex3s(x, y, z);
}
void QOpenGLFunctions_2_0_GlVertex3sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertex3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_GlVertex4f3(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertex4f(x, y, z, w);
}
void QOpenGLFunctions_2_0_GlVertex4fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertex4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_0_GlVertex4i3(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertex4i(x, y, z, w);
}
void QOpenGLFunctions_2_0_GlVertex4iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertex4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_0_GlVertex4s3(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertex4s(x, y, z, w);
}
void QOpenGLFunctions_2_0_GlVertex4sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertex4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_GlVertexAttrib1f3(void* ptr, unsigned int index, float x)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib1f(index, x);
}
void QOpenGLFunctions_2_0_GlVertexAttrib1fv3(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib1fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_0_GlVertexAttrib1s3(void* ptr, unsigned int index, short x)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib1s(index, x);
}
void QOpenGLFunctions_2_0_GlVertexAttrib1sv3(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib1sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_GlVertexAttrib2f3(void* ptr, unsigned int index, float x, float y)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib2f(index, x, y);
}
void QOpenGLFunctions_2_0_GlVertexAttrib2fv3(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib2fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_0_GlVertexAttrib2s3(void* ptr, unsigned int index, short x, short y)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib2s(index, x, y);
}
void QOpenGLFunctions_2_0_GlVertexAttrib2sv3(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib2sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_GlVertexAttrib3f3(void* ptr, unsigned int index, float x, float y, float z)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib3f(index, x, y, z);
}
void QOpenGLFunctions_2_0_GlVertexAttrib3fv3(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib3fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_0_GlVertexAttrib3s3(void* ptr, unsigned int index, short x, short y, short z)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib3s(index, x, y, z);
}
void QOpenGLFunctions_2_0_GlVertexAttrib3sv3(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib3sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_GlVertexAttrib4Niv3(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib4Niv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_0_GlVertexAttrib4Nsv3(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib4Nsv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_GlVertexAttrib4Nub3(void* ptr, unsigned int index, char* x, char* y, char* z, char* w)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib4Nub(index, *static_cast<GLubyte*>(static_cast<void*>(x)), *static_cast<GLubyte*>(static_cast<void*>(y)), *static_cast<GLubyte*>(static_cast<void*>(z)), *static_cast<GLubyte*>(static_cast<void*>(w)));
}
void QOpenGLFunctions_2_0_GlVertexAttrib4Nubv3(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib4Nubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_2_0_GlVertexAttrib4Nuiv3(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib4Nuiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_2_0_GlVertexAttrib4Nusv3(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib4Nusv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_2_0_GlVertexAttrib4f3(void* ptr, unsigned int index, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib4f(index, x, y, z, w);
}
void QOpenGLFunctions_2_0_GlVertexAttrib4fv3(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib4fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_0_GlVertexAttrib4iv3(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_0_GlVertexAttrib4s3(void* ptr, unsigned int index, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib4s(index, x, y, z, w);
}
void QOpenGLFunctions_2_0_GlVertexAttrib4sv3(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib4sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_GlVertexAttrib4ubv3(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib4ubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_2_0_GlVertexAttrib4uiv3(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_2_0_GlVertexAttrib4usv3(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttrib4usv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_2_0_GlVertexAttribPointer3(void* ptr, unsigned int index, int size, unsigned int ty, char normalized, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexAttribPointer(index, size, ty, normalized != 0, stride, pointer);
}
void QOpenGLFunctions_2_0_GlVertexPointer3(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glVertexPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_2_0_GlViewport3(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_2_0_GlWindowPos2f3(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glWindowPos2f(x, y);
}
void QOpenGLFunctions_2_0_GlWindowPos2fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glWindowPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_0_GlWindowPos2i3(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glWindowPos2i(x, y);
}
void QOpenGLFunctions_2_0_GlWindowPos2iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glWindowPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_0_GlWindowPos2s3(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glWindowPos2s(x, y);
}
void QOpenGLFunctions_2_0_GlWindowPos2sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glWindowPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_GlWindowPos3f3(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glWindowPos3f(x, y, z);
}
void QOpenGLFunctions_2_0_GlWindowPos3fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glWindowPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_0_GlWindowPos3i3(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glWindowPos3i(x, y, z);
}
void QOpenGLFunctions_2_0_GlWindowPos3iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glWindowPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_0_GlWindowPos3s3(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glWindowPos3s(x, y, z);
}
void QOpenGLFunctions_2_0_GlWindowPos3sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->glWindowPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_0_DestroyQOpenGLFunctions_2_03(void* ptr)
{
static_cast<QOpenGLFunctions_2_0*>(ptr)->~QOpenGLFunctions_2_0();
}
void QOpenGLFunctions_2_0_DestroyQOpenGLFunctions_2_03Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_2_1: public QOpenGLFunctions_2_1
{
public:
MyQOpenGLFunctions_2_1() : QOpenGLFunctions_2_1() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_2_1_InitializeOpenGLFunctions3(this) != 0; };
~MyQOpenGLFunctions_2_1() { callbackQOpenGLFunctions_2_1_DestroyQOpenGLFunctions_2_13(this); };
};
char QOpenGLFunctions_2_1_GlAreTexturesResident3(void* ptr, int n, unsigned int textures, char residences)
{
Q_UNUSED(residences);
return static_cast<QOpenGLFunctions_2_1*>(ptr)->glAreTexturesResident(n, const_cast<const GLuint*>(&textures), NULL);
}
char QOpenGLFunctions_2_1_GlIsBuffer3(void* ptr, unsigned int buffer)
{
return static_cast<QOpenGLFunctions_2_1*>(ptr)->glIsBuffer(buffer);
}
char QOpenGLFunctions_2_1_GlIsEnabled3(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_2_1*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_2_1_GlIsList3(void* ptr, unsigned int list)
{
return static_cast<QOpenGLFunctions_2_1*>(ptr)->glIsList(list);
}
char QOpenGLFunctions_2_1_GlIsProgram3(void* ptr, unsigned int program)
{
return static_cast<QOpenGLFunctions_2_1*>(ptr)->glIsProgram(program);
}
char QOpenGLFunctions_2_1_GlIsQuery3(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_2_1*>(ptr)->glIsQuery(id);
}
char QOpenGLFunctions_2_1_GlIsShader3(void* ptr, unsigned int shader)
{
return static_cast<QOpenGLFunctions_2_1*>(ptr)->glIsShader(shader);
}
char QOpenGLFunctions_2_1_GlIsTexture3(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_2_1*>(ptr)->glIsTexture(texture);
}
char QOpenGLFunctions_2_1_GlUnmapBuffer3(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_2_1*>(ptr)->glUnmapBuffer(target);
}
unsigned int QOpenGLFunctions_2_1_GlGetError3(void* ptr)
{
return static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetError();
}
int QOpenGLFunctions_2_1_GlRenderMode3(void* ptr, unsigned int mode)
{
return static_cast<QOpenGLFunctions_2_1*>(ptr)->glRenderMode(mode);
}
unsigned int QOpenGLFunctions_2_1_GlCreateProgram3(void* ptr)
{
return static_cast<QOpenGLFunctions_2_1*>(ptr)->glCreateProgram();
}
unsigned int QOpenGLFunctions_2_1_GlCreateShader3(void* ptr, unsigned int ty)
{
return static_cast<QOpenGLFunctions_2_1*>(ptr)->glCreateShader(ty);
}
unsigned int QOpenGLFunctions_2_1_GlGenLists3(void* ptr, int ran)
{
return static_cast<QOpenGLFunctions_2_1*>(ptr)->glGenLists(ran);
}
void* QOpenGLFunctions_2_1_GlMapBuffer3(void* ptr, unsigned int target, unsigned int access)
{
return static_cast<QOpenGLFunctions_2_1*>(ptr)->glMapBuffer(target, access);
}
void* QOpenGLFunctions_2_1_NewQOpenGLFunctions_2_13()
{
return new MyQOpenGLFunctions_2_1();
}
char QOpenGLFunctions_2_1_InitializeOpenGLFunctions3(void* ptr)
{
return static_cast<QOpenGLFunctions_2_1*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_2_1_InitializeOpenGLFunctions3Default(void* ptr)
{
return static_cast<QOpenGLFunctions_2_1*>(ptr)->QOpenGLFunctions_2_1::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_2_1_GlGetString3(void* ptr, unsigned int name)
{
return ({ char* tf76313 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetString(name)))); QtGui_PackedString { tf76313, -1 }; });
}
void QOpenGLFunctions_2_1_GlAccum3(void* ptr, unsigned int op, float value)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glAccum(op, value);
}
void QOpenGLFunctions_2_1_GlActiveTexture3(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glActiveTexture(texture);
}
void QOpenGLFunctions_2_1_GlAlphaFunc3(void* ptr, unsigned int fu, float ref)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glAlphaFunc(fu, ref);
}
void QOpenGLFunctions_2_1_GlArrayElement3(void* ptr, int i)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glArrayElement(i);
}
void QOpenGLFunctions_2_1_GlAttachShader3(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glAttachShader(program, shader);
}
void QOpenGLFunctions_2_1_GlBegin3(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glBegin(mode);
}
void QOpenGLFunctions_2_1_GlBeginQuery3(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glBeginQuery(target, id);
}
void QOpenGLFunctions_2_1_GlBindBuffer3(void* ptr, unsigned int target, unsigned int buffer)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glBindBuffer(target, buffer);
}
void QOpenGLFunctions_2_1_GlBindTexture3(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_2_1_GlBitmap3(void* ptr, int width, int height, float xorig, float yorig, float xmove, float ymove, char* bitmap)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glBitmap(width, height, xorig, yorig, xmove, ymove, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(bitmap))));
}
void QOpenGLFunctions_2_1_GlBlendColor3(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_2_1_GlBlendEquation3(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_2_1_GlBlendEquationSeparate3(void* ptr, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glBlendEquationSeparate(modeRGB, modeAlpha);
}
void QOpenGLFunctions_2_1_GlBlendFunc3(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_2_1_GlBlendFuncSeparate3(void* ptr, unsigned int sfactorRGB, unsigned int dfactorRGB, unsigned int sfactorAlpha, unsigned int dfactorAlpha)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void QOpenGLFunctions_2_1_GlCallList3(void* ptr, unsigned int list)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glCallList(list);
}
void QOpenGLFunctions_2_1_GlCallLists3(void* ptr, int n, unsigned int ty, void* lists)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glCallLists(n, ty, lists);
}
void QOpenGLFunctions_2_1_GlClear3(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_2_1_GlClearAccum3(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glClearAccum(red, green, blue, alpha);
}
void QOpenGLFunctions_2_1_GlClearColor3(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_2_1_GlClearIndex3(void* ptr, float c)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glClearIndex(c);
}
void QOpenGLFunctions_2_1_GlClearStencil3(void* ptr, int s)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_2_1_GlClientActiveTexture3(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glClientActiveTexture(texture);
}
void QOpenGLFunctions_2_1_GlColor3f3(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColor3f(red, green, blue);
}
void QOpenGLFunctions_2_1_GlColor3fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_1_GlColor3i3(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColor3i(red, green, blue);
}
void QOpenGLFunctions_2_1_GlColor3iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_1_GlColor3s3(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColor3s(red, green, blue);
}
void QOpenGLFunctions_2_1_GlColor3sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_GlColor3ub3(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_2_1_GlColor3ubv3(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_2_1_GlColor3ui3(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColor3ui(red, green, blue);
}
void QOpenGLFunctions_2_1_GlColor3uiv3(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_2_1_GlColor3us3(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColor3us(red, green, blue);
}
void QOpenGLFunctions_2_1_GlColor3usv3(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_2_1_GlColor4f3(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColor4f(red, green, blue, alpha);
}
void QOpenGLFunctions_2_1_GlColor4fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColor4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_1_GlColor4i3(void* ptr, int red, int green, int blue, int alpha)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColor4i(red, green, blue, alpha);
}
void QOpenGLFunctions_2_1_GlColor4iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColor4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_1_GlColor4s3(void* ptr, short red, short green, short blue, short alpha)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColor4s(red, green, blue, alpha);
}
void QOpenGLFunctions_2_1_GlColor4sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColor4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_GlColor4ub3(void* ptr, char* red, char* green, char* blue, char* alpha)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColor4ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)), *static_cast<GLubyte*>(static_cast<void*>(alpha)));
}
void QOpenGLFunctions_2_1_GlColor4ubv3(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColor4ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_2_1_GlColor4ui3(void* ptr, unsigned int red, unsigned int green, unsigned int blue, unsigned int alpha)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColor4ui(red, green, blue, alpha);
}
void QOpenGLFunctions_2_1_GlColor4uiv3(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColor4uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_2_1_GlColor4us3(void* ptr, unsigned short red, unsigned short green, unsigned short blue, unsigned short alpha)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColor4us(red, green, blue, alpha);
}
void QOpenGLFunctions_2_1_GlColor4usv3(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColor4usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_2_1_GlColorMask3(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_2_1_GlColorMaterial3(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColorMaterial(face, mode);
}
void QOpenGLFunctions_2_1_GlColorPointer3(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_2_1_GlColorSubTable3(void* ptr, unsigned int target, int start, int count, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColorSubTable(target, start, count, format, ty, data);
}
void QOpenGLFunctions_2_1_GlColorTable3(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColorTable(target, internalformat, width, format, ty, table);
}
void QOpenGLFunctions_2_1_GlColorTableParameterfv3(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColorTableParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_2_1_GlColorTableParameteriv3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glColorTableParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_2_1_GlCompileShader3(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glCompileShader(shader);
}
void QOpenGLFunctions_2_1_GlCompressedTexImage1D3(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
void QOpenGLFunctions_2_1_GlCompressedTexImage2D3(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void QOpenGLFunctions_2_1_GlCompressedTexImage3D3(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int depth, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void QOpenGLFunctions_2_1_GlCompressedTexSubImage1D3(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_2_1_GlCompressedTexSubImage2D3(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_2_1_GlCompressedTexSubImage3D3(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_2_1_GlConvolutionFilter1D3(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glConvolutionFilter1D(target, internalformat, width, format, ty, image);
}
void QOpenGLFunctions_2_1_GlConvolutionFilter2D3(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glConvolutionFilter2D(target, internalformat, width, height, format, ty, image);
}
void QOpenGLFunctions_2_1_GlConvolutionParameterf3(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glConvolutionParameterf(target, pname, params);
}
void QOpenGLFunctions_2_1_GlConvolutionParameterfv3(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glConvolutionParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_2_1_GlConvolutionParameteri3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glConvolutionParameteri(target, pname, params);
}
void QOpenGLFunctions_2_1_GlConvolutionParameteriv3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glConvolutionParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_2_1_GlCopyColorSubTable3(void* ptr, unsigned int target, int start, int x, int y, int width)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glCopyColorSubTable(target, start, x, y, width);
}
void QOpenGLFunctions_2_1_GlCopyColorTable3(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glCopyColorTable(target, internalformat, x, y, width);
}
void QOpenGLFunctions_2_1_GlCopyConvolutionFilter1D3(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glCopyConvolutionFilter1D(target, internalformat, x, y, width);
}
void QOpenGLFunctions_2_1_GlCopyConvolutionFilter2D3(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);
}
void QOpenGLFunctions_2_1_GlCopyPixels3(void* ptr, int x, int y, int width, int height, unsigned int ty)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glCopyPixels(x, y, width, height, ty);
}
void QOpenGLFunctions_2_1_GlCopyTexImage1D3(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_2_1_GlCopyTexImage2D3(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_2_1_GlCopyTexSubImage1D3(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_2_1_GlCopyTexSubImage2D3(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_2_1_GlCopyTexSubImage3D3(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_2_1_GlCullFace3(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_2_1_GlDeleteBuffers3(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glDeleteBuffers(n, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_2_1_GlDeleteLists3(void* ptr, unsigned int list, int ran)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glDeleteLists(list, ran);
}
void QOpenGLFunctions_2_1_GlDeleteProgram3(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glDeleteProgram(program);
}
void QOpenGLFunctions_2_1_GlDeleteQueries3(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glDeleteQueries(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_2_1_GlDeleteShader3(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glDeleteShader(shader);
}
void QOpenGLFunctions_2_1_GlDeleteTextures3(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_2_1_GlDepthFunc3(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_2_1_GlDepthMask3(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_2_1_GlDetachShader3(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glDetachShader(program, shader);
}
void QOpenGLFunctions_2_1_GlDisable3(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_2_1_GlDisableClientState3(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glDisableClientState(array);
}
void QOpenGLFunctions_2_1_GlDisableVertexAttribArray3(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glDisableVertexAttribArray(index);
}
void QOpenGLFunctions_2_1_GlDrawArrays3(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_2_1_GlDrawBuffer3(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glDrawBuffer(mode);
}
void QOpenGLFunctions_2_1_GlDrawBuffers3(void* ptr, int n, unsigned int bufs)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glDrawBuffers(n, const_cast<const GLenum*>(&bufs));
}
void QOpenGLFunctions_2_1_GlDrawElements3(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_2_1_GlDrawPixels3(void* ptr, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glDrawPixels(width, height, format, ty, pixels);
}
void QOpenGLFunctions_2_1_GlDrawRangeElements3(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLFunctions_2_1_GlEdgeFlag3(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glEdgeFlag(flag != 0);
}
void QOpenGLFunctions_2_1_GlEdgeFlagPointer3(void* ptr, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glEdgeFlagPointer(stride, pointer);
}
void QOpenGLFunctions_2_1_GlEdgeFlagv3(void* ptr, char flag)
{
Q_UNUSED(flag);
static_cast<QOpenGLFunctions_2_1*>(ptr)->glEdgeFlagv(NULL);
}
void QOpenGLFunctions_2_1_GlEnable3(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_2_1_GlEnableClientState3(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glEnableClientState(array);
}
void QOpenGLFunctions_2_1_GlEnableVertexAttribArray3(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glEnableVertexAttribArray(index);
}
void QOpenGLFunctions_2_1_GlEnd3(void* ptr)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glEnd();
}
void QOpenGLFunctions_2_1_GlEndList3(void* ptr)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glEndList();
}
void QOpenGLFunctions_2_1_GlEndQuery3(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glEndQuery(target);
}
void QOpenGLFunctions_2_1_GlEvalCoord1f3(void* ptr, float u)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glEvalCoord1f(u);
}
void QOpenGLFunctions_2_1_GlEvalCoord1fv3(void* ptr, float u)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glEvalCoord1fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_2_1_GlEvalCoord2f3(void* ptr, float u, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glEvalCoord2f(u, v);
}
void QOpenGLFunctions_2_1_GlEvalCoord2fv3(void* ptr, float u)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glEvalCoord2fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_2_1_GlEvalMesh13(void* ptr, unsigned int mode, int i1, int i2)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glEvalMesh1(mode, i1, i2);
}
void QOpenGLFunctions_2_1_GlEvalMesh23(void* ptr, unsigned int mode, int i1, int i2, int j1, int j2)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glEvalMesh2(mode, i1, i2, j1, j2);
}
void QOpenGLFunctions_2_1_GlEvalPoint13(void* ptr, int i)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glEvalPoint1(i);
}
void QOpenGLFunctions_2_1_GlEvalPoint23(void* ptr, int i, int j)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glEvalPoint2(i, j);
}
void QOpenGLFunctions_2_1_GlFeedbackBuffer3(void* ptr, int size, unsigned int ty, float buffer)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glFeedbackBuffer(size, ty, &buffer);
}
void QOpenGLFunctions_2_1_GlFinish3(void* ptr)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glFinish();
}
void QOpenGLFunctions_2_1_GlFlush3(void* ptr)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glFlush();
}
void QOpenGLFunctions_2_1_GlFogCoordPointer3(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glFogCoordPointer(ty, stride, pointer);
}
void QOpenGLFunctions_2_1_GlFogCoordf3(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glFogCoordf(coord);
}
void QOpenGLFunctions_2_1_GlFogCoordfv3(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glFogCoordfv(const_cast<const GLfloat*>(&coord));
}
void QOpenGLFunctions_2_1_GlFogf3(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glFogf(pname, param);
}
void QOpenGLFunctions_2_1_GlFogfv3(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glFogfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_2_1_GlFogi3(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glFogi(pname, param);
}
void QOpenGLFunctions_2_1_GlFogiv3(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glFogiv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_2_1_GlFrontFace3(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_2_1_GlGenBuffers3(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGenBuffers(n, &buffers);
}
void QOpenGLFunctions_2_1_GlGenQueries3(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGenQueries(n, &ids);
}
void QOpenGLFunctions_2_1_GlGenTextures3(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_2_1_GlGetAttachedShaders3(void* ptr, unsigned int program, int maxCount, int count, unsigned int obj)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetAttachedShaders(program, maxCount, &count, &obj);
}
void QOpenGLFunctions_2_1_GlGetBooleanv3(void* ptr, unsigned int pname, char params)
{
Q_UNUSED(params);
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_2_1_GlGetBufferParameteriv3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetBufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetBufferPointerv3(void* ptr, unsigned int target, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetBufferPointerv(target, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetColorTable3(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetColorTable(target, format, ty, table);
}
void QOpenGLFunctions_2_1_GlGetColorTableParameterfv3(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetColorTableParameterfv(target, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetColorTableParameteriv3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetColorTableParameteriv(target, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetCompressedTexImage3(void* ptr, unsigned int target, int level, void* img)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetCompressedTexImage(target, level, img);
}
void QOpenGLFunctions_2_1_GlGetConvolutionFilter3(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetConvolutionFilter(target, format, ty, image);
}
void QOpenGLFunctions_2_1_GlGetConvolutionParameterfv3(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetConvolutionParameterfv(target, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetConvolutionParameteriv3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetConvolutionParameteriv(target, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetFloatv3(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetFloatv(pname, &params);
}
void QOpenGLFunctions_2_1_GlGetHistogram3(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetHistogram(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_2_1_GlGetHistogramParameterfv3(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetHistogramParameterfv(target, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetHistogramParameteriv3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetHistogramParameteriv(target, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetIntegerv3(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetIntegerv(pname, &params);
}
void QOpenGLFunctions_2_1_GlGetLightfv3(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetLightfv(light, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetLightiv3(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetLightiv(light, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetMapfv3(void* ptr, unsigned int target, unsigned int query, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetMapfv(target, query, &v);
}
void QOpenGLFunctions_2_1_GlGetMapiv3(void* ptr, unsigned int target, unsigned int query, int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetMapiv(target, query, &v);
}
void QOpenGLFunctions_2_1_GlGetMaterialfv3(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetMaterialfv(face, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetMaterialiv3(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetMaterialiv(face, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetMinmax3(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetMinmax(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_2_1_GlGetMinmaxParameterfv3(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetMinmaxParameterfv(target, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetMinmaxParameteriv3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetMinmaxParameteriv(target, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetPixelMapfv3(void* ptr, unsigned int m, float values)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetPixelMapfv(m, &values);
}
void QOpenGLFunctions_2_1_GlGetPixelMapuiv3(void* ptr, unsigned int m, unsigned int values)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetPixelMapuiv(m, &values);
}
void QOpenGLFunctions_2_1_GlGetPixelMapusv3(void* ptr, unsigned int m, unsigned short values)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetPixelMapusv(m, &values);
}
void QOpenGLFunctions_2_1_GlGetPointerv3(void* ptr, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetPointerv(pname, &params);
}
void QOpenGLFunctions_2_1_GlGetPolygonStipple3(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetPolygonStipple(static_cast<GLubyte*>(static_cast<void*>(mask)));
}
void QOpenGLFunctions_2_1_GlGetProgramiv3(void* ptr, unsigned int program, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetProgramiv(program, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetQueryObjectiv3(void* ptr, unsigned int id, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetQueryObjectiv(id, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetQueryObjectuiv3(void* ptr, unsigned int id, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetQueryObjectuiv(id, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetQueryiv3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetQueryiv(target, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetSeparableFilter3(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* row, void* column, void* span)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetSeparableFilter(target, format, ty, row, column, span);
}
void QOpenGLFunctions_2_1_GlGetShaderiv3(void* ptr, unsigned int shader, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetShaderiv(shader, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetTexEnvfv3(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetTexEnvfv(target, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetTexEnviv3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetTexEnviv(target, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetTexGenfv3(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetTexGenfv(coord, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetTexGeniv3(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetTexGeniv(coord, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetTexImage3(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_2_1_GlGetTexLevelParameterfv3(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetTexLevelParameteriv3(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetTexParameterfv3(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetTexParameteriv3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetUniformfv3(void* ptr, unsigned int program, int location, float params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetUniformfv(program, location, &params);
}
void QOpenGLFunctions_2_1_GlGetUniformiv3(void* ptr, unsigned int program, int location, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetUniformiv(program, location, &params);
}
void QOpenGLFunctions_2_1_GlGetVertexAttribPointerv3(void* ptr, unsigned int index, unsigned int pname, void* pointer)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetVertexAttribPointerv(index, pname, &pointer);
}
void QOpenGLFunctions_2_1_GlGetVertexAttribfv3(void* ptr, unsigned int index, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetVertexAttribfv(index, pname, &params);
}
void QOpenGLFunctions_2_1_GlGetVertexAttribiv3(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glGetVertexAttribiv(index, pname, &params);
}
void QOpenGLFunctions_2_1_GlHint3(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_2_1_GlHistogram3(void* ptr, unsigned int target, int width, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glHistogram(target, width, internalformat, sink != 0);
}
void QOpenGLFunctions_2_1_GlIndexMask3(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glIndexMask(mask);
}
void QOpenGLFunctions_2_1_GlIndexPointer3(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glIndexPointer(ty, stride, pointer);
}
void QOpenGLFunctions_2_1_GlIndexf3(void* ptr, float c)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glIndexf(c);
}
void QOpenGLFunctions_2_1_GlIndexfv3(void* ptr, float c)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glIndexfv(const_cast<const GLfloat*>(&c));
}
void QOpenGLFunctions_2_1_GlIndexi3(void* ptr, int c)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glIndexi(c);
}
void QOpenGLFunctions_2_1_GlIndexiv3(void* ptr, int c)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glIndexiv(const_cast<const GLint*>(&c));
}
void QOpenGLFunctions_2_1_GlIndexs3(void* ptr, short c)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glIndexs(c);
}
void QOpenGLFunctions_2_1_GlIndexsv3(void* ptr, short c)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glIndexsv(const_cast<const GLshort*>(&c));
}
void QOpenGLFunctions_2_1_GlIndexub3(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glIndexub(*static_cast<GLubyte*>(static_cast<void*>(c)));
}
void QOpenGLFunctions_2_1_GlIndexubv3(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glIndexubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(c))));
}
void QOpenGLFunctions_2_1_GlInitNames3(void* ptr)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glInitNames();
}
void QOpenGLFunctions_2_1_GlInterleavedArrays3(void* ptr, unsigned int format, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glInterleavedArrays(format, stride, pointer);
}
void QOpenGLFunctions_2_1_GlLightModelf3(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glLightModelf(pname, param);
}
void QOpenGLFunctions_2_1_GlLightModelfv3(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glLightModelfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_2_1_GlLightModeli3(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glLightModeli(pname, param);
}
void QOpenGLFunctions_2_1_GlLightModeliv3(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glLightModeliv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_2_1_GlLightf3(void* ptr, unsigned int light, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glLightf(light, pname, param);
}
void QOpenGLFunctions_2_1_GlLightfv3(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glLightfv(light, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_2_1_GlLighti3(void* ptr, unsigned int light, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glLighti(light, pname, param);
}
void QOpenGLFunctions_2_1_GlLightiv3(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glLightiv(light, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_2_1_GlLineStipple3(void* ptr, int factor, unsigned short pattern)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glLineStipple(factor, pattern);
}
void QOpenGLFunctions_2_1_GlLineWidth3(void* ptr, float width)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_2_1_GlLinkProgram3(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glLinkProgram(program);
}
void QOpenGLFunctions_2_1_GlListBase3(void* ptr, unsigned int base)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glListBase(base);
}
void QOpenGLFunctions_2_1_GlLoadIdentity3(void* ptr)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glLoadIdentity();
}
void QOpenGLFunctions_2_1_GlLoadMatrixf3(void* ptr, float m)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glLoadMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_2_1_GlLoadName3(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glLoadName(name);
}
void QOpenGLFunctions_2_1_GlLoadTransposeMatrixf3(void* ptr, float m)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glLoadTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_2_1_GlLogicOp3(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_2_1_GlMap1f3(void* ptr, unsigned int target, float u1, float u2, int stride, int order, float points)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMap1f(target, u1, u2, stride, order, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_2_1_GlMap2f3(void* ptr, unsigned int target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float points)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_2_1_GlMapGrid1f3(void* ptr, int un, float u1, float u2)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMapGrid1f(un, u1, u2);
}
void QOpenGLFunctions_2_1_GlMapGrid2f3(void* ptr, int un, float u1, float u2, int vn, float v1, float v2)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMapGrid2f(un, u1, u2, vn, v1, v2);
}
void QOpenGLFunctions_2_1_GlMaterialf3(void* ptr, unsigned int face, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMaterialf(face, pname, param);
}
void QOpenGLFunctions_2_1_GlMaterialfv3(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMaterialfv(face, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_2_1_GlMateriali3(void* ptr, unsigned int face, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMateriali(face, pname, param);
}
void QOpenGLFunctions_2_1_GlMaterialiv3(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMaterialiv(face, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_2_1_GlMatrixMode3(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMatrixMode(mode);
}
void QOpenGLFunctions_2_1_GlMinmax3(void* ptr, unsigned int target, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMinmax(target, internalformat, sink != 0);
}
void QOpenGLFunctions_2_1_GlMultMatrixf3(void* ptr, float m)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_2_1_GlMultTransposeMatrixf3(void* ptr, float m)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_2_1_GlMultiDrawArrays3(void* ptr, unsigned int mode, int first, int count, int drawcount)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiDrawArrays(mode, const_cast<const GLint*>(&first), const_cast<const GLsizei*>(&count), drawcount);
}
void QOpenGLFunctions_2_1_GlMultiTexCoord1f3(void* ptr, unsigned int target, float s)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiTexCoord1f(target, s);
}
void QOpenGLFunctions_2_1_GlMultiTexCoord1fv3(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiTexCoord1fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_1_GlMultiTexCoord1i3(void* ptr, unsigned int target, int s)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiTexCoord1i(target, s);
}
void QOpenGLFunctions_2_1_GlMultiTexCoord1iv3(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiTexCoord1iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_1_GlMultiTexCoord1s3(void* ptr, unsigned int target, short s)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiTexCoord1s(target, s);
}
void QOpenGLFunctions_2_1_GlMultiTexCoord1sv3(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiTexCoord1sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_GlMultiTexCoord2f3(void* ptr, unsigned int target, float s, float t)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiTexCoord2f(target, s, t);
}
void QOpenGLFunctions_2_1_GlMultiTexCoord2fv3(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiTexCoord2fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_1_GlMultiTexCoord2i3(void* ptr, unsigned int target, int s, int t)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiTexCoord2i(target, s, t);
}
void QOpenGLFunctions_2_1_GlMultiTexCoord2iv3(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiTexCoord2iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_1_GlMultiTexCoord2s3(void* ptr, unsigned int target, short s, short t)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiTexCoord2s(target, s, t);
}
void QOpenGLFunctions_2_1_GlMultiTexCoord2sv3(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiTexCoord2sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_GlMultiTexCoord3f3(void* ptr, unsigned int target, float s, float t, float r)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiTexCoord3f(target, s, t, r);
}
void QOpenGLFunctions_2_1_GlMultiTexCoord3fv3(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiTexCoord3fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_1_GlMultiTexCoord3i3(void* ptr, unsigned int target, int s, int t, int r)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiTexCoord3i(target, s, t, r);
}
void QOpenGLFunctions_2_1_GlMultiTexCoord3iv3(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiTexCoord3iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_1_GlMultiTexCoord3s3(void* ptr, unsigned int target, short s, short t, short r)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiTexCoord3s(target, s, t, r);
}
void QOpenGLFunctions_2_1_GlMultiTexCoord3sv3(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiTexCoord3sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_GlMultiTexCoord4f3(void* ptr, unsigned int target, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiTexCoord4f(target, s, t, r, q);
}
void QOpenGLFunctions_2_1_GlMultiTexCoord4fv3(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiTexCoord4fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_1_GlMultiTexCoord4i3(void* ptr, unsigned int target, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiTexCoord4i(target, s, t, r, q);
}
void QOpenGLFunctions_2_1_GlMultiTexCoord4iv3(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiTexCoord4iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_1_GlMultiTexCoord4s3(void* ptr, unsigned int target, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiTexCoord4s(target, s, t, r, q);
}
void QOpenGLFunctions_2_1_GlMultiTexCoord4sv3(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glMultiTexCoord4sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_GlNewList3(void* ptr, unsigned int list, unsigned int mode)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glNewList(list, mode);
}
void QOpenGLFunctions_2_1_GlNormal3f3(void* ptr, float nx, float ny, float nz)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glNormal3f(nx, ny, nz);
}
void QOpenGLFunctions_2_1_GlNormal3fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glNormal3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_1_GlNormal3i3(void* ptr, int nx, int ny, int nz)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glNormal3i(nx, ny, nz);
}
void QOpenGLFunctions_2_1_GlNormal3iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glNormal3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_1_GlNormal3s3(void* ptr, short nx, short ny, short nz)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glNormal3s(nx, ny, nz);
}
void QOpenGLFunctions_2_1_GlNormal3sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glNormal3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_GlNormalPointer3(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glNormalPointer(ty, stride, pointer);
}
void QOpenGLFunctions_2_1_GlPassThrough3(void* ptr, float token)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPassThrough(token);
}
void QOpenGLFunctions_2_1_GlPixelMapfv3(void* ptr, unsigned int m, int mapsize, float values)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPixelMapfv(m, mapsize, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_2_1_GlPixelMapuiv3(void* ptr, unsigned int m, int mapsize, unsigned int values)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPixelMapuiv(m, mapsize, const_cast<const GLuint*>(&values));
}
void QOpenGLFunctions_2_1_GlPixelMapusv3(void* ptr, unsigned int m, int mapsize, unsigned short values)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPixelMapusv(m, mapsize, const_cast<const GLushort*>(&values));
}
void QOpenGLFunctions_2_1_GlPixelStoref3(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_2_1_GlPixelStorei3(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_2_1_GlPixelTransferf3(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPixelTransferf(pname, param);
}
void QOpenGLFunctions_2_1_GlPixelTransferi3(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPixelTransferi(pname, param);
}
void QOpenGLFunctions_2_1_GlPixelZoom3(void* ptr, float xfactor, float yfactor)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPixelZoom(xfactor, yfactor);
}
void QOpenGLFunctions_2_1_GlPointParameterf3(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPointParameterf(pname, param);
}
void QOpenGLFunctions_2_1_GlPointParameterfv3(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPointParameterfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_2_1_GlPointParameteri3(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPointParameteri(pname, param);
}
void QOpenGLFunctions_2_1_GlPointParameteriv3(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPointParameteriv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_2_1_GlPointSize3(void* ptr, float size)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_2_1_GlPolygonMode3(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_2_1_GlPolygonOffset3(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_2_1_GlPolygonStipple3(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPolygonStipple(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(mask))));
}
void QOpenGLFunctions_2_1_GlPopAttrib3(void* ptr)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPopAttrib();
}
void QOpenGLFunctions_2_1_GlPopClientAttrib3(void* ptr)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPopClientAttrib();
}
void QOpenGLFunctions_2_1_GlPopMatrix3(void* ptr)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPopMatrix();
}
void QOpenGLFunctions_2_1_GlPopName3(void* ptr)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPopName();
}
void QOpenGLFunctions_2_1_GlPrioritizeTextures3(void* ptr, int n, unsigned int textures, float priorities)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPrioritizeTextures(n, const_cast<const GLuint*>(&textures), const_cast<const GLfloat*>(&priorities));
}
void QOpenGLFunctions_2_1_GlPushAttrib3(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPushAttrib(mask);
}
void QOpenGLFunctions_2_1_GlPushClientAttrib3(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPushClientAttrib(mask);
}
void QOpenGLFunctions_2_1_GlPushMatrix3(void* ptr)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPushMatrix();
}
void QOpenGLFunctions_2_1_GlPushName3(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glPushName(name);
}
void QOpenGLFunctions_2_1_GlRasterPos2f3(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRasterPos2f(x, y);
}
void QOpenGLFunctions_2_1_GlRasterPos2fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRasterPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_1_GlRasterPos2i3(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRasterPos2i(x, y);
}
void QOpenGLFunctions_2_1_GlRasterPos2iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRasterPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_1_GlRasterPos2s3(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRasterPos2s(x, y);
}
void QOpenGLFunctions_2_1_GlRasterPos2sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRasterPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_GlRasterPos3f3(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRasterPos3f(x, y, z);
}
void QOpenGLFunctions_2_1_GlRasterPos3fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRasterPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_1_GlRasterPos3i3(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRasterPos3i(x, y, z);
}
void QOpenGLFunctions_2_1_GlRasterPos3iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRasterPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_1_GlRasterPos3s3(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRasterPos3s(x, y, z);
}
void QOpenGLFunctions_2_1_GlRasterPos3sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRasterPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_GlRasterPos4f3(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRasterPos4f(x, y, z, w);
}
void QOpenGLFunctions_2_1_GlRasterPos4fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRasterPos4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_1_GlRasterPos4i3(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRasterPos4i(x, y, z, w);
}
void QOpenGLFunctions_2_1_GlRasterPos4iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRasterPos4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_1_GlRasterPos4s3(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRasterPos4s(x, y, z, w);
}
void QOpenGLFunctions_2_1_GlRasterPos4sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRasterPos4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_GlReadBuffer3(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glReadBuffer(mode);
}
void QOpenGLFunctions_2_1_GlReadPixels3(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_2_1_GlRectf3(void* ptr, float x1, float y1, float x2, float y2)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRectf(x1, y1, x2, y2);
}
void QOpenGLFunctions_2_1_GlRectfv3(void* ptr, float v1, float v2)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRectfv(const_cast<const GLfloat*>(&v1), const_cast<const GLfloat*>(&v2));
}
void QOpenGLFunctions_2_1_GlRecti3(void* ptr, int x1, int y1, int x2, int y2)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRecti(x1, y1, x2, y2);
}
void QOpenGLFunctions_2_1_GlRectiv3(void* ptr, int v1, int v2)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRectiv(const_cast<const GLint*>(&v1), const_cast<const GLint*>(&v2));
}
void QOpenGLFunctions_2_1_GlRects3(void* ptr, short x1, short y1, short x2, short y2)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRects(x1, y1, x2, y2);
}
void QOpenGLFunctions_2_1_GlRectsv3(void* ptr, short v1, short v2)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRectsv(const_cast<const GLshort*>(&v1), const_cast<const GLshort*>(&v2));
}
void QOpenGLFunctions_2_1_GlResetHistogram3(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glResetHistogram(target);
}
void QOpenGLFunctions_2_1_GlResetMinmax3(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glResetMinmax(target);
}
void QOpenGLFunctions_2_1_GlRotatef3(void* ptr, float angle, float x, float y, float z)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glRotatef(angle, x, y, z);
}
void QOpenGLFunctions_2_1_GlSampleCoverage3(void* ptr, float value, char invert)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glSampleCoverage(value, invert != 0);
}
void QOpenGLFunctions_2_1_GlScalef3(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glScalef(x, y, z);
}
void QOpenGLFunctions_2_1_GlScissor3(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_2_1_GlSecondaryColor3f3(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glSecondaryColor3f(red, green, blue);
}
void QOpenGLFunctions_2_1_GlSecondaryColor3fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glSecondaryColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_1_GlSecondaryColor3i3(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glSecondaryColor3i(red, green, blue);
}
void QOpenGLFunctions_2_1_GlSecondaryColor3iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glSecondaryColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_1_GlSecondaryColor3s3(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glSecondaryColor3s(red, green, blue);
}
void QOpenGLFunctions_2_1_GlSecondaryColor3sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glSecondaryColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_GlSecondaryColor3ub3(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glSecondaryColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_2_1_GlSecondaryColor3ubv3(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glSecondaryColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_2_1_GlSecondaryColor3ui3(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glSecondaryColor3ui(red, green, blue);
}
void QOpenGLFunctions_2_1_GlSecondaryColor3uiv3(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glSecondaryColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_2_1_GlSecondaryColor3us3(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glSecondaryColor3us(red, green, blue);
}
void QOpenGLFunctions_2_1_GlSecondaryColor3usv3(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glSecondaryColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_2_1_GlSecondaryColorPointer3(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glSecondaryColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_2_1_GlSelectBuffer3(void* ptr, int size, unsigned int buffer)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glSelectBuffer(size, &buffer);
}
void QOpenGLFunctions_2_1_GlSeparableFilter2D3(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* row, void* column)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glSeparableFilter2D(target, internalformat, width, height, format, ty, row, column);
}
void QOpenGLFunctions_2_1_GlShadeModel3(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glShadeModel(mode);
}
void QOpenGLFunctions_2_1_GlStencilFunc3(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_2_1_GlStencilFuncSeparate3(void* ptr, unsigned int face, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glStencilFuncSeparate(face, fu, ref, mask);
}
void QOpenGLFunctions_2_1_GlStencilMask3(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_2_1_GlStencilMaskSeparate3(void* ptr, unsigned int face, unsigned int mask)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glStencilMaskSeparate(face, mask);
}
void QOpenGLFunctions_2_1_GlStencilOp3(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_2_1_GlStencilOpSeparate3(void* ptr, unsigned int face, unsigned int sfail, unsigned int dpfail, unsigned int dppass)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glStencilOpSeparate(face, sfail, dpfail, dppass);
}
void QOpenGLFunctions_2_1_GlTexCoord1f3(void* ptr, float s)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoord1f(s);
}
void QOpenGLFunctions_2_1_GlTexCoord1fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoord1fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_1_GlTexCoord1i3(void* ptr, int s)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoord1i(s);
}
void QOpenGLFunctions_2_1_GlTexCoord1iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoord1iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_1_GlTexCoord1s3(void* ptr, short s)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoord1s(s);
}
void QOpenGLFunctions_2_1_GlTexCoord1sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoord1sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_GlTexCoord2f3(void* ptr, float s, float t)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoord2f(s, t);
}
void QOpenGLFunctions_2_1_GlTexCoord2fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoord2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_1_GlTexCoord2i3(void* ptr, int s, int t)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoord2i(s, t);
}
void QOpenGLFunctions_2_1_GlTexCoord2iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoord2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_1_GlTexCoord2s3(void* ptr, short s, short t)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoord2s(s, t);
}
void QOpenGLFunctions_2_1_GlTexCoord2sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoord2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_GlTexCoord3f3(void* ptr, float s, float t, float r)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoord3f(s, t, r);
}
void QOpenGLFunctions_2_1_GlTexCoord3fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoord3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_1_GlTexCoord3i3(void* ptr, int s, int t, int r)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoord3i(s, t, r);
}
void QOpenGLFunctions_2_1_GlTexCoord3iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoord3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_1_GlTexCoord3s3(void* ptr, short s, short t, short r)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoord3s(s, t, r);
}
void QOpenGLFunctions_2_1_GlTexCoord3sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoord3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_GlTexCoord4f3(void* ptr, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoord4f(s, t, r, q);
}
void QOpenGLFunctions_2_1_GlTexCoord4fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoord4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_1_GlTexCoord4i3(void* ptr, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoord4i(s, t, r, q);
}
void QOpenGLFunctions_2_1_GlTexCoord4iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoord4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_1_GlTexCoord4s3(void* ptr, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoord4s(s, t, r, q);
}
void QOpenGLFunctions_2_1_GlTexCoord4sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoord4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_GlTexCoordPointer3(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexCoordPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_2_1_GlTexEnvf3(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexEnvf(target, pname, param);
}
void QOpenGLFunctions_2_1_GlTexEnvfv3(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexEnvfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_2_1_GlTexEnvi3(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexEnvi(target, pname, param);
}
void QOpenGLFunctions_2_1_GlTexEnviv3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexEnviv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_2_1_GlTexGenf3(void* ptr, unsigned int coord, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexGenf(coord, pname, param);
}
void QOpenGLFunctions_2_1_GlTexGenfv3(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexGenfv(coord, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_2_1_GlTexGeni3(void* ptr, unsigned int coord, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexGeni(coord, pname, param);
}
void QOpenGLFunctions_2_1_GlTexGeniv3(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexGeniv(coord, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_2_1_GlTexImage1D3(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_2_1_GlTexImage2D3(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_2_1_GlTexImage3D3(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLFunctions_2_1_GlTexParameterf3(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_2_1_GlTexParameterfv3(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_2_1_GlTexParameteri3(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_2_1_GlTexParameteriv3(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_2_1_GlTexSubImage1D3(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_2_1_GlTexSubImage2D3(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_2_1_GlTexSubImage3D3(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_2_1_GlTranslatef3(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glTranslatef(x, y, z);
}
void QOpenGLFunctions_2_1_GlUniform1f3(void* ptr, int location, float v0)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniform1f(location, v0);
}
void QOpenGLFunctions_2_1_GlUniform1fv3(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniform1fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_2_1_GlUniform1i3(void* ptr, int location, int v0)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniform1i(location, v0);
}
void QOpenGLFunctions_2_1_GlUniform1iv3(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniform1iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_2_1_GlUniform2f3(void* ptr, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniform2f(location, v0, v1);
}
void QOpenGLFunctions_2_1_GlUniform2fv3(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniform2fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_2_1_GlUniform2i3(void* ptr, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniform2i(location, v0, v1);
}
void QOpenGLFunctions_2_1_GlUniform2iv3(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniform2iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_2_1_GlUniform3f3(void* ptr, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniform3f(location, v0, v1, v2);
}
void QOpenGLFunctions_2_1_GlUniform3fv3(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniform3fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_2_1_GlUniform3i3(void* ptr, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniform3i(location, v0, v1, v2);
}
void QOpenGLFunctions_2_1_GlUniform3iv3(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniform3iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_2_1_GlUniform4f3(void* ptr, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniform4f(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_2_1_GlUniform4fv3(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniform4fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_2_1_GlUniform4i3(void* ptr, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniform4i(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_2_1_GlUniform4iv3(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniform4iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_2_1_GlUniformMatrix2fv3(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniformMatrix2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_2_1_GlUniformMatrix2x3fv3(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniformMatrix2x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_2_1_GlUniformMatrix2x4fv3(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniformMatrix2x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_2_1_GlUniformMatrix3fv3(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniformMatrix3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_2_1_GlUniformMatrix3x2fv3(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniformMatrix3x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_2_1_GlUniformMatrix3x4fv3(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniformMatrix3x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_2_1_GlUniformMatrix4fv3(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniformMatrix4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_2_1_GlUniformMatrix4x2fv3(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniformMatrix4x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_2_1_GlUniformMatrix4x3fv3(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUniformMatrix4x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_2_1_GlUseProgram3(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glUseProgram(program);
}
void QOpenGLFunctions_2_1_GlValidateProgram3(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glValidateProgram(program);
}
void QOpenGLFunctions_2_1_GlVertex2f3(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertex2f(x, y);
}
void QOpenGLFunctions_2_1_GlVertex2fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertex2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_1_GlVertex2i3(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertex2i(x, y);
}
void QOpenGLFunctions_2_1_GlVertex2iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertex2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_1_GlVertex2s3(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertex2s(x, y);
}
void QOpenGLFunctions_2_1_GlVertex2sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertex2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_GlVertex3f3(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertex3f(x, y, z);
}
void QOpenGLFunctions_2_1_GlVertex3fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertex3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_1_GlVertex3i3(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertex3i(x, y, z);
}
void QOpenGLFunctions_2_1_GlVertex3iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertex3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_1_GlVertex3s3(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertex3s(x, y, z);
}
void QOpenGLFunctions_2_1_GlVertex3sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertex3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_GlVertex4f3(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertex4f(x, y, z, w);
}
void QOpenGLFunctions_2_1_GlVertex4fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertex4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_1_GlVertex4i3(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertex4i(x, y, z, w);
}
void QOpenGLFunctions_2_1_GlVertex4iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertex4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_1_GlVertex4s3(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertex4s(x, y, z, w);
}
void QOpenGLFunctions_2_1_GlVertex4sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertex4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_GlVertexAttrib1f3(void* ptr, unsigned int index, float x)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib1f(index, x);
}
void QOpenGLFunctions_2_1_GlVertexAttrib1fv3(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib1fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_1_GlVertexAttrib1s3(void* ptr, unsigned int index, short x)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib1s(index, x);
}
void QOpenGLFunctions_2_1_GlVertexAttrib1sv3(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib1sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_GlVertexAttrib2f3(void* ptr, unsigned int index, float x, float y)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib2f(index, x, y);
}
void QOpenGLFunctions_2_1_GlVertexAttrib2fv3(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib2fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_1_GlVertexAttrib2s3(void* ptr, unsigned int index, short x, short y)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib2s(index, x, y);
}
void QOpenGLFunctions_2_1_GlVertexAttrib2sv3(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib2sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_GlVertexAttrib3f3(void* ptr, unsigned int index, float x, float y, float z)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib3f(index, x, y, z);
}
void QOpenGLFunctions_2_1_GlVertexAttrib3fv3(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib3fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_1_GlVertexAttrib3s3(void* ptr, unsigned int index, short x, short y, short z)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib3s(index, x, y, z);
}
void QOpenGLFunctions_2_1_GlVertexAttrib3sv3(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib3sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_GlVertexAttrib4Niv3(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib4Niv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_1_GlVertexAttrib4Nsv3(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib4Nsv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_GlVertexAttrib4Nub3(void* ptr, unsigned int index, char* x, char* y, char* z, char* w)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib4Nub(index, *static_cast<GLubyte*>(static_cast<void*>(x)), *static_cast<GLubyte*>(static_cast<void*>(y)), *static_cast<GLubyte*>(static_cast<void*>(z)), *static_cast<GLubyte*>(static_cast<void*>(w)));
}
void QOpenGLFunctions_2_1_GlVertexAttrib4Nubv3(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib4Nubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_2_1_GlVertexAttrib4Nuiv3(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib4Nuiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_2_1_GlVertexAttrib4Nusv3(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib4Nusv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_2_1_GlVertexAttrib4f3(void* ptr, unsigned int index, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib4f(index, x, y, z, w);
}
void QOpenGLFunctions_2_1_GlVertexAttrib4fv3(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib4fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_1_GlVertexAttrib4iv3(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_1_GlVertexAttrib4s3(void* ptr, unsigned int index, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib4s(index, x, y, z, w);
}
void QOpenGLFunctions_2_1_GlVertexAttrib4sv3(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib4sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_GlVertexAttrib4ubv3(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib4ubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_2_1_GlVertexAttrib4uiv3(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_2_1_GlVertexAttrib4usv3(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttrib4usv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_2_1_GlVertexAttribPointer3(void* ptr, unsigned int index, int size, unsigned int ty, char normalized, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexAttribPointer(index, size, ty, normalized != 0, stride, pointer);
}
void QOpenGLFunctions_2_1_GlVertexPointer3(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glVertexPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_2_1_GlViewport3(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_2_1_GlWindowPos2f3(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glWindowPos2f(x, y);
}
void QOpenGLFunctions_2_1_GlWindowPos2fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glWindowPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_1_GlWindowPos2i3(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glWindowPos2i(x, y);
}
void QOpenGLFunctions_2_1_GlWindowPos2iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glWindowPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_1_GlWindowPos2s3(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glWindowPos2s(x, y);
}
void QOpenGLFunctions_2_1_GlWindowPos2sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glWindowPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_GlWindowPos3f3(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glWindowPos3f(x, y, z);
}
void QOpenGLFunctions_2_1_GlWindowPos3fv3(void* ptr, float v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glWindowPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_2_1_GlWindowPos3i3(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glWindowPos3i(x, y, z);
}
void QOpenGLFunctions_2_1_GlWindowPos3iv3(void* ptr, int v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glWindowPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_2_1_GlWindowPos3s3(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glWindowPos3s(x, y, z);
}
void QOpenGLFunctions_2_1_GlWindowPos3sv3(void* ptr, short v)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->glWindowPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_2_1_DestroyQOpenGLFunctions_2_13(void* ptr)
{
static_cast<QOpenGLFunctions_2_1*>(ptr)->~QOpenGLFunctions_2_1();
}
void QOpenGLFunctions_2_1_DestroyQOpenGLFunctions_2_13Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_3_0: public QOpenGLFunctions_3_0
{
public:
MyQOpenGLFunctions_3_0() : QOpenGLFunctions_3_0() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_3_0_InitializeOpenGLFunctions4(this) != 0; };
~MyQOpenGLFunctions_3_0() { callbackQOpenGLFunctions_3_0_DestroyQOpenGLFunctions_3_04(this); };
};
char QOpenGLFunctions_3_0_GlAreTexturesResident4(void* ptr, int n, unsigned int textures, char residences)
{
Q_UNUSED(residences);
return static_cast<QOpenGLFunctions_3_0*>(ptr)->glAreTexturesResident(n, const_cast<const GLuint*>(&textures), NULL);
}
char QOpenGLFunctions_3_0_GlIsBuffer4(void* ptr, unsigned int buffer)
{
return static_cast<QOpenGLFunctions_3_0*>(ptr)->glIsBuffer(buffer);
}
char QOpenGLFunctions_3_0_GlIsEnabled4(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_3_0*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_3_0_GlIsEnabledi4(void* ptr, unsigned int target, unsigned int index)
{
return static_cast<QOpenGLFunctions_3_0*>(ptr)->glIsEnabledi(target, index);
}
char QOpenGLFunctions_3_0_GlIsFramebuffer4(void* ptr, unsigned int framebuffer)
{
return static_cast<QOpenGLFunctions_3_0*>(ptr)->glIsFramebuffer(framebuffer);
}
char QOpenGLFunctions_3_0_GlIsList4(void* ptr, unsigned int list)
{
return static_cast<QOpenGLFunctions_3_0*>(ptr)->glIsList(list);
}
char QOpenGLFunctions_3_0_GlIsProgram4(void* ptr, unsigned int program)
{
return static_cast<QOpenGLFunctions_3_0*>(ptr)->glIsProgram(program);
}
char QOpenGLFunctions_3_0_GlIsQuery4(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_3_0*>(ptr)->glIsQuery(id);
}
char QOpenGLFunctions_3_0_GlIsRenderbuffer4(void* ptr, unsigned int renderbuffer)
{
return static_cast<QOpenGLFunctions_3_0*>(ptr)->glIsRenderbuffer(renderbuffer);
}
char QOpenGLFunctions_3_0_GlIsShader4(void* ptr, unsigned int shader)
{
return static_cast<QOpenGLFunctions_3_0*>(ptr)->glIsShader(shader);
}
char QOpenGLFunctions_3_0_GlIsTexture4(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_3_0*>(ptr)->glIsTexture(texture);
}
char QOpenGLFunctions_3_0_GlIsVertexArray4(void* ptr, unsigned int array)
{
return static_cast<QOpenGLFunctions_3_0*>(ptr)->glIsVertexArray(array);
}
char QOpenGLFunctions_3_0_GlUnmapBuffer4(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_3_0*>(ptr)->glUnmapBuffer(target);
}
unsigned int QOpenGLFunctions_3_0_GlCheckFramebufferStatus4(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_3_0*>(ptr)->glCheckFramebufferStatus(target);
}
unsigned int QOpenGLFunctions_3_0_GlGetError4(void* ptr)
{
return static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetError();
}
int QOpenGLFunctions_3_0_GlRenderMode4(void* ptr, unsigned int mode)
{
return static_cast<QOpenGLFunctions_3_0*>(ptr)->glRenderMode(mode);
}
unsigned int QOpenGLFunctions_3_0_GlCreateProgram4(void* ptr)
{
return static_cast<QOpenGLFunctions_3_0*>(ptr)->glCreateProgram();
}
unsigned int QOpenGLFunctions_3_0_GlCreateShader4(void* ptr, unsigned int ty)
{
return static_cast<QOpenGLFunctions_3_0*>(ptr)->glCreateShader(ty);
}
unsigned int QOpenGLFunctions_3_0_GlGenLists4(void* ptr, int ran)
{
return static_cast<QOpenGLFunctions_3_0*>(ptr)->glGenLists(ran);
}
void* QOpenGLFunctions_3_0_GlMapBuffer4(void* ptr, unsigned int target, unsigned int access)
{
return static_cast<QOpenGLFunctions_3_0*>(ptr)->glMapBuffer(target, access);
}
void* QOpenGLFunctions_3_0_NewQOpenGLFunctions_3_04()
{
return new MyQOpenGLFunctions_3_0();
}
char QOpenGLFunctions_3_0_InitializeOpenGLFunctions4(void* ptr)
{
return static_cast<QOpenGLFunctions_3_0*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_3_0_InitializeOpenGLFunctions4Default(void* ptr)
{
return static_cast<QOpenGLFunctions_3_0*>(ptr)->QOpenGLFunctions_3_0::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_3_0_GlGetString4(void* ptr, unsigned int name)
{
return ({ char* t86fb02 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetString(name)))); QtGui_PackedString { t86fb02, -1 }; });
}
struct QtGui_PackedString QOpenGLFunctions_3_0_GlGetStringi4(void* ptr, unsigned int name, unsigned int index)
{
return ({ char* t2ebf28 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetStringi(name, index)))); QtGui_PackedString { t2ebf28, -1 }; });
}
void QOpenGLFunctions_3_0_GlAccum4(void* ptr, unsigned int op, float value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glAccum(op, value);
}
void QOpenGLFunctions_3_0_GlActiveTexture4(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glActiveTexture(texture);
}
void QOpenGLFunctions_3_0_GlAlphaFunc4(void* ptr, unsigned int fu, float ref)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glAlphaFunc(fu, ref);
}
void QOpenGLFunctions_3_0_GlArrayElement4(void* ptr, int i)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glArrayElement(i);
}
void QOpenGLFunctions_3_0_GlAttachShader4(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glAttachShader(program, shader);
}
void QOpenGLFunctions_3_0_GlBegin4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glBegin(mode);
}
void QOpenGLFunctions_3_0_GlBeginConditionalRender4(void* ptr, unsigned int id, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glBeginConditionalRender(id, mode);
}
void QOpenGLFunctions_3_0_GlBeginQuery4(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glBeginQuery(target, id);
}
void QOpenGLFunctions_3_0_GlBeginTransformFeedback4(void* ptr, unsigned int primitiveMode)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glBeginTransformFeedback(primitiveMode);
}
void QOpenGLFunctions_3_0_GlBindBuffer4(void* ptr, unsigned int target, unsigned int buffer)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glBindBuffer(target, buffer);
}
void QOpenGLFunctions_3_0_GlBindBufferBase4(void* ptr, unsigned int target, unsigned int index, unsigned int buffer)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glBindBufferBase(target, index, buffer);
}
void QOpenGLFunctions_3_0_GlBindFramebuffer4(void* ptr, unsigned int target, unsigned int framebuffer)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glBindFramebuffer(target, framebuffer);
}
void QOpenGLFunctions_3_0_GlBindRenderbuffer4(void* ptr, unsigned int target, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glBindRenderbuffer(target, renderbuffer);
}
void QOpenGLFunctions_3_0_GlBindTexture4(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_3_0_GlBindVertexArray4(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glBindVertexArray(array);
}
void QOpenGLFunctions_3_0_GlBitmap4(void* ptr, int width, int height, float xorig, float yorig, float xmove, float ymove, char* bitmap)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glBitmap(width, height, xorig, yorig, xmove, ymove, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(bitmap))));
}
void QOpenGLFunctions_3_0_GlBlendColor4(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_3_0_GlBlendEquation4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_3_0_GlBlendEquationSeparate4(void* ptr, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glBlendEquationSeparate(modeRGB, modeAlpha);
}
void QOpenGLFunctions_3_0_GlBlendFunc4(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_3_0_GlBlendFuncSeparate4(void* ptr, unsigned int sfactorRGB, unsigned int dfactorRGB, unsigned int sfactorAlpha, unsigned int dfactorAlpha)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void QOpenGLFunctions_3_0_GlBlitFramebuffer4(void* ptr, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, unsigned int mask, unsigned int filter)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
void QOpenGLFunctions_3_0_GlCallList4(void* ptr, unsigned int list)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glCallList(list);
}
void QOpenGLFunctions_3_0_GlCallLists4(void* ptr, int n, unsigned int ty, void* lists)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glCallLists(n, ty, lists);
}
void QOpenGLFunctions_3_0_GlClampColor4(void* ptr, unsigned int target, unsigned int clamp)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glClampColor(target, clamp);
}
void QOpenGLFunctions_3_0_GlClear4(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_3_0_GlClearAccum4(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glClearAccum(red, green, blue, alpha);
}
void QOpenGLFunctions_3_0_GlClearBufferfi4(void* ptr, unsigned int buffer, int drawbuffer, float depth, int stencil)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glClearBufferfi(buffer, drawbuffer, depth, stencil);
}
void QOpenGLFunctions_3_0_GlClearBufferfv4(void* ptr, unsigned int buffer, int drawbuffer, float value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glClearBufferfv(buffer, drawbuffer, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_0_GlClearBufferiv4(void* ptr, unsigned int buffer, int drawbuffer, int value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glClearBufferiv(buffer, drawbuffer, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_0_GlClearBufferuiv4(void* ptr, unsigned int buffer, int drawbuffer, unsigned int value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glClearBufferuiv(buffer, drawbuffer, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_0_GlClearColor4(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_3_0_GlClearIndex4(void* ptr, float c)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glClearIndex(c);
}
void QOpenGLFunctions_3_0_GlClearStencil4(void* ptr, int s)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_3_0_GlClientActiveTexture4(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glClientActiveTexture(texture);
}
void QOpenGLFunctions_3_0_GlColor3f4(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColor3f(red, green, blue);
}
void QOpenGLFunctions_3_0_GlColor3fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_0_GlColor3i4(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColor3i(red, green, blue);
}
void QOpenGLFunctions_3_0_GlColor3iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlColor3s4(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColor3s(red, green, blue);
}
void QOpenGLFunctions_3_0_GlColor3sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlColor3ub4(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_3_0_GlColor3ubv4(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_3_0_GlColor3ui4(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColor3ui(red, green, blue);
}
void QOpenGLFunctions_3_0_GlColor3uiv4(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_0_GlColor3us4(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColor3us(red, green, blue);
}
void QOpenGLFunctions_3_0_GlColor3usv4(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_3_0_GlColor4f4(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColor4f(red, green, blue, alpha);
}
void QOpenGLFunctions_3_0_GlColor4fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColor4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_0_GlColor4i4(void* ptr, int red, int green, int blue, int alpha)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColor4i(red, green, blue, alpha);
}
void QOpenGLFunctions_3_0_GlColor4iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColor4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlColor4s4(void* ptr, short red, short green, short blue, short alpha)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColor4s(red, green, blue, alpha);
}
void QOpenGLFunctions_3_0_GlColor4sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColor4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlColor4ub4(void* ptr, char* red, char* green, char* blue, char* alpha)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColor4ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)), *static_cast<GLubyte*>(static_cast<void*>(alpha)));
}
void QOpenGLFunctions_3_0_GlColor4ubv4(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColor4ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_3_0_GlColor4ui4(void* ptr, unsigned int red, unsigned int green, unsigned int blue, unsigned int alpha)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColor4ui(red, green, blue, alpha);
}
void QOpenGLFunctions_3_0_GlColor4uiv4(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColor4uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_0_GlColor4us4(void* ptr, unsigned short red, unsigned short green, unsigned short blue, unsigned short alpha)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColor4us(red, green, blue, alpha);
}
void QOpenGLFunctions_3_0_GlColor4usv4(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColor4usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_3_0_GlColorMask4(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_3_0_GlColorMaski4(void* ptr, unsigned int index, char r, char g, char b, char a)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColorMaski(index, r != 0, g != 0, b != 0, a != 0);
}
void QOpenGLFunctions_3_0_GlColorMaterial4(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColorMaterial(face, mode);
}
void QOpenGLFunctions_3_0_GlColorPointer4(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_3_0_GlColorSubTable4(void* ptr, unsigned int target, int start, int count, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColorSubTable(target, start, count, format, ty, data);
}
void QOpenGLFunctions_3_0_GlColorTable4(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColorTable(target, internalformat, width, format, ty, table);
}
void QOpenGLFunctions_3_0_GlColorTableParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColorTableParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_0_GlColorTableParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glColorTableParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_0_GlCompileShader4(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glCompileShader(shader);
}
void QOpenGLFunctions_3_0_GlCompressedTexImage1D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
void QOpenGLFunctions_3_0_GlCompressedTexImage2D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void QOpenGLFunctions_3_0_GlCompressedTexImage3D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int depth, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void QOpenGLFunctions_3_0_GlCompressedTexSubImage1D4(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_3_0_GlCompressedTexSubImage2D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_3_0_GlCompressedTexSubImage3D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_3_0_GlConvolutionFilter1D4(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glConvolutionFilter1D(target, internalformat, width, format, ty, image);
}
void QOpenGLFunctions_3_0_GlConvolutionFilter2D4(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glConvolutionFilter2D(target, internalformat, width, height, format, ty, image);
}
void QOpenGLFunctions_3_0_GlConvolutionParameterf4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glConvolutionParameterf(target, pname, params);
}
void QOpenGLFunctions_3_0_GlConvolutionParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glConvolutionParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_0_GlConvolutionParameteri4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glConvolutionParameteri(target, pname, params);
}
void QOpenGLFunctions_3_0_GlConvolutionParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glConvolutionParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_0_GlCopyColorSubTable4(void* ptr, unsigned int target, int start, int x, int y, int width)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glCopyColorSubTable(target, start, x, y, width);
}
void QOpenGLFunctions_3_0_GlCopyColorTable4(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glCopyColorTable(target, internalformat, x, y, width);
}
void QOpenGLFunctions_3_0_GlCopyConvolutionFilter1D4(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glCopyConvolutionFilter1D(target, internalformat, x, y, width);
}
void QOpenGLFunctions_3_0_GlCopyConvolutionFilter2D4(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);
}
void QOpenGLFunctions_3_0_GlCopyPixels4(void* ptr, int x, int y, int width, int height, unsigned int ty)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glCopyPixels(x, y, width, height, ty);
}
void QOpenGLFunctions_3_0_GlCopyTexImage1D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_3_0_GlCopyTexImage2D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_3_0_GlCopyTexSubImage1D4(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_3_0_GlCopyTexSubImage2D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_3_0_GlCopyTexSubImage3D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_3_0_GlCullFace4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_3_0_GlDeleteBuffers4(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glDeleteBuffers(n, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_3_0_GlDeleteFramebuffers4(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glDeleteFramebuffers(n, const_cast<const GLuint*>(&framebuffers));
}
void QOpenGLFunctions_3_0_GlDeleteLists4(void* ptr, unsigned int list, int ran)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glDeleteLists(list, ran);
}
void QOpenGLFunctions_3_0_GlDeleteProgram4(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glDeleteProgram(program);
}
void QOpenGLFunctions_3_0_GlDeleteQueries4(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glDeleteQueries(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_3_0_GlDeleteRenderbuffers4(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glDeleteRenderbuffers(n, const_cast<const GLuint*>(&renderbuffers));
}
void QOpenGLFunctions_3_0_GlDeleteShader4(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glDeleteShader(shader);
}
void QOpenGLFunctions_3_0_GlDeleteTextures4(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_3_0_GlDeleteVertexArrays4(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glDeleteVertexArrays(n, const_cast<const GLuint*>(&arrays));
}
void QOpenGLFunctions_3_0_GlDepthFunc4(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_3_0_GlDepthMask4(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_3_0_GlDetachShader4(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glDetachShader(program, shader);
}
void QOpenGLFunctions_3_0_GlDisable4(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_3_0_GlDisableClientState4(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glDisableClientState(array);
}
void QOpenGLFunctions_3_0_GlDisableVertexAttribArray4(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glDisableVertexAttribArray(index);
}
void QOpenGLFunctions_3_0_GlDisablei4(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glDisablei(target, index);
}
void QOpenGLFunctions_3_0_GlDrawArrays4(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_3_0_GlDrawBuffer4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glDrawBuffer(mode);
}
void QOpenGLFunctions_3_0_GlDrawBuffers4(void* ptr, int n, unsigned int bufs)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glDrawBuffers(n, const_cast<const GLenum*>(&bufs));
}
void QOpenGLFunctions_3_0_GlDrawElements4(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_3_0_GlDrawPixels4(void* ptr, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glDrawPixels(width, height, format, ty, pixels);
}
void QOpenGLFunctions_3_0_GlDrawRangeElements4(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLFunctions_3_0_GlEdgeFlag4(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glEdgeFlag(flag != 0);
}
void QOpenGLFunctions_3_0_GlEdgeFlagPointer4(void* ptr, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glEdgeFlagPointer(stride, pointer);
}
void QOpenGLFunctions_3_0_GlEdgeFlagv4(void* ptr, char flag)
{
Q_UNUSED(flag);
static_cast<QOpenGLFunctions_3_0*>(ptr)->glEdgeFlagv(NULL);
}
void QOpenGLFunctions_3_0_GlEnable4(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_3_0_GlEnableClientState4(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glEnableClientState(array);
}
void QOpenGLFunctions_3_0_GlEnableVertexAttribArray4(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glEnableVertexAttribArray(index);
}
void QOpenGLFunctions_3_0_GlEnablei4(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glEnablei(target, index);
}
void QOpenGLFunctions_3_0_GlEnd4(void* ptr)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glEnd();
}
void QOpenGLFunctions_3_0_GlEndConditionalRender4(void* ptr)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glEndConditionalRender();
}
void QOpenGLFunctions_3_0_GlEndList4(void* ptr)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glEndList();
}
void QOpenGLFunctions_3_0_GlEndQuery4(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glEndQuery(target);
}
void QOpenGLFunctions_3_0_GlEndTransformFeedback4(void* ptr)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glEndTransformFeedback();
}
void QOpenGLFunctions_3_0_GlEvalCoord1f4(void* ptr, float u)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glEvalCoord1f(u);
}
void QOpenGLFunctions_3_0_GlEvalCoord1fv4(void* ptr, float u)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glEvalCoord1fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_3_0_GlEvalCoord2f4(void* ptr, float u, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glEvalCoord2f(u, v);
}
void QOpenGLFunctions_3_0_GlEvalCoord2fv4(void* ptr, float u)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glEvalCoord2fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_3_0_GlEvalMesh14(void* ptr, unsigned int mode, int i1, int i2)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glEvalMesh1(mode, i1, i2);
}
void QOpenGLFunctions_3_0_GlEvalMesh24(void* ptr, unsigned int mode, int i1, int i2, int j1, int j2)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glEvalMesh2(mode, i1, i2, j1, j2);
}
void QOpenGLFunctions_3_0_GlEvalPoint14(void* ptr, int i)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glEvalPoint1(i);
}
void QOpenGLFunctions_3_0_GlEvalPoint24(void* ptr, int i, int j)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glEvalPoint2(i, j);
}
void QOpenGLFunctions_3_0_GlFeedbackBuffer4(void* ptr, int size, unsigned int ty, float buffer)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glFeedbackBuffer(size, ty, &buffer);
}
void QOpenGLFunctions_3_0_GlFinish4(void* ptr)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glFinish();
}
void QOpenGLFunctions_3_0_GlFlush4(void* ptr)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glFlush();
}
void QOpenGLFunctions_3_0_GlFogCoordPointer4(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glFogCoordPointer(ty, stride, pointer);
}
void QOpenGLFunctions_3_0_GlFogCoordf4(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glFogCoordf(coord);
}
void QOpenGLFunctions_3_0_GlFogCoordfv4(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glFogCoordfv(const_cast<const GLfloat*>(&coord));
}
void QOpenGLFunctions_3_0_GlFogf4(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glFogf(pname, param);
}
void QOpenGLFunctions_3_0_GlFogfv4(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glFogfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_0_GlFogi4(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glFogi(pname, param);
}
void QOpenGLFunctions_3_0_GlFogiv4(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glFogiv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_0_GlFramebufferRenderbuffer4(void* ptr, unsigned int target, unsigned int attachment, unsigned int renderbuffertarget, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
void QOpenGLFunctions_3_0_GlFramebufferTexture1D4(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glFramebufferTexture1D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_3_0_GlFramebufferTexture2D4(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_3_0_GlFramebufferTexture3D4(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level, int zoffset)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}
void QOpenGLFunctions_3_0_GlFramebufferTextureLayer4(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level, int layer)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glFramebufferTextureLayer(target, attachment, texture, level, layer);
}
void QOpenGLFunctions_3_0_GlFrontFace4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_3_0_GlGenBuffers4(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGenBuffers(n, &buffers);
}
void QOpenGLFunctions_3_0_GlGenFramebuffers4(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGenFramebuffers(n, &framebuffers);
}
void QOpenGLFunctions_3_0_GlGenQueries4(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGenQueries(n, &ids);
}
void QOpenGLFunctions_3_0_GlGenRenderbuffers4(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGenRenderbuffers(n, &renderbuffers);
}
void QOpenGLFunctions_3_0_GlGenTextures4(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_3_0_GlGenVertexArrays4(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGenVertexArrays(n, &arrays);
}
void QOpenGLFunctions_3_0_GlGenerateMipmap4(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGenerateMipmap(target);
}
void QOpenGLFunctions_3_0_GlGetAttachedShaders4(void* ptr, unsigned int program, int maxCount, int count, unsigned int obj)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetAttachedShaders(program, maxCount, &count, &obj);
}
void QOpenGLFunctions_3_0_GlGetBooleani_v4(void* ptr, unsigned int target, unsigned int index, char data)
{
Q_UNUSED(data);
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetBooleani_v(target, index, NULL);
}
void QOpenGLFunctions_3_0_GlGetBooleanv4(void* ptr, unsigned int pname, char params)
{
Q_UNUSED(params);
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_3_0_GlGetBufferParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetBufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetBufferPointerv4(void* ptr, unsigned int target, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetBufferPointerv(target, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetColorTable4(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetColorTable(target, format, ty, table);
}
void QOpenGLFunctions_3_0_GlGetColorTableParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetColorTableParameterfv(target, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetColorTableParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetColorTableParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetCompressedTexImage4(void* ptr, unsigned int target, int level, void* img)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetCompressedTexImage(target, level, img);
}
void QOpenGLFunctions_3_0_GlGetConvolutionFilter4(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetConvolutionFilter(target, format, ty, image);
}
void QOpenGLFunctions_3_0_GlGetConvolutionParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetConvolutionParameterfv(target, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetConvolutionParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetConvolutionParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetFloatv4(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetFloatv(pname, &params);
}
void QOpenGLFunctions_3_0_GlGetFramebufferAttachmentParameteriv4(void* ptr, unsigned int target, unsigned int attachment, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetFramebufferAttachmentParameteriv(target, attachment, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetHistogram4(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetHistogram(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_3_0_GlGetHistogramParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetHistogramParameterfv(target, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetHistogramParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetHistogramParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetIntegeri_v4(void* ptr, unsigned int target, unsigned int index, int data)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetIntegeri_v(target, index, &data);
}
void QOpenGLFunctions_3_0_GlGetIntegerv4(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetIntegerv(pname, &params);
}
void QOpenGLFunctions_3_0_GlGetLightfv4(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetLightfv(light, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetLightiv4(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetLightiv(light, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetMapfv4(void* ptr, unsigned int target, unsigned int query, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetMapfv(target, query, &v);
}
void QOpenGLFunctions_3_0_GlGetMapiv4(void* ptr, unsigned int target, unsigned int query, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetMapiv(target, query, &v);
}
void QOpenGLFunctions_3_0_GlGetMaterialfv4(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetMaterialfv(face, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetMaterialiv4(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetMaterialiv(face, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetMinmax4(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetMinmax(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_3_0_GlGetMinmaxParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetMinmaxParameterfv(target, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetMinmaxParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetMinmaxParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetPixelMapfv4(void* ptr, unsigned int m, float values)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetPixelMapfv(m, &values);
}
void QOpenGLFunctions_3_0_GlGetPixelMapuiv4(void* ptr, unsigned int m, unsigned int values)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetPixelMapuiv(m, &values);
}
void QOpenGLFunctions_3_0_GlGetPixelMapusv4(void* ptr, unsigned int m, unsigned short values)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetPixelMapusv(m, &values);
}
void QOpenGLFunctions_3_0_GlGetPointerv4(void* ptr, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetPointerv(pname, &params);
}
void QOpenGLFunctions_3_0_GlGetPolygonStipple4(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetPolygonStipple(static_cast<GLubyte*>(static_cast<void*>(mask)));
}
void QOpenGLFunctions_3_0_GlGetProgramiv4(void* ptr, unsigned int program, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetProgramiv(program, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetQueryObjectiv4(void* ptr, unsigned int id, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetQueryObjectiv(id, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetQueryObjectuiv4(void* ptr, unsigned int id, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetQueryObjectuiv(id, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetQueryiv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetQueryiv(target, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetRenderbufferParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetRenderbufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetSeparableFilter4(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* row, void* column, void* span)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetSeparableFilter(target, format, ty, row, column, span);
}
void QOpenGLFunctions_3_0_GlGetShaderiv4(void* ptr, unsigned int shader, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetShaderiv(shader, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetTexEnvfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetTexEnvfv(target, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetTexEnviv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetTexEnviv(target, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetTexGenfv4(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetTexGenfv(coord, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetTexGeniv4(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetTexGeniv(coord, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetTexImage4(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_3_0_GlGetTexLevelParameterfv4(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetTexLevelParameteriv4(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetTexParameterIiv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetTexParameterIiv(target, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetTexParameterIuiv4(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetTexParameterIuiv(target, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetTexParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetTexParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetUniformfv4(void* ptr, unsigned int program, int location, float params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetUniformfv(program, location, &params);
}
void QOpenGLFunctions_3_0_GlGetUniformiv4(void* ptr, unsigned int program, int location, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetUniformiv(program, location, &params);
}
void QOpenGLFunctions_3_0_GlGetUniformuiv4(void* ptr, unsigned int program, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetUniformuiv(program, location, &params);
}
void QOpenGLFunctions_3_0_GlGetVertexAttribIiv4(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetVertexAttribIiv(index, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetVertexAttribIuiv4(void* ptr, unsigned int index, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetVertexAttribIuiv(index, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetVertexAttribPointerv4(void* ptr, unsigned int index, unsigned int pname, void* pointer)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetVertexAttribPointerv(index, pname, &pointer);
}
void QOpenGLFunctions_3_0_GlGetVertexAttribfv4(void* ptr, unsigned int index, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetVertexAttribfv(index, pname, &params);
}
void QOpenGLFunctions_3_0_GlGetVertexAttribiv4(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glGetVertexAttribiv(index, pname, &params);
}
void QOpenGLFunctions_3_0_GlHint4(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_3_0_GlHistogram4(void* ptr, unsigned int target, int width, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glHistogram(target, width, internalformat, sink != 0);
}
void QOpenGLFunctions_3_0_GlIndexMask4(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glIndexMask(mask);
}
void QOpenGLFunctions_3_0_GlIndexPointer4(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glIndexPointer(ty, stride, pointer);
}
void QOpenGLFunctions_3_0_GlIndexf4(void* ptr, float c)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glIndexf(c);
}
void QOpenGLFunctions_3_0_GlIndexfv4(void* ptr, float c)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glIndexfv(const_cast<const GLfloat*>(&c));
}
void QOpenGLFunctions_3_0_GlIndexi4(void* ptr, int c)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glIndexi(c);
}
void QOpenGLFunctions_3_0_GlIndexiv4(void* ptr, int c)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glIndexiv(const_cast<const GLint*>(&c));
}
void QOpenGLFunctions_3_0_GlIndexs4(void* ptr, short c)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glIndexs(c);
}
void QOpenGLFunctions_3_0_GlIndexsv4(void* ptr, short c)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glIndexsv(const_cast<const GLshort*>(&c));
}
void QOpenGLFunctions_3_0_GlIndexub4(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glIndexub(*static_cast<GLubyte*>(static_cast<void*>(c)));
}
void QOpenGLFunctions_3_0_GlIndexubv4(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glIndexubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(c))));
}
void QOpenGLFunctions_3_0_GlInitNames4(void* ptr)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glInitNames();
}
void QOpenGLFunctions_3_0_GlInterleavedArrays4(void* ptr, unsigned int format, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glInterleavedArrays(format, stride, pointer);
}
void QOpenGLFunctions_3_0_GlLightModelf4(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glLightModelf(pname, param);
}
void QOpenGLFunctions_3_0_GlLightModelfv4(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glLightModelfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_0_GlLightModeli4(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glLightModeli(pname, param);
}
void QOpenGLFunctions_3_0_GlLightModeliv4(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glLightModeliv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_0_GlLightf4(void* ptr, unsigned int light, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glLightf(light, pname, param);
}
void QOpenGLFunctions_3_0_GlLightfv4(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glLightfv(light, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_0_GlLighti4(void* ptr, unsigned int light, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glLighti(light, pname, param);
}
void QOpenGLFunctions_3_0_GlLightiv4(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glLightiv(light, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_0_GlLineStipple4(void* ptr, int factor, unsigned short pattern)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glLineStipple(factor, pattern);
}
void QOpenGLFunctions_3_0_GlLineWidth4(void* ptr, float width)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_3_0_GlLinkProgram4(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glLinkProgram(program);
}
void QOpenGLFunctions_3_0_GlListBase4(void* ptr, unsigned int base)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glListBase(base);
}
void QOpenGLFunctions_3_0_GlLoadIdentity4(void* ptr)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glLoadIdentity();
}
void QOpenGLFunctions_3_0_GlLoadMatrixf4(void* ptr, float m)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glLoadMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_3_0_GlLoadName4(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glLoadName(name);
}
void QOpenGLFunctions_3_0_GlLoadTransposeMatrixf4(void* ptr, float m)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glLoadTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_3_0_GlLogicOp4(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_3_0_GlMap1f4(void* ptr, unsigned int target, float u1, float u2, int stride, int order, float points)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMap1f(target, u1, u2, stride, order, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_3_0_GlMap2f4(void* ptr, unsigned int target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float points)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_3_0_GlMapGrid1f4(void* ptr, int un, float u1, float u2)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMapGrid1f(un, u1, u2);
}
void QOpenGLFunctions_3_0_GlMapGrid2f4(void* ptr, int un, float u1, float u2, int vn, float v1, float v2)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMapGrid2f(un, u1, u2, vn, v1, v2);
}
void QOpenGLFunctions_3_0_GlMaterialf4(void* ptr, unsigned int face, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMaterialf(face, pname, param);
}
void QOpenGLFunctions_3_0_GlMaterialfv4(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMaterialfv(face, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_0_GlMateriali4(void* ptr, unsigned int face, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMateriali(face, pname, param);
}
void QOpenGLFunctions_3_0_GlMaterialiv4(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMaterialiv(face, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_0_GlMatrixMode4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMatrixMode(mode);
}
void QOpenGLFunctions_3_0_GlMinmax4(void* ptr, unsigned int target, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMinmax(target, internalformat, sink != 0);
}
void QOpenGLFunctions_3_0_GlMultMatrixf4(void* ptr, float m)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_3_0_GlMultTransposeMatrixf4(void* ptr, float m)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_3_0_GlMultiDrawArrays4(void* ptr, unsigned int mode, int first, int count, int drawcount)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiDrawArrays(mode, const_cast<const GLint*>(&first), const_cast<const GLsizei*>(&count), drawcount);
}
void QOpenGLFunctions_3_0_GlMultiTexCoord1f4(void* ptr, unsigned int target, float s)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiTexCoord1f(target, s);
}
void QOpenGLFunctions_3_0_GlMultiTexCoord1fv4(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiTexCoord1fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_0_GlMultiTexCoord1i4(void* ptr, unsigned int target, int s)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiTexCoord1i(target, s);
}
void QOpenGLFunctions_3_0_GlMultiTexCoord1iv4(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiTexCoord1iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlMultiTexCoord1s4(void* ptr, unsigned int target, short s)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiTexCoord1s(target, s);
}
void QOpenGLFunctions_3_0_GlMultiTexCoord1sv4(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiTexCoord1sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlMultiTexCoord2f4(void* ptr, unsigned int target, float s, float t)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiTexCoord2f(target, s, t);
}
void QOpenGLFunctions_3_0_GlMultiTexCoord2fv4(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiTexCoord2fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_0_GlMultiTexCoord2i4(void* ptr, unsigned int target, int s, int t)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiTexCoord2i(target, s, t);
}
void QOpenGLFunctions_3_0_GlMultiTexCoord2iv4(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiTexCoord2iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlMultiTexCoord2s4(void* ptr, unsigned int target, short s, short t)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiTexCoord2s(target, s, t);
}
void QOpenGLFunctions_3_0_GlMultiTexCoord2sv4(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiTexCoord2sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlMultiTexCoord3f4(void* ptr, unsigned int target, float s, float t, float r)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiTexCoord3f(target, s, t, r);
}
void QOpenGLFunctions_3_0_GlMultiTexCoord3fv4(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiTexCoord3fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_0_GlMultiTexCoord3i4(void* ptr, unsigned int target, int s, int t, int r)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiTexCoord3i(target, s, t, r);
}
void QOpenGLFunctions_3_0_GlMultiTexCoord3iv4(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiTexCoord3iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlMultiTexCoord3s4(void* ptr, unsigned int target, short s, short t, short r)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiTexCoord3s(target, s, t, r);
}
void QOpenGLFunctions_3_0_GlMultiTexCoord3sv4(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiTexCoord3sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlMultiTexCoord4f4(void* ptr, unsigned int target, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiTexCoord4f(target, s, t, r, q);
}
void QOpenGLFunctions_3_0_GlMultiTexCoord4fv4(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiTexCoord4fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_0_GlMultiTexCoord4i4(void* ptr, unsigned int target, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiTexCoord4i(target, s, t, r, q);
}
void QOpenGLFunctions_3_0_GlMultiTexCoord4iv4(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiTexCoord4iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlMultiTexCoord4s4(void* ptr, unsigned int target, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiTexCoord4s(target, s, t, r, q);
}
void QOpenGLFunctions_3_0_GlMultiTexCoord4sv4(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glMultiTexCoord4sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlNewList4(void* ptr, unsigned int list, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glNewList(list, mode);
}
void QOpenGLFunctions_3_0_GlNormal3f4(void* ptr, float nx, float ny, float nz)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glNormal3f(nx, ny, nz);
}
void QOpenGLFunctions_3_0_GlNormal3fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glNormal3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_0_GlNormal3i4(void* ptr, int nx, int ny, int nz)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glNormal3i(nx, ny, nz);
}
void QOpenGLFunctions_3_0_GlNormal3iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glNormal3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlNormal3s4(void* ptr, short nx, short ny, short nz)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glNormal3s(nx, ny, nz);
}
void QOpenGLFunctions_3_0_GlNormal3sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glNormal3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlNormalPointer4(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glNormalPointer(ty, stride, pointer);
}
void QOpenGLFunctions_3_0_GlPassThrough4(void* ptr, float token)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPassThrough(token);
}
void QOpenGLFunctions_3_0_GlPixelMapfv4(void* ptr, unsigned int m, int mapsize, float values)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPixelMapfv(m, mapsize, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_3_0_GlPixelMapuiv4(void* ptr, unsigned int m, int mapsize, unsigned int values)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPixelMapuiv(m, mapsize, const_cast<const GLuint*>(&values));
}
void QOpenGLFunctions_3_0_GlPixelMapusv4(void* ptr, unsigned int m, int mapsize, unsigned short values)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPixelMapusv(m, mapsize, const_cast<const GLushort*>(&values));
}
void QOpenGLFunctions_3_0_GlPixelStoref4(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_3_0_GlPixelStorei4(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_3_0_GlPixelTransferf4(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPixelTransferf(pname, param);
}
void QOpenGLFunctions_3_0_GlPixelTransferi4(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPixelTransferi(pname, param);
}
void QOpenGLFunctions_3_0_GlPixelZoom4(void* ptr, float xfactor, float yfactor)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPixelZoom(xfactor, yfactor);
}
void QOpenGLFunctions_3_0_GlPointParameterf4(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPointParameterf(pname, param);
}
void QOpenGLFunctions_3_0_GlPointParameterfv4(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPointParameterfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_0_GlPointParameteri4(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPointParameteri(pname, param);
}
void QOpenGLFunctions_3_0_GlPointParameteriv4(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPointParameteriv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_0_GlPointSize4(void* ptr, float size)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_3_0_GlPolygonMode4(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_3_0_GlPolygonOffset4(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_3_0_GlPolygonStipple4(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPolygonStipple(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(mask))));
}
void QOpenGLFunctions_3_0_GlPopAttrib4(void* ptr)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPopAttrib();
}
void QOpenGLFunctions_3_0_GlPopClientAttrib4(void* ptr)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPopClientAttrib();
}
void QOpenGLFunctions_3_0_GlPopMatrix4(void* ptr)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPopMatrix();
}
void QOpenGLFunctions_3_0_GlPopName4(void* ptr)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPopName();
}
void QOpenGLFunctions_3_0_GlPrioritizeTextures4(void* ptr, int n, unsigned int textures, float priorities)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPrioritizeTextures(n, const_cast<const GLuint*>(&textures), const_cast<const GLfloat*>(&priorities));
}
void QOpenGLFunctions_3_0_GlPushAttrib4(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPushAttrib(mask);
}
void QOpenGLFunctions_3_0_GlPushClientAttrib4(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPushClientAttrib(mask);
}
void QOpenGLFunctions_3_0_GlPushMatrix4(void* ptr)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPushMatrix();
}
void QOpenGLFunctions_3_0_GlPushName4(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glPushName(name);
}
void QOpenGLFunctions_3_0_GlRasterPos2f4(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRasterPos2f(x, y);
}
void QOpenGLFunctions_3_0_GlRasterPos2fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRasterPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_0_GlRasterPos2i4(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRasterPos2i(x, y);
}
void QOpenGLFunctions_3_0_GlRasterPos2iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRasterPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlRasterPos2s4(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRasterPos2s(x, y);
}
void QOpenGLFunctions_3_0_GlRasterPos2sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRasterPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlRasterPos3f4(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRasterPos3f(x, y, z);
}
void QOpenGLFunctions_3_0_GlRasterPos3fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRasterPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_0_GlRasterPos3i4(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRasterPos3i(x, y, z);
}
void QOpenGLFunctions_3_0_GlRasterPos3iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRasterPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlRasterPos3s4(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRasterPos3s(x, y, z);
}
void QOpenGLFunctions_3_0_GlRasterPos3sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRasterPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlRasterPos4f4(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRasterPos4f(x, y, z, w);
}
void QOpenGLFunctions_3_0_GlRasterPos4fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRasterPos4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_0_GlRasterPos4i4(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRasterPos4i(x, y, z, w);
}
void QOpenGLFunctions_3_0_GlRasterPos4iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRasterPos4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlRasterPos4s4(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRasterPos4s(x, y, z, w);
}
void QOpenGLFunctions_3_0_GlRasterPos4sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRasterPos4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlReadBuffer4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glReadBuffer(mode);
}
void QOpenGLFunctions_3_0_GlReadPixels4(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_3_0_GlRectf4(void* ptr, float x1, float y1, float x2, float y2)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRectf(x1, y1, x2, y2);
}
void QOpenGLFunctions_3_0_GlRectfv4(void* ptr, float v1, float v2)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRectfv(const_cast<const GLfloat*>(&v1), const_cast<const GLfloat*>(&v2));
}
void QOpenGLFunctions_3_0_GlRecti4(void* ptr, int x1, int y1, int x2, int y2)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRecti(x1, y1, x2, y2);
}
void QOpenGLFunctions_3_0_GlRectiv4(void* ptr, int v1, int v2)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRectiv(const_cast<const GLint*>(&v1), const_cast<const GLint*>(&v2));
}
void QOpenGLFunctions_3_0_GlRects4(void* ptr, short x1, short y1, short x2, short y2)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRects(x1, y1, x2, y2);
}
void QOpenGLFunctions_3_0_GlRectsv4(void* ptr, short v1, short v2)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRectsv(const_cast<const GLshort*>(&v1), const_cast<const GLshort*>(&v2));
}
void QOpenGLFunctions_3_0_GlRenderbufferStorage4(void* ptr, unsigned int target, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRenderbufferStorage(target, internalformat, width, height);
}
void QOpenGLFunctions_3_0_GlRenderbufferStorageMultisample4(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
}
void QOpenGLFunctions_3_0_GlResetHistogram4(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glResetHistogram(target);
}
void QOpenGLFunctions_3_0_GlResetMinmax4(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glResetMinmax(target);
}
void QOpenGLFunctions_3_0_GlRotatef4(void* ptr, float angle, float x, float y, float z)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glRotatef(angle, x, y, z);
}
void QOpenGLFunctions_3_0_GlSampleCoverage4(void* ptr, float value, char invert)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glSampleCoverage(value, invert != 0);
}
void QOpenGLFunctions_3_0_GlScalef4(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glScalef(x, y, z);
}
void QOpenGLFunctions_3_0_GlScissor4(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_3_0_GlSecondaryColor3f4(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glSecondaryColor3f(red, green, blue);
}
void QOpenGLFunctions_3_0_GlSecondaryColor3fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glSecondaryColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_0_GlSecondaryColor3i4(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glSecondaryColor3i(red, green, blue);
}
void QOpenGLFunctions_3_0_GlSecondaryColor3iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glSecondaryColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlSecondaryColor3s4(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glSecondaryColor3s(red, green, blue);
}
void QOpenGLFunctions_3_0_GlSecondaryColor3sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glSecondaryColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlSecondaryColor3ub4(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glSecondaryColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_3_0_GlSecondaryColor3ubv4(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glSecondaryColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_3_0_GlSecondaryColor3ui4(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glSecondaryColor3ui(red, green, blue);
}
void QOpenGLFunctions_3_0_GlSecondaryColor3uiv4(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glSecondaryColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_0_GlSecondaryColor3us4(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glSecondaryColor3us(red, green, blue);
}
void QOpenGLFunctions_3_0_GlSecondaryColor3usv4(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glSecondaryColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_3_0_GlSecondaryColorPointer4(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glSecondaryColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_3_0_GlSelectBuffer4(void* ptr, int size, unsigned int buffer)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glSelectBuffer(size, &buffer);
}
void QOpenGLFunctions_3_0_GlSeparableFilter2D4(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* row, void* column)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glSeparableFilter2D(target, internalformat, width, height, format, ty, row, column);
}
void QOpenGLFunctions_3_0_GlShadeModel4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glShadeModel(mode);
}
void QOpenGLFunctions_3_0_GlStencilFunc4(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_3_0_GlStencilFuncSeparate4(void* ptr, unsigned int face, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glStencilFuncSeparate(face, fu, ref, mask);
}
void QOpenGLFunctions_3_0_GlStencilMask4(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_3_0_GlStencilMaskSeparate4(void* ptr, unsigned int face, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glStencilMaskSeparate(face, mask);
}
void QOpenGLFunctions_3_0_GlStencilOp4(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_3_0_GlStencilOpSeparate4(void* ptr, unsigned int face, unsigned int sfail, unsigned int dpfail, unsigned int dppass)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glStencilOpSeparate(face, sfail, dpfail, dppass);
}
void QOpenGLFunctions_3_0_GlTexCoord1f4(void* ptr, float s)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoord1f(s);
}
void QOpenGLFunctions_3_0_GlTexCoord1fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoord1fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_0_GlTexCoord1i4(void* ptr, int s)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoord1i(s);
}
void QOpenGLFunctions_3_0_GlTexCoord1iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoord1iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlTexCoord1s4(void* ptr, short s)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoord1s(s);
}
void QOpenGLFunctions_3_0_GlTexCoord1sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoord1sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlTexCoord2f4(void* ptr, float s, float t)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoord2f(s, t);
}
void QOpenGLFunctions_3_0_GlTexCoord2fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoord2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_0_GlTexCoord2i4(void* ptr, int s, int t)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoord2i(s, t);
}
void QOpenGLFunctions_3_0_GlTexCoord2iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoord2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlTexCoord2s4(void* ptr, short s, short t)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoord2s(s, t);
}
void QOpenGLFunctions_3_0_GlTexCoord2sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoord2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlTexCoord3f4(void* ptr, float s, float t, float r)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoord3f(s, t, r);
}
void QOpenGLFunctions_3_0_GlTexCoord3fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoord3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_0_GlTexCoord3i4(void* ptr, int s, int t, int r)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoord3i(s, t, r);
}
void QOpenGLFunctions_3_0_GlTexCoord3iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoord3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlTexCoord3s4(void* ptr, short s, short t, short r)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoord3s(s, t, r);
}
void QOpenGLFunctions_3_0_GlTexCoord3sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoord3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlTexCoord4f4(void* ptr, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoord4f(s, t, r, q);
}
void QOpenGLFunctions_3_0_GlTexCoord4fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoord4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_0_GlTexCoord4i4(void* ptr, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoord4i(s, t, r, q);
}
void QOpenGLFunctions_3_0_GlTexCoord4iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoord4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlTexCoord4s4(void* ptr, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoord4s(s, t, r, q);
}
void QOpenGLFunctions_3_0_GlTexCoord4sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoord4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlTexCoordPointer4(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexCoordPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_3_0_GlTexEnvf4(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexEnvf(target, pname, param);
}
void QOpenGLFunctions_3_0_GlTexEnvfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexEnvfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_0_GlTexEnvi4(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexEnvi(target, pname, param);
}
void QOpenGLFunctions_3_0_GlTexEnviv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexEnviv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_0_GlTexGenf4(void* ptr, unsigned int coord, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexGenf(coord, pname, param);
}
void QOpenGLFunctions_3_0_GlTexGenfv4(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexGenfv(coord, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_0_GlTexGeni4(void* ptr, unsigned int coord, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexGeni(coord, pname, param);
}
void QOpenGLFunctions_3_0_GlTexGeniv4(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexGeniv(coord, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_0_GlTexImage1D4(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_3_0_GlTexImage2D4(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_3_0_GlTexImage3D4(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLFunctions_3_0_GlTexParameterIiv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexParameterIiv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_0_GlTexParameterIuiv4(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexParameterIuiv(target, pname, const_cast<const GLuint*>(&params));
}
void QOpenGLFunctions_3_0_GlTexParameterf4(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_3_0_GlTexParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_0_GlTexParameteri4(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_3_0_GlTexParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_0_GlTexSubImage1D4(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_3_0_GlTexSubImage2D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_3_0_GlTexSubImage3D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_3_0_GlTranslatef4(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glTranslatef(x, y, z);
}
void QOpenGLFunctions_3_0_GlUniform1f4(void* ptr, int location, float v0)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniform1f(location, v0);
}
void QOpenGLFunctions_3_0_GlUniform1fv4(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniform1fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_0_GlUniform1i4(void* ptr, int location, int v0)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniform1i(location, v0);
}
void QOpenGLFunctions_3_0_GlUniform1iv4(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniform1iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_0_GlUniform1ui4(void* ptr, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniform1ui(location, v0);
}
void QOpenGLFunctions_3_0_GlUniform1uiv4(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniform1uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_0_GlUniform2f4(void* ptr, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniform2f(location, v0, v1);
}
void QOpenGLFunctions_3_0_GlUniform2fv4(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniform2fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_0_GlUniform2i4(void* ptr, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniform2i(location, v0, v1);
}
void QOpenGLFunctions_3_0_GlUniform2iv4(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniform2iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_0_GlUniform2ui4(void* ptr, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniform2ui(location, v0, v1);
}
void QOpenGLFunctions_3_0_GlUniform2uiv4(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniform2uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_0_GlUniform3f4(void* ptr, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniform3f(location, v0, v1, v2);
}
void QOpenGLFunctions_3_0_GlUniform3fv4(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniform3fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_0_GlUniform3i4(void* ptr, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniform3i(location, v0, v1, v2);
}
void QOpenGLFunctions_3_0_GlUniform3iv4(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniform3iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_0_GlUniform3ui4(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniform3ui(location, v0, v1, v2);
}
void QOpenGLFunctions_3_0_GlUniform3uiv4(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniform3uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_0_GlUniform4f4(void* ptr, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniform4f(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_3_0_GlUniform4fv4(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniform4fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_0_GlUniform4i4(void* ptr, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniform4i(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_3_0_GlUniform4iv4(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniform4iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_0_GlUniform4ui4(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniform4ui(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_3_0_GlUniform4uiv4(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniform4uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_0_GlUniformMatrix2fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniformMatrix2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_0_GlUniformMatrix2x3fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniformMatrix2x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_0_GlUniformMatrix2x4fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniformMatrix2x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_0_GlUniformMatrix3fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniformMatrix3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_0_GlUniformMatrix3x2fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniformMatrix3x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_0_GlUniformMatrix3x4fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniformMatrix3x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_0_GlUniformMatrix4fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniformMatrix4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_0_GlUniformMatrix4x2fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniformMatrix4x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_0_GlUniformMatrix4x3fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUniformMatrix4x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_0_GlUseProgram4(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glUseProgram(program);
}
void QOpenGLFunctions_3_0_GlValidateProgram4(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glValidateProgram(program);
}
void QOpenGLFunctions_3_0_GlVertex2f4(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertex2f(x, y);
}
void QOpenGLFunctions_3_0_GlVertex2fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertex2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_0_GlVertex2i4(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertex2i(x, y);
}
void QOpenGLFunctions_3_0_GlVertex2iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertex2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlVertex2s4(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertex2s(x, y);
}
void QOpenGLFunctions_3_0_GlVertex2sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertex2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlVertex3f4(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertex3f(x, y, z);
}
void QOpenGLFunctions_3_0_GlVertex3fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertex3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_0_GlVertex3i4(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertex3i(x, y, z);
}
void QOpenGLFunctions_3_0_GlVertex3iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertex3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlVertex3s4(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertex3s(x, y, z);
}
void QOpenGLFunctions_3_0_GlVertex3sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertex3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlVertex4f4(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertex4f(x, y, z, w);
}
void QOpenGLFunctions_3_0_GlVertex4fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertex4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_0_GlVertex4i4(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertex4i(x, y, z, w);
}
void QOpenGLFunctions_3_0_GlVertex4iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertex4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlVertex4s4(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertex4s(x, y, z, w);
}
void QOpenGLFunctions_3_0_GlVertex4sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertex4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttrib1f4(void* ptr, unsigned int index, float x)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib1f(index, x);
}
void QOpenGLFunctions_3_0_GlVertexAttrib1fv4(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib1fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttrib1s4(void* ptr, unsigned int index, short x)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib1s(index, x);
}
void QOpenGLFunctions_3_0_GlVertexAttrib1sv4(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib1sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttrib2f4(void* ptr, unsigned int index, float x, float y)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib2f(index, x, y);
}
void QOpenGLFunctions_3_0_GlVertexAttrib2fv4(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib2fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttrib2s4(void* ptr, unsigned int index, short x, short y)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib2s(index, x, y);
}
void QOpenGLFunctions_3_0_GlVertexAttrib2sv4(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib2sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttrib3f4(void* ptr, unsigned int index, float x, float y, float z)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib3f(index, x, y, z);
}
void QOpenGLFunctions_3_0_GlVertexAttrib3fv4(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib3fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttrib3s4(void* ptr, unsigned int index, short x, short y, short z)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib3s(index, x, y, z);
}
void QOpenGLFunctions_3_0_GlVertexAttrib3sv4(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib3sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttrib4Niv4(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib4Niv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttrib4Nsv4(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib4Nsv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttrib4Nub4(void* ptr, unsigned int index, char* x, char* y, char* z, char* w)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib4Nub(index, *static_cast<GLubyte*>(static_cast<void*>(x)), *static_cast<GLubyte*>(static_cast<void*>(y)), *static_cast<GLubyte*>(static_cast<void*>(z)), *static_cast<GLubyte*>(static_cast<void*>(w)));
}
void QOpenGLFunctions_3_0_GlVertexAttrib4Nubv4(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib4Nubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_3_0_GlVertexAttrib4Nuiv4(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib4Nuiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttrib4Nusv4(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib4Nusv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttrib4f4(void* ptr, unsigned int index, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib4f(index, x, y, z, w);
}
void QOpenGLFunctions_3_0_GlVertexAttrib4fv4(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib4fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttrib4iv4(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttrib4s4(void* ptr, unsigned int index, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib4s(index, x, y, z, w);
}
void QOpenGLFunctions_3_0_GlVertexAttrib4sv4(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib4sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttrib4ubv4(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib4ubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_3_0_GlVertexAttrib4uiv4(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttrib4usv4(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttrib4usv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttribI1i4(void* ptr, unsigned int index, int x)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttribI1i(index, x);
}
void QOpenGLFunctions_3_0_GlVertexAttribI1iv4(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttribI1iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttribI1ui4(void* ptr, unsigned int index, unsigned int x)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttribI1ui(index, x);
}
void QOpenGLFunctions_3_0_GlVertexAttribI1uiv4(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttribI1uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttribI2i4(void* ptr, unsigned int index, int x, int y)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttribI2i(index, x, y);
}
void QOpenGLFunctions_3_0_GlVertexAttribI2iv4(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttribI2iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttribI2ui4(void* ptr, unsigned int index, unsigned int x, unsigned int y)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttribI2ui(index, x, y);
}
void QOpenGLFunctions_3_0_GlVertexAttribI2uiv4(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttribI2uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttribI3i4(void* ptr, unsigned int index, int x, int y, int z)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttribI3i(index, x, y, z);
}
void QOpenGLFunctions_3_0_GlVertexAttribI3iv4(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttribI3iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttribI3ui4(void* ptr, unsigned int index, unsigned int x, unsigned int y, unsigned int z)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttribI3ui(index, x, y, z);
}
void QOpenGLFunctions_3_0_GlVertexAttribI3uiv4(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttribI3uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttribI4i4(void* ptr, unsigned int index, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttribI4i(index, x, y, z, w);
}
void QOpenGLFunctions_3_0_GlVertexAttribI4iv4(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttribI4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttribI4sv4(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttribI4sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttribI4ubv4(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttribI4ubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_3_0_GlVertexAttribI4ui4(void* ptr, unsigned int index, unsigned int x, unsigned int y, unsigned int z, unsigned int w)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttribI4ui(index, x, y, z, w);
}
void QOpenGLFunctions_3_0_GlVertexAttribI4uiv4(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttribI4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttribI4usv4(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttribI4usv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_3_0_GlVertexAttribIPointer4(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttribIPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_3_0_GlVertexAttribPointer4(void* ptr, unsigned int index, int size, unsigned int ty, char normalized, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexAttribPointer(index, size, ty, normalized != 0, stride, pointer);
}
void QOpenGLFunctions_3_0_GlVertexPointer4(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glVertexPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_3_0_GlViewport4(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_3_0_GlWindowPos2f4(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glWindowPos2f(x, y);
}
void QOpenGLFunctions_3_0_GlWindowPos2fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glWindowPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_0_GlWindowPos2i4(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glWindowPos2i(x, y);
}
void QOpenGLFunctions_3_0_GlWindowPos2iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glWindowPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlWindowPos2s4(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glWindowPos2s(x, y);
}
void QOpenGLFunctions_3_0_GlWindowPos2sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glWindowPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_GlWindowPos3f4(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glWindowPos3f(x, y, z);
}
void QOpenGLFunctions_3_0_GlWindowPos3fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glWindowPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_0_GlWindowPos3i4(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glWindowPos3i(x, y, z);
}
void QOpenGLFunctions_3_0_GlWindowPos3iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glWindowPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_0_GlWindowPos3s4(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glWindowPos3s(x, y, z);
}
void QOpenGLFunctions_3_0_GlWindowPos3sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->glWindowPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_0_DestroyQOpenGLFunctions_3_04(void* ptr)
{
static_cast<QOpenGLFunctions_3_0*>(ptr)->~QOpenGLFunctions_3_0();
}
void QOpenGLFunctions_3_0_DestroyQOpenGLFunctions_3_04Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_3_1: public QOpenGLFunctions_3_1
{
public:
MyQOpenGLFunctions_3_1() : QOpenGLFunctions_3_1() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_3_1_InitializeOpenGLFunctions4(this) != 0; };
~MyQOpenGLFunctions_3_1() { callbackQOpenGLFunctions_3_1_DestroyQOpenGLFunctions_3_14(this); };
};
char QOpenGLFunctions_3_1_GlIsBuffer4(void* ptr, unsigned int buffer)
{
return static_cast<QOpenGLFunctions_3_1*>(ptr)->glIsBuffer(buffer);
}
char QOpenGLFunctions_3_1_GlIsEnabled4(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_3_1*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_3_1_GlIsEnabledi4(void* ptr, unsigned int target, unsigned int index)
{
return static_cast<QOpenGLFunctions_3_1*>(ptr)->glIsEnabledi(target, index);
}
char QOpenGLFunctions_3_1_GlIsFramebuffer4(void* ptr, unsigned int framebuffer)
{
return static_cast<QOpenGLFunctions_3_1*>(ptr)->glIsFramebuffer(framebuffer);
}
char QOpenGLFunctions_3_1_GlIsProgram4(void* ptr, unsigned int program)
{
return static_cast<QOpenGLFunctions_3_1*>(ptr)->glIsProgram(program);
}
char QOpenGLFunctions_3_1_GlIsQuery4(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_3_1*>(ptr)->glIsQuery(id);
}
char QOpenGLFunctions_3_1_GlIsRenderbuffer4(void* ptr, unsigned int renderbuffer)
{
return static_cast<QOpenGLFunctions_3_1*>(ptr)->glIsRenderbuffer(renderbuffer);
}
char QOpenGLFunctions_3_1_GlIsShader4(void* ptr, unsigned int shader)
{
return static_cast<QOpenGLFunctions_3_1*>(ptr)->glIsShader(shader);
}
char QOpenGLFunctions_3_1_GlIsTexture4(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_3_1*>(ptr)->glIsTexture(texture);
}
char QOpenGLFunctions_3_1_GlIsVertexArray4(void* ptr, unsigned int array)
{
return static_cast<QOpenGLFunctions_3_1*>(ptr)->glIsVertexArray(array);
}
char QOpenGLFunctions_3_1_GlUnmapBuffer4(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_3_1*>(ptr)->glUnmapBuffer(target);
}
unsigned int QOpenGLFunctions_3_1_GlCheckFramebufferStatus4(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_3_1*>(ptr)->glCheckFramebufferStatus(target);
}
unsigned int QOpenGLFunctions_3_1_GlGetError4(void* ptr)
{
return static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetError();
}
unsigned int QOpenGLFunctions_3_1_GlCreateProgram4(void* ptr)
{
return static_cast<QOpenGLFunctions_3_1*>(ptr)->glCreateProgram();
}
unsigned int QOpenGLFunctions_3_1_GlCreateShader4(void* ptr, unsigned int ty)
{
return static_cast<QOpenGLFunctions_3_1*>(ptr)->glCreateShader(ty);
}
void* QOpenGLFunctions_3_1_GlMapBuffer4(void* ptr, unsigned int target, unsigned int access)
{
return static_cast<QOpenGLFunctions_3_1*>(ptr)->glMapBuffer(target, access);
}
void* QOpenGLFunctions_3_1_NewQOpenGLFunctions_3_14()
{
return new MyQOpenGLFunctions_3_1();
}
char QOpenGLFunctions_3_1_InitializeOpenGLFunctions4(void* ptr)
{
return static_cast<QOpenGLFunctions_3_1*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_3_1_InitializeOpenGLFunctions4Default(void* ptr)
{
return static_cast<QOpenGLFunctions_3_1*>(ptr)->QOpenGLFunctions_3_1::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_3_1_GlGetString4(void* ptr, unsigned int name)
{
return ({ char* td98617 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetString(name)))); QtGui_PackedString { td98617, -1 }; });
}
struct QtGui_PackedString QOpenGLFunctions_3_1_GlGetStringi4(void* ptr, unsigned int name, unsigned int index)
{
return ({ char* tf561f1 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetStringi(name, index)))); QtGui_PackedString { tf561f1, -1 }; });
}
void QOpenGLFunctions_3_1_GlActiveTexture4(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glActiveTexture(texture);
}
void QOpenGLFunctions_3_1_GlAttachShader4(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glAttachShader(program, shader);
}
void QOpenGLFunctions_3_1_GlBeginConditionalRender4(void* ptr, unsigned int id, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glBeginConditionalRender(id, mode);
}
void QOpenGLFunctions_3_1_GlBeginQuery4(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glBeginQuery(target, id);
}
void QOpenGLFunctions_3_1_GlBeginTransformFeedback4(void* ptr, unsigned int primitiveMode)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glBeginTransformFeedback(primitiveMode);
}
void QOpenGLFunctions_3_1_GlBindBuffer4(void* ptr, unsigned int target, unsigned int buffer)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glBindBuffer(target, buffer);
}
void QOpenGLFunctions_3_1_GlBindBufferBase4(void* ptr, unsigned int target, unsigned int index, unsigned int buffer)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glBindBufferBase(target, index, buffer);
}
void QOpenGLFunctions_3_1_GlBindFramebuffer4(void* ptr, unsigned int target, unsigned int framebuffer)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glBindFramebuffer(target, framebuffer);
}
void QOpenGLFunctions_3_1_GlBindRenderbuffer4(void* ptr, unsigned int target, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glBindRenderbuffer(target, renderbuffer);
}
void QOpenGLFunctions_3_1_GlBindTexture4(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_3_1_GlBindVertexArray4(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glBindVertexArray(array);
}
void QOpenGLFunctions_3_1_GlBlendColor4(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_3_1_GlBlendEquation4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_3_1_GlBlendEquationSeparate4(void* ptr, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glBlendEquationSeparate(modeRGB, modeAlpha);
}
void QOpenGLFunctions_3_1_GlBlendFunc4(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_3_1_GlBlendFuncSeparate4(void* ptr, unsigned int sfactorRGB, unsigned int dfactorRGB, unsigned int sfactorAlpha, unsigned int dfactorAlpha)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void QOpenGLFunctions_3_1_GlBlitFramebuffer4(void* ptr, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, unsigned int mask, unsigned int filter)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
void QOpenGLFunctions_3_1_GlClampColor4(void* ptr, unsigned int target, unsigned int clamp)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glClampColor(target, clamp);
}
void QOpenGLFunctions_3_1_GlClear4(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_3_1_GlClearBufferfi4(void* ptr, unsigned int buffer, int drawbuffer, float depth, int stencil)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glClearBufferfi(buffer, drawbuffer, depth, stencil);
}
void QOpenGLFunctions_3_1_GlClearBufferfv4(void* ptr, unsigned int buffer, int drawbuffer, float value)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glClearBufferfv(buffer, drawbuffer, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_1_GlClearBufferiv4(void* ptr, unsigned int buffer, int drawbuffer, int value)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glClearBufferiv(buffer, drawbuffer, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_1_GlClearBufferuiv4(void* ptr, unsigned int buffer, int drawbuffer, unsigned int value)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glClearBufferuiv(buffer, drawbuffer, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_1_GlClearColor4(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_3_1_GlClearStencil4(void* ptr, int s)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_3_1_GlColorMask4(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_3_1_GlColorMaski4(void* ptr, unsigned int index, char r, char g, char b, char a)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glColorMaski(index, r != 0, g != 0, b != 0, a != 0);
}
void QOpenGLFunctions_3_1_GlCompileShader4(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glCompileShader(shader);
}
void QOpenGLFunctions_3_1_GlCompressedTexImage1D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
void QOpenGLFunctions_3_1_GlCompressedTexImage2D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void QOpenGLFunctions_3_1_GlCompressedTexImage3D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int depth, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void QOpenGLFunctions_3_1_GlCompressedTexSubImage1D4(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_3_1_GlCompressedTexSubImage2D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_3_1_GlCompressedTexSubImage3D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_3_1_GlCopyTexImage1D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_3_1_GlCopyTexImage2D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_3_1_GlCopyTexSubImage1D4(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_3_1_GlCopyTexSubImage2D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_3_1_GlCopyTexSubImage3D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_3_1_GlCullFace4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_3_1_GlDeleteBuffers4(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glDeleteBuffers(n, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_3_1_GlDeleteFramebuffers4(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glDeleteFramebuffers(n, const_cast<const GLuint*>(&framebuffers));
}
void QOpenGLFunctions_3_1_GlDeleteProgram4(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glDeleteProgram(program);
}
void QOpenGLFunctions_3_1_GlDeleteQueries4(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glDeleteQueries(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_3_1_GlDeleteRenderbuffers4(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glDeleteRenderbuffers(n, const_cast<const GLuint*>(&renderbuffers));
}
void QOpenGLFunctions_3_1_GlDeleteShader4(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glDeleteShader(shader);
}
void QOpenGLFunctions_3_1_GlDeleteTextures4(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_3_1_GlDeleteVertexArrays4(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glDeleteVertexArrays(n, const_cast<const GLuint*>(&arrays));
}
void QOpenGLFunctions_3_1_GlDepthFunc4(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_3_1_GlDepthMask4(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_3_1_GlDetachShader4(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glDetachShader(program, shader);
}
void QOpenGLFunctions_3_1_GlDisable4(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_3_1_GlDisableVertexAttribArray4(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glDisableVertexAttribArray(index);
}
void QOpenGLFunctions_3_1_GlDisablei4(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glDisablei(target, index);
}
void QOpenGLFunctions_3_1_GlDrawArrays4(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_3_1_GlDrawArraysInstanced4(void* ptr, unsigned int mode, int first, int count, int instancecount)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glDrawArraysInstanced(mode, first, count, instancecount);
}
void QOpenGLFunctions_3_1_GlDrawBuffer4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glDrawBuffer(mode);
}
void QOpenGLFunctions_3_1_GlDrawBuffers4(void* ptr, int n, unsigned int bufs)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glDrawBuffers(n, const_cast<const GLenum*>(&bufs));
}
void QOpenGLFunctions_3_1_GlDrawElements4(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_3_1_GlDrawElementsInstanced4(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glDrawElementsInstanced(mode, count, ty, indices, instancecount);
}
void QOpenGLFunctions_3_1_GlDrawRangeElements4(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLFunctions_3_1_GlEnable4(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_3_1_GlEnableVertexAttribArray4(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glEnableVertexAttribArray(index);
}
void QOpenGLFunctions_3_1_GlEnablei4(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glEnablei(target, index);
}
void QOpenGLFunctions_3_1_GlEndConditionalRender4(void* ptr)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glEndConditionalRender();
}
void QOpenGLFunctions_3_1_GlEndQuery4(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glEndQuery(target);
}
void QOpenGLFunctions_3_1_GlEndTransformFeedback4(void* ptr)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glEndTransformFeedback();
}
void QOpenGLFunctions_3_1_GlFinish4(void* ptr)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glFinish();
}
void QOpenGLFunctions_3_1_GlFlush4(void* ptr)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glFlush();
}
void QOpenGLFunctions_3_1_GlFramebufferRenderbuffer4(void* ptr, unsigned int target, unsigned int attachment, unsigned int renderbuffertarget, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
void QOpenGLFunctions_3_1_GlFramebufferTexture1D4(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glFramebufferTexture1D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_3_1_GlFramebufferTexture2D4(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_3_1_GlFramebufferTexture3D4(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level, int zoffset)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}
void QOpenGLFunctions_3_1_GlFramebufferTextureLayer4(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level, int layer)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glFramebufferTextureLayer(target, attachment, texture, level, layer);
}
void QOpenGLFunctions_3_1_GlFrontFace4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_3_1_GlGenBuffers4(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGenBuffers(n, &buffers);
}
void QOpenGLFunctions_3_1_GlGenFramebuffers4(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGenFramebuffers(n, &framebuffers);
}
void QOpenGLFunctions_3_1_GlGenQueries4(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGenQueries(n, &ids);
}
void QOpenGLFunctions_3_1_GlGenRenderbuffers4(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGenRenderbuffers(n, &renderbuffers);
}
void QOpenGLFunctions_3_1_GlGenTextures4(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_3_1_GlGenVertexArrays4(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGenVertexArrays(n, &arrays);
}
void QOpenGLFunctions_3_1_GlGenerateMipmap4(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGenerateMipmap(target);
}
void QOpenGLFunctions_3_1_GlGetActiveUniformBlockiv4(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, &params);
}
void QOpenGLFunctions_3_1_GlGetActiveUniformsiv4(void* ptr, unsigned int program, int uniformCount, unsigned int uniformIndices, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetActiveUniformsiv(program, uniformCount, const_cast<const GLuint*>(&uniformIndices), pname, &params);
}
void QOpenGLFunctions_3_1_GlGetAttachedShaders4(void* ptr, unsigned int program, int maxCount, int count, unsigned int obj)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetAttachedShaders(program, maxCount, &count, &obj);
}
void QOpenGLFunctions_3_1_GlGetBooleani_v4(void* ptr, unsigned int target, unsigned int index, char data)
{
Q_UNUSED(data);
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetBooleani_v(target, index, NULL);
}
void QOpenGLFunctions_3_1_GlGetBooleanv4(void* ptr, unsigned int pname, char params)
{
Q_UNUSED(params);
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_3_1_GlGetBufferParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetBufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_1_GlGetBufferPointerv4(void* ptr, unsigned int target, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetBufferPointerv(target, pname, &params);
}
void QOpenGLFunctions_3_1_GlGetCompressedTexImage4(void* ptr, unsigned int target, int level, void* img)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetCompressedTexImage(target, level, img);
}
void QOpenGLFunctions_3_1_GlGetFloatv4(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetFloatv(pname, &params);
}
void QOpenGLFunctions_3_1_GlGetFramebufferAttachmentParameteriv4(void* ptr, unsigned int target, unsigned int attachment, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetFramebufferAttachmentParameteriv(target, attachment, pname, &params);
}
void QOpenGLFunctions_3_1_GlGetIntegeri_v4(void* ptr, unsigned int target, unsigned int index, int data)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetIntegeri_v(target, index, &data);
}
void QOpenGLFunctions_3_1_GlGetIntegerv4(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetIntegerv(pname, &params);
}
void QOpenGLFunctions_3_1_GlGetPointerv4(void* ptr, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetPointerv(pname, &params);
}
void QOpenGLFunctions_3_1_GlGetProgramiv4(void* ptr, unsigned int program, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetProgramiv(program, pname, &params);
}
void QOpenGLFunctions_3_1_GlGetQueryObjectiv4(void* ptr, unsigned int id, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetQueryObjectiv(id, pname, &params);
}
void QOpenGLFunctions_3_1_GlGetQueryObjectuiv4(void* ptr, unsigned int id, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetQueryObjectuiv(id, pname, &params);
}
void QOpenGLFunctions_3_1_GlGetQueryiv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetQueryiv(target, pname, &params);
}
void QOpenGLFunctions_3_1_GlGetRenderbufferParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetRenderbufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_1_GlGetShaderiv4(void* ptr, unsigned int shader, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetShaderiv(shader, pname, &params);
}
void QOpenGLFunctions_3_1_GlGetTexImage4(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_3_1_GlGetTexLevelParameterfv4(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_3_1_GlGetTexLevelParameteriv4(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_3_1_GlGetTexParameterIiv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetTexParameterIiv(target, pname, &params);
}
void QOpenGLFunctions_3_1_GlGetTexParameterIuiv4(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetTexParameterIuiv(target, pname, &params);
}
void QOpenGLFunctions_3_1_GlGetTexParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_3_1_GlGetTexParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_1_GlGetUniformfv4(void* ptr, unsigned int program, int location, float params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetUniformfv(program, location, &params);
}
void QOpenGLFunctions_3_1_GlGetUniformiv4(void* ptr, unsigned int program, int location, int params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetUniformiv(program, location, &params);
}
void QOpenGLFunctions_3_1_GlGetUniformuiv4(void* ptr, unsigned int program, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetUniformuiv(program, location, &params);
}
void QOpenGLFunctions_3_1_GlGetVertexAttribIiv4(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetVertexAttribIiv(index, pname, &params);
}
void QOpenGLFunctions_3_1_GlGetVertexAttribIuiv4(void* ptr, unsigned int index, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetVertexAttribIuiv(index, pname, &params);
}
void QOpenGLFunctions_3_1_GlGetVertexAttribPointerv4(void* ptr, unsigned int index, unsigned int pname, void* pointer)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetVertexAttribPointerv(index, pname, &pointer);
}
void QOpenGLFunctions_3_1_GlGetVertexAttribfv4(void* ptr, unsigned int index, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetVertexAttribfv(index, pname, &params);
}
void QOpenGLFunctions_3_1_GlGetVertexAttribiv4(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glGetVertexAttribiv(index, pname, &params);
}
void QOpenGLFunctions_3_1_GlHint4(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_3_1_GlIndexub4(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glIndexub(*static_cast<GLubyte*>(static_cast<void*>(c)));
}
void QOpenGLFunctions_3_1_GlIndexubv4(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glIndexubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(c))));
}
void QOpenGLFunctions_3_1_GlLineWidth4(void* ptr, float width)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_3_1_GlLinkProgram4(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glLinkProgram(program);
}
void QOpenGLFunctions_3_1_GlLogicOp4(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_3_1_GlMultiDrawArrays4(void* ptr, unsigned int mode, int first, int count, int drawcount)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glMultiDrawArrays(mode, const_cast<const GLint*>(&first), const_cast<const GLsizei*>(&count), drawcount);
}
void QOpenGLFunctions_3_1_GlPixelStoref4(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_3_1_GlPixelStorei4(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_3_1_GlPointParameterf4(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glPointParameterf(pname, param);
}
void QOpenGLFunctions_3_1_GlPointParameterfv4(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glPointParameterfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_1_GlPointParameteri4(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glPointParameteri(pname, param);
}
void QOpenGLFunctions_3_1_GlPointParameteriv4(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glPointParameteriv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_1_GlPointSize4(void* ptr, float size)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_3_1_GlPolygonMode4(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_3_1_GlPolygonOffset4(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_3_1_GlPrimitiveRestartIndex4(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glPrimitiveRestartIndex(index);
}
void QOpenGLFunctions_3_1_GlReadBuffer4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glReadBuffer(mode);
}
void QOpenGLFunctions_3_1_GlReadPixels4(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_3_1_GlRenderbufferStorage4(void* ptr, unsigned int target, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glRenderbufferStorage(target, internalformat, width, height);
}
void QOpenGLFunctions_3_1_GlRenderbufferStorageMultisample4(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
}
void QOpenGLFunctions_3_1_GlSampleCoverage4(void* ptr, float value, char invert)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glSampleCoverage(value, invert != 0);
}
void QOpenGLFunctions_3_1_GlScissor4(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_3_1_GlStencilFunc4(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_3_1_GlStencilFuncSeparate4(void* ptr, unsigned int face, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glStencilFuncSeparate(face, fu, ref, mask);
}
void QOpenGLFunctions_3_1_GlStencilMask4(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_3_1_GlStencilMaskSeparate4(void* ptr, unsigned int face, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glStencilMaskSeparate(face, mask);
}
void QOpenGLFunctions_3_1_GlStencilOp4(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_3_1_GlStencilOpSeparate4(void* ptr, unsigned int face, unsigned int sfail, unsigned int dpfail, unsigned int dppass)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glStencilOpSeparate(face, sfail, dpfail, dppass);
}
void QOpenGLFunctions_3_1_GlTexBuffer4(void* ptr, unsigned int target, unsigned int internalformat, unsigned int buffer)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glTexBuffer(target, internalformat, buffer);
}
void QOpenGLFunctions_3_1_GlTexImage1D4(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_3_1_GlTexImage2D4(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_3_1_GlTexImage3D4(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLFunctions_3_1_GlTexParameterIiv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glTexParameterIiv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_1_GlTexParameterIuiv4(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glTexParameterIuiv(target, pname, const_cast<const GLuint*>(&params));
}
void QOpenGLFunctions_3_1_GlTexParameterf4(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_3_1_GlTexParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_1_GlTexParameteri4(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_3_1_GlTexParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_1_GlTexSubImage1D4(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_3_1_GlTexSubImage2D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_3_1_GlTexSubImage3D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_3_1_GlUniform1f4(void* ptr, int location, float v0)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniform1f(location, v0);
}
void QOpenGLFunctions_3_1_GlUniform1fv4(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniform1fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_1_GlUniform1i4(void* ptr, int location, int v0)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniform1i(location, v0);
}
void QOpenGLFunctions_3_1_GlUniform1iv4(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniform1iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_1_GlUniform1ui4(void* ptr, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniform1ui(location, v0);
}
void QOpenGLFunctions_3_1_GlUniform1uiv4(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniform1uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_1_GlUniform2f4(void* ptr, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniform2f(location, v0, v1);
}
void QOpenGLFunctions_3_1_GlUniform2fv4(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniform2fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_1_GlUniform2i4(void* ptr, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniform2i(location, v0, v1);
}
void QOpenGLFunctions_3_1_GlUniform2iv4(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniform2iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_1_GlUniform2ui4(void* ptr, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniform2ui(location, v0, v1);
}
void QOpenGLFunctions_3_1_GlUniform2uiv4(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniform2uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_1_GlUniform3f4(void* ptr, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniform3f(location, v0, v1, v2);
}
void QOpenGLFunctions_3_1_GlUniform3fv4(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniform3fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_1_GlUniform3i4(void* ptr, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniform3i(location, v0, v1, v2);
}
void QOpenGLFunctions_3_1_GlUniform3iv4(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniform3iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_1_GlUniform3ui4(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniform3ui(location, v0, v1, v2);
}
void QOpenGLFunctions_3_1_GlUniform3uiv4(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniform3uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_1_GlUniform4f4(void* ptr, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniform4f(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_3_1_GlUniform4fv4(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniform4fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_1_GlUniform4i4(void* ptr, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniform4i(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_3_1_GlUniform4iv4(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniform4iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_1_GlUniform4ui4(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniform4ui(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_3_1_GlUniform4uiv4(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniform4uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_1_GlUniformBlockBinding4(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int uniformBlockBinding)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}
void QOpenGLFunctions_3_1_GlUniformMatrix2fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniformMatrix2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_1_GlUniformMatrix2x3fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniformMatrix2x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_1_GlUniformMatrix2x4fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniformMatrix2x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_1_GlUniformMatrix3fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniformMatrix3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_1_GlUniformMatrix3x2fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniformMatrix3x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_1_GlUniformMatrix3x4fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniformMatrix3x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_1_GlUniformMatrix4fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniformMatrix4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_1_GlUniformMatrix4x2fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniformMatrix4x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_1_GlUniformMatrix4x3fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUniformMatrix4x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_1_GlUseProgram4(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glUseProgram(program);
}
void QOpenGLFunctions_3_1_GlValidateProgram4(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glValidateProgram(program);
}
void QOpenGLFunctions_3_1_GlVertexAttribIPointer4(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glVertexAttribIPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_3_1_GlVertexAttribPointer4(void* ptr, unsigned int index, int size, unsigned int ty, char normalized, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glVertexAttribPointer(index, size, ty, normalized != 0, stride, pointer);
}
void QOpenGLFunctions_3_1_GlViewport4(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_3_1_DestroyQOpenGLFunctions_3_14(void* ptr)
{
static_cast<QOpenGLFunctions_3_1*>(ptr)->~QOpenGLFunctions_3_1();
}
void QOpenGLFunctions_3_1_DestroyQOpenGLFunctions_3_14Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_3_2_Compatibility: public QOpenGLFunctions_3_2_Compatibility
{
public:
MyQOpenGLFunctions_3_2_Compatibility() : QOpenGLFunctions_3_2_Compatibility() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_3_2_Compatibility_InitializeOpenGLFunctions4(this) != 0; };
~MyQOpenGLFunctions_3_2_Compatibility() { callbackQOpenGLFunctions_3_2_Compatibility_DestroyQOpenGLFunctions_3_2_Compatibility4(this); };
};
char QOpenGLFunctions_3_2_Compatibility_GlAreTexturesResident4(void* ptr, int n, unsigned int textures, char residences)
{
Q_UNUSED(residences);
return static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glAreTexturesResident(n, const_cast<const GLuint*>(&textures), NULL);
}
char QOpenGLFunctions_3_2_Compatibility_GlIsBuffer4(void* ptr, unsigned int buffer)
{
return static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glIsBuffer(buffer);
}
char QOpenGLFunctions_3_2_Compatibility_GlIsEnabled4(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_3_2_Compatibility_GlIsEnabledi4(void* ptr, unsigned int target, unsigned int index)
{
return static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glIsEnabledi(target, index);
}
char QOpenGLFunctions_3_2_Compatibility_GlIsFramebuffer4(void* ptr, unsigned int framebuffer)
{
return static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glIsFramebuffer(framebuffer);
}
char QOpenGLFunctions_3_2_Compatibility_GlIsList4(void* ptr, unsigned int list)
{
return static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glIsList(list);
}
char QOpenGLFunctions_3_2_Compatibility_GlIsProgram4(void* ptr, unsigned int program)
{
return static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glIsProgram(program);
}
char QOpenGLFunctions_3_2_Compatibility_GlIsQuery4(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glIsQuery(id);
}
char QOpenGLFunctions_3_2_Compatibility_GlIsRenderbuffer4(void* ptr, unsigned int renderbuffer)
{
return static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glIsRenderbuffer(renderbuffer);
}
char QOpenGLFunctions_3_2_Compatibility_GlIsShader4(void* ptr, unsigned int shader)
{
return static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glIsShader(shader);
}
char QOpenGLFunctions_3_2_Compatibility_GlIsTexture4(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glIsTexture(texture);
}
char QOpenGLFunctions_3_2_Compatibility_GlIsVertexArray4(void* ptr, unsigned int array)
{
return static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glIsVertexArray(array);
}
char QOpenGLFunctions_3_2_Compatibility_GlUnmapBuffer4(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUnmapBuffer(target);
}
unsigned int QOpenGLFunctions_3_2_Compatibility_GlCheckFramebufferStatus4(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glCheckFramebufferStatus(target);
}
unsigned int QOpenGLFunctions_3_2_Compatibility_GlGetError4(void* ptr)
{
return static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetError();
}
int QOpenGLFunctions_3_2_Compatibility_GlRenderMode4(void* ptr, unsigned int mode)
{
return static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRenderMode(mode);
}
unsigned int QOpenGLFunctions_3_2_Compatibility_GlCreateProgram4(void* ptr)
{
return static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glCreateProgram();
}
unsigned int QOpenGLFunctions_3_2_Compatibility_GlCreateShader4(void* ptr, unsigned int ty)
{
return static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glCreateShader(ty);
}
unsigned int QOpenGLFunctions_3_2_Compatibility_GlGenLists4(void* ptr, int ran)
{
return static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGenLists(ran);
}
void* QOpenGLFunctions_3_2_Compatibility_GlMapBuffer4(void* ptr, unsigned int target, unsigned int access)
{
return static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMapBuffer(target, access);
}
void* QOpenGLFunctions_3_2_Compatibility_NewQOpenGLFunctions_3_2_Compatibility4()
{
return new MyQOpenGLFunctions_3_2_Compatibility();
}
char QOpenGLFunctions_3_2_Compatibility_InitializeOpenGLFunctions4(void* ptr)
{
return static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_3_2_Compatibility_InitializeOpenGLFunctions4Default(void* ptr)
{
return static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->QOpenGLFunctions_3_2_Compatibility::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_3_2_Compatibility_GlGetString4(void* ptr, unsigned int name)
{
return ({ char* t0c6a23 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetString(name)))); QtGui_PackedString { t0c6a23, -1 }; });
}
struct QtGui_PackedString QOpenGLFunctions_3_2_Compatibility_GlGetStringi4(void* ptr, unsigned int name, unsigned int index)
{
return ({ char* t87fb5a = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetStringi(name, index)))); QtGui_PackedString { t87fb5a, -1 }; });
}
void QOpenGLFunctions_3_2_Compatibility_GlAccum4(void* ptr, unsigned int op, float value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glAccum(op, value);
}
void QOpenGLFunctions_3_2_Compatibility_GlActiveTexture4(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glActiveTexture(texture);
}
void QOpenGLFunctions_3_2_Compatibility_GlAlphaFunc4(void* ptr, unsigned int fu, float ref)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glAlphaFunc(fu, ref);
}
void QOpenGLFunctions_3_2_Compatibility_GlArrayElement4(void* ptr, int i)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glArrayElement(i);
}
void QOpenGLFunctions_3_2_Compatibility_GlAttachShader4(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glAttachShader(program, shader);
}
void QOpenGLFunctions_3_2_Compatibility_GlBegin4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glBegin(mode);
}
void QOpenGLFunctions_3_2_Compatibility_GlBeginConditionalRender4(void* ptr, unsigned int id, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glBeginConditionalRender(id, mode);
}
void QOpenGLFunctions_3_2_Compatibility_GlBeginQuery4(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glBeginQuery(target, id);
}
void QOpenGLFunctions_3_2_Compatibility_GlBeginTransformFeedback4(void* ptr, unsigned int primitiveMode)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glBeginTransformFeedback(primitiveMode);
}
void QOpenGLFunctions_3_2_Compatibility_GlBindBuffer4(void* ptr, unsigned int target, unsigned int buffer)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glBindBuffer(target, buffer);
}
void QOpenGLFunctions_3_2_Compatibility_GlBindBufferBase4(void* ptr, unsigned int target, unsigned int index, unsigned int buffer)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glBindBufferBase(target, index, buffer);
}
void QOpenGLFunctions_3_2_Compatibility_GlBindFramebuffer4(void* ptr, unsigned int target, unsigned int framebuffer)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glBindFramebuffer(target, framebuffer);
}
void QOpenGLFunctions_3_2_Compatibility_GlBindRenderbuffer4(void* ptr, unsigned int target, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glBindRenderbuffer(target, renderbuffer);
}
void QOpenGLFunctions_3_2_Compatibility_GlBindTexture4(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_3_2_Compatibility_GlBindVertexArray4(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glBindVertexArray(array);
}
void QOpenGLFunctions_3_2_Compatibility_GlBitmap4(void* ptr, int width, int height, float xorig, float yorig, float xmove, float ymove, char* bitmap)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glBitmap(width, height, xorig, yorig, xmove, ymove, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(bitmap))));
}
void QOpenGLFunctions_3_2_Compatibility_GlBlendColor4(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_3_2_Compatibility_GlBlendEquation4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_3_2_Compatibility_GlBlendEquationSeparate4(void* ptr, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glBlendEquationSeparate(modeRGB, modeAlpha);
}
void QOpenGLFunctions_3_2_Compatibility_GlBlendFunc4(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_3_2_Compatibility_GlBlendFuncSeparate4(void* ptr, unsigned int sfactorRGB, unsigned int dfactorRGB, unsigned int sfactorAlpha, unsigned int dfactorAlpha)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void QOpenGLFunctions_3_2_Compatibility_GlBlitFramebuffer4(void* ptr, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, unsigned int mask, unsigned int filter)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
void QOpenGLFunctions_3_2_Compatibility_GlCallList4(void* ptr, unsigned int list)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glCallList(list);
}
void QOpenGLFunctions_3_2_Compatibility_GlCallLists4(void* ptr, int n, unsigned int ty, void* lists)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glCallLists(n, ty, lists);
}
void QOpenGLFunctions_3_2_Compatibility_GlClampColor4(void* ptr, unsigned int target, unsigned int clamp)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glClampColor(target, clamp);
}
void QOpenGLFunctions_3_2_Compatibility_GlClear4(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_3_2_Compatibility_GlClearAccum4(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glClearAccum(red, green, blue, alpha);
}
void QOpenGLFunctions_3_2_Compatibility_GlClearBufferfi4(void* ptr, unsigned int buffer, int drawbuffer, float depth, int stencil)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glClearBufferfi(buffer, drawbuffer, depth, stencil);
}
void QOpenGLFunctions_3_2_Compatibility_GlClearBufferfv4(void* ptr, unsigned int buffer, int drawbuffer, float value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glClearBufferfv(buffer, drawbuffer, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Compatibility_GlClearBufferiv4(void* ptr, unsigned int buffer, int drawbuffer, int value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glClearBufferiv(buffer, drawbuffer, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_2_Compatibility_GlClearBufferuiv4(void* ptr, unsigned int buffer, int drawbuffer, unsigned int value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glClearBufferuiv(buffer, drawbuffer, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_2_Compatibility_GlClearColor4(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_3_2_Compatibility_GlClearIndex4(void* ptr, float c)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glClearIndex(c);
}
void QOpenGLFunctions_3_2_Compatibility_GlClearStencil4(void* ptr, int s)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_3_2_Compatibility_GlClientActiveTexture4(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glClientActiveTexture(texture);
}
void QOpenGLFunctions_3_2_Compatibility_GlColor3f4(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColor3f(red, green, blue);
}
void QOpenGLFunctions_3_2_Compatibility_GlColor3fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlColor3i4(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColor3i(red, green, blue);
}
void QOpenGLFunctions_3_2_Compatibility_GlColor3iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlColor3s4(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColor3s(red, green, blue);
}
void QOpenGLFunctions_3_2_Compatibility_GlColor3sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlColor3ub4(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_3_2_Compatibility_GlColor3ubv4(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_3_2_Compatibility_GlColor3ui4(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColor3ui(red, green, blue);
}
void QOpenGLFunctions_3_2_Compatibility_GlColor3uiv4(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlColor3us4(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColor3us(red, green, blue);
}
void QOpenGLFunctions_3_2_Compatibility_GlColor3usv4(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlColor4f4(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColor4f(red, green, blue, alpha);
}
void QOpenGLFunctions_3_2_Compatibility_GlColor4fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColor4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlColor4i4(void* ptr, int red, int green, int blue, int alpha)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColor4i(red, green, blue, alpha);
}
void QOpenGLFunctions_3_2_Compatibility_GlColor4iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColor4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlColor4s4(void* ptr, short red, short green, short blue, short alpha)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColor4s(red, green, blue, alpha);
}
void QOpenGLFunctions_3_2_Compatibility_GlColor4sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColor4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlColor4ub4(void* ptr, char* red, char* green, char* blue, char* alpha)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColor4ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)), *static_cast<GLubyte*>(static_cast<void*>(alpha)));
}
void QOpenGLFunctions_3_2_Compatibility_GlColor4ubv4(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColor4ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_3_2_Compatibility_GlColor4ui4(void* ptr, unsigned int red, unsigned int green, unsigned int blue, unsigned int alpha)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColor4ui(red, green, blue, alpha);
}
void QOpenGLFunctions_3_2_Compatibility_GlColor4uiv4(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColor4uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlColor4us4(void* ptr, unsigned short red, unsigned short green, unsigned short blue, unsigned short alpha)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColor4us(red, green, blue, alpha);
}
void QOpenGLFunctions_3_2_Compatibility_GlColor4usv4(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColor4usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlColorMask4(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_3_2_Compatibility_GlColorMaski4(void* ptr, unsigned int index, char r, char g, char b, char a)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColorMaski(index, r != 0, g != 0, b != 0, a != 0);
}
void QOpenGLFunctions_3_2_Compatibility_GlColorMaterial4(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColorMaterial(face, mode);
}
void QOpenGLFunctions_3_2_Compatibility_GlColorPointer4(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_3_2_Compatibility_GlColorSubTable4(void* ptr, unsigned int target, int start, int count, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColorSubTable(target, start, count, format, ty, data);
}
void QOpenGLFunctions_3_2_Compatibility_GlColorTable4(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColorTable(target, internalformat, width, format, ty, table);
}
void QOpenGLFunctions_3_2_Compatibility_GlColorTableParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColorTableParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_2_Compatibility_GlColorTableParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glColorTableParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_2_Compatibility_GlCompileShader4(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glCompileShader(shader);
}
void QOpenGLFunctions_3_2_Compatibility_GlCompressedTexImage1D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
void QOpenGLFunctions_3_2_Compatibility_GlCompressedTexImage2D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void QOpenGLFunctions_3_2_Compatibility_GlCompressedTexImage3D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int depth, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void QOpenGLFunctions_3_2_Compatibility_GlCompressedTexSubImage1D4(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_3_2_Compatibility_GlCompressedTexSubImage2D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_3_2_Compatibility_GlCompressedTexSubImage3D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_3_2_Compatibility_GlConvolutionFilter1D4(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glConvolutionFilter1D(target, internalformat, width, format, ty, image);
}
void QOpenGLFunctions_3_2_Compatibility_GlConvolutionFilter2D4(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glConvolutionFilter2D(target, internalformat, width, height, format, ty, image);
}
void QOpenGLFunctions_3_2_Compatibility_GlConvolutionParameterf4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glConvolutionParameterf(target, pname, params);
}
void QOpenGLFunctions_3_2_Compatibility_GlConvolutionParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glConvolutionParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_2_Compatibility_GlConvolutionParameteri4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glConvolutionParameteri(target, pname, params);
}
void QOpenGLFunctions_3_2_Compatibility_GlConvolutionParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glConvolutionParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_2_Compatibility_GlCopyColorSubTable4(void* ptr, unsigned int target, int start, int x, int y, int width)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glCopyColorSubTable(target, start, x, y, width);
}
void QOpenGLFunctions_3_2_Compatibility_GlCopyColorTable4(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glCopyColorTable(target, internalformat, x, y, width);
}
void QOpenGLFunctions_3_2_Compatibility_GlCopyConvolutionFilter1D4(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glCopyConvolutionFilter1D(target, internalformat, x, y, width);
}
void QOpenGLFunctions_3_2_Compatibility_GlCopyConvolutionFilter2D4(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);
}
void QOpenGLFunctions_3_2_Compatibility_GlCopyPixels4(void* ptr, int x, int y, int width, int height, unsigned int ty)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glCopyPixels(x, y, width, height, ty);
}
void QOpenGLFunctions_3_2_Compatibility_GlCopyTexImage1D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_3_2_Compatibility_GlCopyTexImage2D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_3_2_Compatibility_GlCopyTexSubImage1D4(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_3_2_Compatibility_GlCopyTexSubImage2D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_3_2_Compatibility_GlCopyTexSubImage3D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_3_2_Compatibility_GlCullFace4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_3_2_Compatibility_GlDeleteBuffers4(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDeleteBuffers(n, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_3_2_Compatibility_GlDeleteFramebuffers4(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDeleteFramebuffers(n, const_cast<const GLuint*>(&framebuffers));
}
void QOpenGLFunctions_3_2_Compatibility_GlDeleteLists4(void* ptr, unsigned int list, int ran)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDeleteLists(list, ran);
}
void QOpenGLFunctions_3_2_Compatibility_GlDeleteProgram4(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDeleteProgram(program);
}
void QOpenGLFunctions_3_2_Compatibility_GlDeleteQueries4(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDeleteQueries(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_3_2_Compatibility_GlDeleteRenderbuffers4(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDeleteRenderbuffers(n, const_cast<const GLuint*>(&renderbuffers));
}
void QOpenGLFunctions_3_2_Compatibility_GlDeleteShader4(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDeleteShader(shader);
}
void QOpenGLFunctions_3_2_Compatibility_GlDeleteTextures4(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_3_2_Compatibility_GlDeleteVertexArrays4(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDeleteVertexArrays(n, const_cast<const GLuint*>(&arrays));
}
void QOpenGLFunctions_3_2_Compatibility_GlDepthFunc4(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_3_2_Compatibility_GlDepthMask4(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_3_2_Compatibility_GlDetachShader4(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDetachShader(program, shader);
}
void QOpenGLFunctions_3_2_Compatibility_GlDisable4(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_3_2_Compatibility_GlDisableClientState4(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDisableClientState(array);
}
void QOpenGLFunctions_3_2_Compatibility_GlDisableVertexAttribArray4(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDisableVertexAttribArray(index);
}
void QOpenGLFunctions_3_2_Compatibility_GlDisablei4(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDisablei(target, index);
}
void QOpenGLFunctions_3_2_Compatibility_GlDrawArrays4(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_3_2_Compatibility_GlDrawArraysInstanced4(void* ptr, unsigned int mode, int first, int count, int instancecount)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDrawArraysInstanced(mode, first, count, instancecount);
}
void QOpenGLFunctions_3_2_Compatibility_GlDrawBuffer4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDrawBuffer(mode);
}
void QOpenGLFunctions_3_2_Compatibility_GlDrawBuffers4(void* ptr, int n, unsigned int bufs)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDrawBuffers(n, const_cast<const GLenum*>(&bufs));
}
void QOpenGLFunctions_3_2_Compatibility_GlDrawElements4(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_3_2_Compatibility_GlDrawElementsBaseVertex4(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDrawElementsBaseVertex(mode, count, ty, indices, basevertex);
}
void QOpenGLFunctions_3_2_Compatibility_GlDrawElementsInstanced4(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDrawElementsInstanced(mode, count, ty, indices, instancecount);
}
void QOpenGLFunctions_3_2_Compatibility_GlDrawElementsInstancedBaseVertex4(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDrawElementsInstancedBaseVertex(mode, count, ty, indices, instancecount, basevertex);
}
void QOpenGLFunctions_3_2_Compatibility_GlDrawPixels4(void* ptr, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDrawPixels(width, height, format, ty, pixels);
}
void QOpenGLFunctions_3_2_Compatibility_GlDrawRangeElements4(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLFunctions_3_2_Compatibility_GlDrawRangeElementsBaseVertex4(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glDrawRangeElementsBaseVertex(mode, start, end, count, ty, indices, basevertex);
}
void QOpenGLFunctions_3_2_Compatibility_GlEdgeFlag4(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glEdgeFlag(flag != 0);
}
void QOpenGLFunctions_3_2_Compatibility_GlEdgeFlagPointer4(void* ptr, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glEdgeFlagPointer(stride, pointer);
}
void QOpenGLFunctions_3_2_Compatibility_GlEdgeFlagv4(void* ptr, char flag)
{
Q_UNUSED(flag);
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glEdgeFlagv(NULL);
}
void QOpenGLFunctions_3_2_Compatibility_GlEnable4(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_3_2_Compatibility_GlEnableClientState4(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glEnableClientState(array);
}
void QOpenGLFunctions_3_2_Compatibility_GlEnableVertexAttribArray4(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glEnableVertexAttribArray(index);
}
void QOpenGLFunctions_3_2_Compatibility_GlEnablei4(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glEnablei(target, index);
}
void QOpenGLFunctions_3_2_Compatibility_GlEnd4(void* ptr)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glEnd();
}
void QOpenGLFunctions_3_2_Compatibility_GlEndConditionalRender4(void* ptr)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glEndConditionalRender();
}
void QOpenGLFunctions_3_2_Compatibility_GlEndList4(void* ptr)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glEndList();
}
void QOpenGLFunctions_3_2_Compatibility_GlEndQuery4(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glEndQuery(target);
}
void QOpenGLFunctions_3_2_Compatibility_GlEndTransformFeedback4(void* ptr)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glEndTransformFeedback();
}
void QOpenGLFunctions_3_2_Compatibility_GlEvalCoord1f4(void* ptr, float u)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glEvalCoord1f(u);
}
void QOpenGLFunctions_3_2_Compatibility_GlEvalCoord1fv4(void* ptr, float u)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glEvalCoord1fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_3_2_Compatibility_GlEvalCoord2f4(void* ptr, float u, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glEvalCoord2f(u, v);
}
void QOpenGLFunctions_3_2_Compatibility_GlEvalCoord2fv4(void* ptr, float u)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glEvalCoord2fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_3_2_Compatibility_GlEvalMesh14(void* ptr, unsigned int mode, int i1, int i2)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glEvalMesh1(mode, i1, i2);
}
void QOpenGLFunctions_3_2_Compatibility_GlEvalMesh24(void* ptr, unsigned int mode, int i1, int i2, int j1, int j2)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glEvalMesh2(mode, i1, i2, j1, j2);
}
void QOpenGLFunctions_3_2_Compatibility_GlEvalPoint14(void* ptr, int i)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glEvalPoint1(i);
}
void QOpenGLFunctions_3_2_Compatibility_GlEvalPoint24(void* ptr, int i, int j)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glEvalPoint2(i, j);
}
void QOpenGLFunctions_3_2_Compatibility_GlFeedbackBuffer4(void* ptr, int size, unsigned int ty, float buffer)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glFeedbackBuffer(size, ty, &buffer);
}
void QOpenGLFunctions_3_2_Compatibility_GlFinish4(void* ptr)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glFinish();
}
void QOpenGLFunctions_3_2_Compatibility_GlFlush4(void* ptr)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glFlush();
}
void QOpenGLFunctions_3_2_Compatibility_GlFogCoordPointer4(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glFogCoordPointer(ty, stride, pointer);
}
void QOpenGLFunctions_3_2_Compatibility_GlFogCoordf4(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glFogCoordf(coord);
}
void QOpenGLFunctions_3_2_Compatibility_GlFogCoordfv4(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glFogCoordfv(const_cast<const GLfloat*>(&coord));
}
void QOpenGLFunctions_3_2_Compatibility_GlFogf4(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glFogf(pname, param);
}
void QOpenGLFunctions_3_2_Compatibility_GlFogfv4(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glFogfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_2_Compatibility_GlFogi4(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glFogi(pname, param);
}
void QOpenGLFunctions_3_2_Compatibility_GlFogiv4(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glFogiv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_2_Compatibility_GlFramebufferRenderbuffer4(void* ptr, unsigned int target, unsigned int attachment, unsigned int renderbuffertarget, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
void QOpenGLFunctions_3_2_Compatibility_GlFramebufferTexture4(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glFramebufferTexture(target, attachment, texture, level);
}
void QOpenGLFunctions_3_2_Compatibility_GlFramebufferTexture1D4(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glFramebufferTexture1D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_3_2_Compatibility_GlFramebufferTexture2D4(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_3_2_Compatibility_GlFramebufferTexture3D4(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level, int zoffset)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}
void QOpenGLFunctions_3_2_Compatibility_GlFramebufferTextureLayer4(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level, int layer)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glFramebufferTextureLayer(target, attachment, texture, level, layer);
}
void QOpenGLFunctions_3_2_Compatibility_GlFrontFace4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_3_2_Compatibility_GlGenBuffers4(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGenBuffers(n, &buffers);
}
void QOpenGLFunctions_3_2_Compatibility_GlGenFramebuffers4(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGenFramebuffers(n, &framebuffers);
}
void QOpenGLFunctions_3_2_Compatibility_GlGenQueries4(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGenQueries(n, &ids);
}
void QOpenGLFunctions_3_2_Compatibility_GlGenRenderbuffers4(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGenRenderbuffers(n, &renderbuffers);
}
void QOpenGLFunctions_3_2_Compatibility_GlGenTextures4(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_3_2_Compatibility_GlGenVertexArrays4(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGenVertexArrays(n, &arrays);
}
void QOpenGLFunctions_3_2_Compatibility_GlGenerateMipmap4(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGenerateMipmap(target);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetActiveUniformBlockiv4(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetActiveUniformsiv4(void* ptr, unsigned int program, int uniformCount, unsigned int uniformIndices, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetActiveUniformsiv(program, uniformCount, const_cast<const GLuint*>(&uniformIndices), pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetAttachedShaders4(void* ptr, unsigned int program, int maxCount, int count, unsigned int obj)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetAttachedShaders(program, maxCount, &count, &obj);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetBooleani_v4(void* ptr, unsigned int target, unsigned int index, char data)
{
Q_UNUSED(data);
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetBooleani_v(target, index, NULL);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetBooleanv4(void* ptr, unsigned int pname, char params)
{
Q_UNUSED(params);
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetBufferParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetBufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetBufferPointerv4(void* ptr, unsigned int target, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetBufferPointerv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetColorTable4(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetColorTable(target, format, ty, table);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetColorTableParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetColorTableParameterfv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetColorTableParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetColorTableParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetCompressedTexImage4(void* ptr, unsigned int target, int level, void* img)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetCompressedTexImage(target, level, img);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetConvolutionFilter4(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetConvolutionFilter(target, format, ty, image);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetConvolutionParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetConvolutionParameterfv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetConvolutionParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetConvolutionParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetFloatv4(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetFloatv(pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetFramebufferAttachmentParameteriv4(void* ptr, unsigned int target, unsigned int attachment, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetFramebufferAttachmentParameteriv(target, attachment, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetHistogram4(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetHistogram(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetHistogramParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetHistogramParameterfv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetHistogramParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetHistogramParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetIntegeri_v4(void* ptr, unsigned int target, unsigned int index, int data)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetIntegeri_v(target, index, &data);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetIntegerv4(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetIntegerv(pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetLightfv4(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetLightfv(light, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetLightiv4(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetLightiv(light, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetMapfv4(void* ptr, unsigned int target, unsigned int query, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetMapfv(target, query, &v);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetMapiv4(void* ptr, unsigned int target, unsigned int query, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetMapiv(target, query, &v);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetMaterialfv4(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetMaterialfv(face, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetMaterialiv4(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetMaterialiv(face, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetMinmax4(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetMinmax(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetMinmaxParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetMinmaxParameterfv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetMinmaxParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetMinmaxParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetMultisamplefv4(void* ptr, unsigned int pname, unsigned int index, float val)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetMultisamplefv(pname, index, &val);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetPixelMapfv4(void* ptr, unsigned int m, float values)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetPixelMapfv(m, &values);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetPixelMapuiv4(void* ptr, unsigned int m, unsigned int values)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetPixelMapuiv(m, &values);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetPixelMapusv4(void* ptr, unsigned int m, unsigned short values)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetPixelMapusv(m, &values);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetPointerv4(void* ptr, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetPointerv(pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetPolygonStipple4(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetPolygonStipple(static_cast<GLubyte*>(static_cast<void*>(mask)));
}
void QOpenGLFunctions_3_2_Compatibility_GlGetProgramiv4(void* ptr, unsigned int program, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetProgramiv(program, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetQueryObjectiv4(void* ptr, unsigned int id, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetQueryObjectiv(id, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetQueryObjectuiv4(void* ptr, unsigned int id, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetQueryObjectuiv(id, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetQueryiv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetQueryiv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetRenderbufferParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetRenderbufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetSeparableFilter4(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* row, void* column, void* span)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetSeparableFilter(target, format, ty, row, column, span);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetShaderiv4(void* ptr, unsigned int shader, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetShaderiv(shader, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetTexEnvfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetTexEnvfv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetTexEnviv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetTexEnviv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetTexGenfv4(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetTexGenfv(coord, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetTexGeniv4(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetTexGeniv(coord, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetTexImage4(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetTexLevelParameterfv4(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetTexLevelParameteriv4(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetTexParameterIiv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetTexParameterIiv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetTexParameterIuiv4(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetTexParameterIuiv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetTexParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetTexParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetUniformfv4(void* ptr, unsigned int program, int location, float params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetUniformfv(program, location, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetUniformiv4(void* ptr, unsigned int program, int location, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetUniformiv(program, location, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetUniformuiv4(void* ptr, unsigned int program, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetUniformuiv(program, location, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetVertexAttribIiv4(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetVertexAttribIiv(index, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetVertexAttribIuiv4(void* ptr, unsigned int index, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetVertexAttribIuiv(index, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetVertexAttribPointerv4(void* ptr, unsigned int index, unsigned int pname, void* pointer)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetVertexAttribPointerv(index, pname, &pointer);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetVertexAttribfv4(void* ptr, unsigned int index, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetVertexAttribfv(index, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlGetVertexAttribiv4(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glGetVertexAttribiv(index, pname, &params);
}
void QOpenGLFunctions_3_2_Compatibility_GlHint4(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_3_2_Compatibility_GlHistogram4(void* ptr, unsigned int target, int width, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glHistogram(target, width, internalformat, sink != 0);
}
void QOpenGLFunctions_3_2_Compatibility_GlIndexMask4(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glIndexMask(mask);
}
void QOpenGLFunctions_3_2_Compatibility_GlIndexPointer4(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glIndexPointer(ty, stride, pointer);
}
void QOpenGLFunctions_3_2_Compatibility_GlIndexf4(void* ptr, float c)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glIndexf(c);
}
void QOpenGLFunctions_3_2_Compatibility_GlIndexfv4(void* ptr, float c)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glIndexfv(const_cast<const GLfloat*>(&c));
}
void QOpenGLFunctions_3_2_Compatibility_GlIndexi4(void* ptr, int c)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glIndexi(c);
}
void QOpenGLFunctions_3_2_Compatibility_GlIndexiv4(void* ptr, int c)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glIndexiv(const_cast<const GLint*>(&c));
}
void QOpenGLFunctions_3_2_Compatibility_GlIndexs4(void* ptr, short c)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glIndexs(c);
}
void QOpenGLFunctions_3_2_Compatibility_GlIndexsv4(void* ptr, short c)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glIndexsv(const_cast<const GLshort*>(&c));
}
void QOpenGLFunctions_3_2_Compatibility_GlIndexub4(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glIndexub(*static_cast<GLubyte*>(static_cast<void*>(c)));
}
void QOpenGLFunctions_3_2_Compatibility_GlIndexubv4(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glIndexubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(c))));
}
void QOpenGLFunctions_3_2_Compatibility_GlInitNames4(void* ptr)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glInitNames();
}
void QOpenGLFunctions_3_2_Compatibility_GlInterleavedArrays4(void* ptr, unsigned int format, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glInterleavedArrays(format, stride, pointer);
}
void QOpenGLFunctions_3_2_Compatibility_GlLightModelf4(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glLightModelf(pname, param);
}
void QOpenGLFunctions_3_2_Compatibility_GlLightModelfv4(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glLightModelfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_2_Compatibility_GlLightModeli4(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glLightModeli(pname, param);
}
void QOpenGLFunctions_3_2_Compatibility_GlLightModeliv4(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glLightModeliv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_2_Compatibility_GlLightf4(void* ptr, unsigned int light, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glLightf(light, pname, param);
}
void QOpenGLFunctions_3_2_Compatibility_GlLightfv4(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glLightfv(light, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_2_Compatibility_GlLighti4(void* ptr, unsigned int light, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glLighti(light, pname, param);
}
void QOpenGLFunctions_3_2_Compatibility_GlLightiv4(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glLightiv(light, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_2_Compatibility_GlLineStipple4(void* ptr, int factor, unsigned short pattern)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glLineStipple(factor, pattern);
}
void QOpenGLFunctions_3_2_Compatibility_GlLineWidth4(void* ptr, float width)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_3_2_Compatibility_GlLinkProgram4(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glLinkProgram(program);
}
void QOpenGLFunctions_3_2_Compatibility_GlListBase4(void* ptr, unsigned int base)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glListBase(base);
}
void QOpenGLFunctions_3_2_Compatibility_GlLoadIdentity4(void* ptr)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glLoadIdentity();
}
void QOpenGLFunctions_3_2_Compatibility_GlLoadMatrixf4(void* ptr, float m)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glLoadMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_3_2_Compatibility_GlLoadName4(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glLoadName(name);
}
void QOpenGLFunctions_3_2_Compatibility_GlLoadTransposeMatrixf4(void* ptr, float m)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glLoadTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_3_2_Compatibility_GlLogicOp4(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_3_2_Compatibility_GlMap1f4(void* ptr, unsigned int target, float u1, float u2, int stride, int order, float points)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMap1f(target, u1, u2, stride, order, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_3_2_Compatibility_GlMap2f4(void* ptr, unsigned int target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float points)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_3_2_Compatibility_GlMapGrid1f4(void* ptr, int un, float u1, float u2)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMapGrid1f(un, u1, u2);
}
void QOpenGLFunctions_3_2_Compatibility_GlMapGrid2f4(void* ptr, int un, float u1, float u2, int vn, float v1, float v2)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMapGrid2f(un, u1, u2, vn, v1, v2);
}
void QOpenGLFunctions_3_2_Compatibility_GlMaterialf4(void* ptr, unsigned int face, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMaterialf(face, pname, param);
}
void QOpenGLFunctions_3_2_Compatibility_GlMaterialfv4(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMaterialfv(face, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_2_Compatibility_GlMateriali4(void* ptr, unsigned int face, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMateriali(face, pname, param);
}
void QOpenGLFunctions_3_2_Compatibility_GlMaterialiv4(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMaterialiv(face, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_2_Compatibility_GlMatrixMode4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMatrixMode(mode);
}
void QOpenGLFunctions_3_2_Compatibility_GlMinmax4(void* ptr, unsigned int target, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMinmax(target, internalformat, sink != 0);
}
void QOpenGLFunctions_3_2_Compatibility_GlMultMatrixf4(void* ptr, float m)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_3_2_Compatibility_GlMultTransposeMatrixf4(void* ptr, float m)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiDrawArrays4(void* ptr, unsigned int mode, int first, int count, int drawcount)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiDrawArrays(mode, const_cast<const GLint*>(&first), const_cast<const GLsizei*>(&count), drawcount);
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiTexCoord1f4(void* ptr, unsigned int target, float s)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiTexCoord1f(target, s);
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiTexCoord1fv4(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiTexCoord1fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiTexCoord1i4(void* ptr, unsigned int target, int s)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiTexCoord1i(target, s);
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiTexCoord1iv4(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiTexCoord1iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiTexCoord1s4(void* ptr, unsigned int target, short s)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiTexCoord1s(target, s);
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiTexCoord1sv4(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiTexCoord1sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiTexCoord2f4(void* ptr, unsigned int target, float s, float t)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiTexCoord2f(target, s, t);
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiTexCoord2fv4(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiTexCoord2fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiTexCoord2i4(void* ptr, unsigned int target, int s, int t)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiTexCoord2i(target, s, t);
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiTexCoord2iv4(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiTexCoord2iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiTexCoord2s4(void* ptr, unsigned int target, short s, short t)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiTexCoord2s(target, s, t);
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiTexCoord2sv4(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiTexCoord2sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiTexCoord3f4(void* ptr, unsigned int target, float s, float t, float r)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiTexCoord3f(target, s, t, r);
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiTexCoord3fv4(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiTexCoord3fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiTexCoord3i4(void* ptr, unsigned int target, int s, int t, int r)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiTexCoord3i(target, s, t, r);
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiTexCoord3iv4(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiTexCoord3iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiTexCoord3s4(void* ptr, unsigned int target, short s, short t, short r)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiTexCoord3s(target, s, t, r);
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiTexCoord3sv4(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiTexCoord3sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiTexCoord4f4(void* ptr, unsigned int target, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiTexCoord4f(target, s, t, r, q);
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiTexCoord4fv4(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiTexCoord4fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiTexCoord4i4(void* ptr, unsigned int target, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiTexCoord4i(target, s, t, r, q);
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiTexCoord4iv4(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiTexCoord4iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiTexCoord4s4(void* ptr, unsigned int target, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiTexCoord4s(target, s, t, r, q);
}
void QOpenGLFunctions_3_2_Compatibility_GlMultiTexCoord4sv4(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glMultiTexCoord4sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlNewList4(void* ptr, unsigned int list, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glNewList(list, mode);
}
void QOpenGLFunctions_3_2_Compatibility_GlNormal3f4(void* ptr, float nx, float ny, float nz)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glNormal3f(nx, ny, nz);
}
void QOpenGLFunctions_3_2_Compatibility_GlNormal3fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glNormal3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlNormal3i4(void* ptr, int nx, int ny, int nz)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glNormal3i(nx, ny, nz);
}
void QOpenGLFunctions_3_2_Compatibility_GlNormal3iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glNormal3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlNormal3s4(void* ptr, short nx, short ny, short nz)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glNormal3s(nx, ny, nz);
}
void QOpenGLFunctions_3_2_Compatibility_GlNormal3sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glNormal3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlNormalPointer4(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glNormalPointer(ty, stride, pointer);
}
void QOpenGLFunctions_3_2_Compatibility_GlPassThrough4(void* ptr, float token)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPassThrough(token);
}
void QOpenGLFunctions_3_2_Compatibility_GlPixelMapfv4(void* ptr, unsigned int m, int mapsize, float values)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPixelMapfv(m, mapsize, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_3_2_Compatibility_GlPixelMapuiv4(void* ptr, unsigned int m, int mapsize, unsigned int values)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPixelMapuiv(m, mapsize, const_cast<const GLuint*>(&values));
}
void QOpenGLFunctions_3_2_Compatibility_GlPixelMapusv4(void* ptr, unsigned int m, int mapsize, unsigned short values)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPixelMapusv(m, mapsize, const_cast<const GLushort*>(&values));
}
void QOpenGLFunctions_3_2_Compatibility_GlPixelStoref4(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_3_2_Compatibility_GlPixelStorei4(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_3_2_Compatibility_GlPixelTransferf4(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPixelTransferf(pname, param);
}
void QOpenGLFunctions_3_2_Compatibility_GlPixelTransferi4(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPixelTransferi(pname, param);
}
void QOpenGLFunctions_3_2_Compatibility_GlPixelZoom4(void* ptr, float xfactor, float yfactor)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPixelZoom(xfactor, yfactor);
}
void QOpenGLFunctions_3_2_Compatibility_GlPointParameterf4(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPointParameterf(pname, param);
}
void QOpenGLFunctions_3_2_Compatibility_GlPointParameterfv4(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPointParameterfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_2_Compatibility_GlPointParameteri4(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPointParameteri(pname, param);
}
void QOpenGLFunctions_3_2_Compatibility_GlPointParameteriv4(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPointParameteriv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_2_Compatibility_GlPointSize4(void* ptr, float size)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_3_2_Compatibility_GlPolygonMode4(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_3_2_Compatibility_GlPolygonOffset4(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_3_2_Compatibility_GlPolygonStipple4(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPolygonStipple(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(mask))));
}
void QOpenGLFunctions_3_2_Compatibility_GlPopAttrib4(void* ptr)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPopAttrib();
}
void QOpenGLFunctions_3_2_Compatibility_GlPopClientAttrib4(void* ptr)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPopClientAttrib();
}
void QOpenGLFunctions_3_2_Compatibility_GlPopMatrix4(void* ptr)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPopMatrix();
}
void QOpenGLFunctions_3_2_Compatibility_GlPopName4(void* ptr)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPopName();
}
void QOpenGLFunctions_3_2_Compatibility_GlPrimitiveRestartIndex4(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPrimitiveRestartIndex(index);
}
void QOpenGLFunctions_3_2_Compatibility_GlPrioritizeTextures4(void* ptr, int n, unsigned int textures, float priorities)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPrioritizeTextures(n, const_cast<const GLuint*>(&textures), const_cast<const GLfloat*>(&priorities));
}
void QOpenGLFunctions_3_2_Compatibility_GlProvokingVertex4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glProvokingVertex(mode);
}
void QOpenGLFunctions_3_2_Compatibility_GlPushAttrib4(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPushAttrib(mask);
}
void QOpenGLFunctions_3_2_Compatibility_GlPushClientAttrib4(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPushClientAttrib(mask);
}
void QOpenGLFunctions_3_2_Compatibility_GlPushMatrix4(void* ptr)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPushMatrix();
}
void QOpenGLFunctions_3_2_Compatibility_GlPushName4(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glPushName(name);
}
void QOpenGLFunctions_3_2_Compatibility_GlRasterPos2f4(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRasterPos2f(x, y);
}
void QOpenGLFunctions_3_2_Compatibility_GlRasterPos2fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRasterPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlRasterPos2i4(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRasterPos2i(x, y);
}
void QOpenGLFunctions_3_2_Compatibility_GlRasterPos2iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRasterPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlRasterPos2s4(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRasterPos2s(x, y);
}
void QOpenGLFunctions_3_2_Compatibility_GlRasterPos2sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRasterPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlRasterPos3f4(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRasterPos3f(x, y, z);
}
void QOpenGLFunctions_3_2_Compatibility_GlRasterPos3fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRasterPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlRasterPos3i4(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRasterPos3i(x, y, z);
}
void QOpenGLFunctions_3_2_Compatibility_GlRasterPos3iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRasterPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlRasterPos3s4(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRasterPos3s(x, y, z);
}
void QOpenGLFunctions_3_2_Compatibility_GlRasterPos3sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRasterPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlRasterPos4f4(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRasterPos4f(x, y, z, w);
}
void QOpenGLFunctions_3_2_Compatibility_GlRasterPos4fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRasterPos4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlRasterPos4i4(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRasterPos4i(x, y, z, w);
}
void QOpenGLFunctions_3_2_Compatibility_GlRasterPos4iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRasterPos4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlRasterPos4s4(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRasterPos4s(x, y, z, w);
}
void QOpenGLFunctions_3_2_Compatibility_GlRasterPos4sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRasterPos4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlReadBuffer4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glReadBuffer(mode);
}
void QOpenGLFunctions_3_2_Compatibility_GlReadPixels4(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_3_2_Compatibility_GlRectf4(void* ptr, float x1, float y1, float x2, float y2)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRectf(x1, y1, x2, y2);
}
void QOpenGLFunctions_3_2_Compatibility_GlRectfv4(void* ptr, float v1, float v2)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRectfv(const_cast<const GLfloat*>(&v1), const_cast<const GLfloat*>(&v2));
}
void QOpenGLFunctions_3_2_Compatibility_GlRecti4(void* ptr, int x1, int y1, int x2, int y2)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRecti(x1, y1, x2, y2);
}
void QOpenGLFunctions_3_2_Compatibility_GlRectiv4(void* ptr, int v1, int v2)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRectiv(const_cast<const GLint*>(&v1), const_cast<const GLint*>(&v2));
}
void QOpenGLFunctions_3_2_Compatibility_GlRects4(void* ptr, short x1, short y1, short x2, short y2)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRects(x1, y1, x2, y2);
}
void QOpenGLFunctions_3_2_Compatibility_GlRectsv4(void* ptr, short v1, short v2)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRectsv(const_cast<const GLshort*>(&v1), const_cast<const GLshort*>(&v2));
}
void QOpenGLFunctions_3_2_Compatibility_GlRenderbufferStorage4(void* ptr, unsigned int target, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRenderbufferStorage(target, internalformat, width, height);
}
void QOpenGLFunctions_3_2_Compatibility_GlRenderbufferStorageMultisample4(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
}
void QOpenGLFunctions_3_2_Compatibility_GlResetHistogram4(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glResetHistogram(target);
}
void QOpenGLFunctions_3_2_Compatibility_GlResetMinmax4(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glResetMinmax(target);
}
void QOpenGLFunctions_3_2_Compatibility_GlRotatef4(void* ptr, float angle, float x, float y, float z)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glRotatef(angle, x, y, z);
}
void QOpenGLFunctions_3_2_Compatibility_GlSampleCoverage4(void* ptr, float value, char invert)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glSampleCoverage(value, invert != 0);
}
void QOpenGLFunctions_3_2_Compatibility_GlSampleMaski4(void* ptr, unsigned int index, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glSampleMaski(index, mask);
}
void QOpenGLFunctions_3_2_Compatibility_GlScalef4(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glScalef(x, y, z);
}
void QOpenGLFunctions_3_2_Compatibility_GlScissor4(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_3_2_Compatibility_GlSecondaryColor3f4(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glSecondaryColor3f(red, green, blue);
}
void QOpenGLFunctions_3_2_Compatibility_GlSecondaryColor3fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glSecondaryColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlSecondaryColor3i4(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glSecondaryColor3i(red, green, blue);
}
void QOpenGLFunctions_3_2_Compatibility_GlSecondaryColor3iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glSecondaryColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlSecondaryColor3s4(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glSecondaryColor3s(red, green, blue);
}
void QOpenGLFunctions_3_2_Compatibility_GlSecondaryColor3sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glSecondaryColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlSecondaryColor3ub4(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glSecondaryColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_3_2_Compatibility_GlSecondaryColor3ubv4(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glSecondaryColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_3_2_Compatibility_GlSecondaryColor3ui4(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glSecondaryColor3ui(red, green, blue);
}
void QOpenGLFunctions_3_2_Compatibility_GlSecondaryColor3uiv4(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glSecondaryColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlSecondaryColor3us4(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glSecondaryColor3us(red, green, blue);
}
void QOpenGLFunctions_3_2_Compatibility_GlSecondaryColor3usv4(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glSecondaryColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlSecondaryColorPointer4(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glSecondaryColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_3_2_Compatibility_GlSelectBuffer4(void* ptr, int size, unsigned int buffer)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glSelectBuffer(size, &buffer);
}
void QOpenGLFunctions_3_2_Compatibility_GlSeparableFilter2D4(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* row, void* column)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glSeparableFilter2D(target, internalformat, width, height, format, ty, row, column);
}
void QOpenGLFunctions_3_2_Compatibility_GlShadeModel4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glShadeModel(mode);
}
void QOpenGLFunctions_3_2_Compatibility_GlStencilFunc4(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_3_2_Compatibility_GlStencilFuncSeparate4(void* ptr, unsigned int face, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glStencilFuncSeparate(face, fu, ref, mask);
}
void QOpenGLFunctions_3_2_Compatibility_GlStencilMask4(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_3_2_Compatibility_GlStencilMaskSeparate4(void* ptr, unsigned int face, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glStencilMaskSeparate(face, mask);
}
void QOpenGLFunctions_3_2_Compatibility_GlStencilOp4(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_3_2_Compatibility_GlStencilOpSeparate4(void* ptr, unsigned int face, unsigned int sfail, unsigned int dpfail, unsigned int dppass)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glStencilOpSeparate(face, sfail, dpfail, dppass);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexBuffer4(void* ptr, unsigned int target, unsigned int internalformat, unsigned int buffer)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexBuffer(target, internalformat, buffer);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoord1f4(void* ptr, float s)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoord1f(s);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoord1fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoord1fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoord1i4(void* ptr, int s)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoord1i(s);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoord1iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoord1iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoord1s4(void* ptr, short s)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoord1s(s);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoord1sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoord1sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoord2f4(void* ptr, float s, float t)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoord2f(s, t);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoord2fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoord2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoord2i4(void* ptr, int s, int t)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoord2i(s, t);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoord2iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoord2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoord2s4(void* ptr, short s, short t)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoord2s(s, t);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoord2sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoord2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoord3f4(void* ptr, float s, float t, float r)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoord3f(s, t, r);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoord3fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoord3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoord3i4(void* ptr, int s, int t, int r)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoord3i(s, t, r);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoord3iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoord3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoord3s4(void* ptr, short s, short t, short r)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoord3s(s, t, r);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoord3sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoord3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoord4f4(void* ptr, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoord4f(s, t, r, q);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoord4fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoord4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoord4i4(void* ptr, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoord4i(s, t, r, q);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoord4iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoord4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoord4s4(void* ptr, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoord4s(s, t, r, q);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoord4sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoord4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlTexCoordPointer4(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexCoordPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexEnvf4(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexEnvf(target, pname, param);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexEnvfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexEnvfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_2_Compatibility_GlTexEnvi4(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexEnvi(target, pname, param);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexEnviv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexEnviv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_2_Compatibility_GlTexGenf4(void* ptr, unsigned int coord, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexGenf(coord, pname, param);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexGenfv4(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexGenfv(coord, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_2_Compatibility_GlTexGeni4(void* ptr, unsigned int coord, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexGeni(coord, pname, param);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexGeniv4(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexGeniv(coord, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_2_Compatibility_GlTexImage1D4(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexImage2D4(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexImage2DMultisample4(void* ptr, unsigned int target, int samples, int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexImage3D4(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexImage3DMultisample4(void* ptr, unsigned int target, int samples, int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexParameterIiv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexParameterIiv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_2_Compatibility_GlTexParameterIuiv4(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexParameterIuiv(target, pname, const_cast<const GLuint*>(&params));
}
void QOpenGLFunctions_3_2_Compatibility_GlTexParameterf4(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_2_Compatibility_GlTexParameteri4(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_2_Compatibility_GlTexSubImage1D4(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexSubImage2D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_3_2_Compatibility_GlTexSubImage3D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_3_2_Compatibility_GlTranslatef4(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glTranslatef(x, y, z);
}
void QOpenGLFunctions_3_2_Compatibility_GlUniform1f4(void* ptr, int location, float v0)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniform1f(location, v0);
}
void QOpenGLFunctions_3_2_Compatibility_GlUniform1fv4(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniform1fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Compatibility_GlUniform1i4(void* ptr, int location, int v0)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniform1i(location, v0);
}
void QOpenGLFunctions_3_2_Compatibility_GlUniform1iv4(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniform1iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_2_Compatibility_GlUniform1ui4(void* ptr, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniform1ui(location, v0);
}
void QOpenGLFunctions_3_2_Compatibility_GlUniform1uiv4(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniform1uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_2_Compatibility_GlUniform2f4(void* ptr, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniform2f(location, v0, v1);
}
void QOpenGLFunctions_3_2_Compatibility_GlUniform2fv4(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniform2fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Compatibility_GlUniform2i4(void* ptr, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniform2i(location, v0, v1);
}
void QOpenGLFunctions_3_2_Compatibility_GlUniform2iv4(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniform2iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_2_Compatibility_GlUniform2ui4(void* ptr, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniform2ui(location, v0, v1);
}
void QOpenGLFunctions_3_2_Compatibility_GlUniform2uiv4(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniform2uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_2_Compatibility_GlUniform3f4(void* ptr, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniform3f(location, v0, v1, v2);
}
void QOpenGLFunctions_3_2_Compatibility_GlUniform3fv4(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniform3fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Compatibility_GlUniform3i4(void* ptr, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniform3i(location, v0, v1, v2);
}
void QOpenGLFunctions_3_2_Compatibility_GlUniform3iv4(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniform3iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_2_Compatibility_GlUniform3ui4(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniform3ui(location, v0, v1, v2);
}
void QOpenGLFunctions_3_2_Compatibility_GlUniform3uiv4(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniform3uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_2_Compatibility_GlUniform4f4(void* ptr, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniform4f(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_3_2_Compatibility_GlUniform4fv4(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniform4fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Compatibility_GlUniform4i4(void* ptr, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniform4i(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_3_2_Compatibility_GlUniform4iv4(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniform4iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_2_Compatibility_GlUniform4ui4(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniform4ui(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_3_2_Compatibility_GlUniform4uiv4(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniform4uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_2_Compatibility_GlUniformBlockBinding4(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int uniformBlockBinding)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}
void QOpenGLFunctions_3_2_Compatibility_GlUniformMatrix2fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniformMatrix2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Compatibility_GlUniformMatrix2x3fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniformMatrix2x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Compatibility_GlUniformMatrix2x4fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniformMatrix2x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Compatibility_GlUniformMatrix3fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniformMatrix3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Compatibility_GlUniformMatrix3x2fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniformMatrix3x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Compatibility_GlUniformMatrix3x4fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniformMatrix3x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Compatibility_GlUniformMatrix4fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniformMatrix4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Compatibility_GlUniformMatrix4x2fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniformMatrix4x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Compatibility_GlUniformMatrix4x3fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUniformMatrix4x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Compatibility_GlUseProgram4(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glUseProgram(program);
}
void QOpenGLFunctions_3_2_Compatibility_GlValidateProgram4(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glValidateProgram(program);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertex2f4(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertex2f(x, y);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertex2fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertex2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertex2i4(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertex2i(x, y);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertex2iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertex2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertex2s4(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertex2s(x, y);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertex2sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertex2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertex3f4(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertex3f(x, y, z);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertex3fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertex3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertex3i4(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertex3i(x, y, z);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertex3iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertex3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertex3s4(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertex3s(x, y, z);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertex3sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertex3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertex4f4(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertex4f(x, y, z, w);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertex4fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertex4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertex4i4(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertex4i(x, y, z, w);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertex4iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertex4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertex4s4(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertex4s(x, y, z, w);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertex4sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertex4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib1f4(void* ptr, unsigned int index, float x)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib1f(index, x);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib1fv4(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib1fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib1s4(void* ptr, unsigned int index, short x)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib1s(index, x);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib1sv4(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib1sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib2f4(void* ptr, unsigned int index, float x, float y)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib2f(index, x, y);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib2fv4(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib2fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib2s4(void* ptr, unsigned int index, short x, short y)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib2s(index, x, y);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib2sv4(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib2sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib3f4(void* ptr, unsigned int index, float x, float y, float z)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib3f(index, x, y, z);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib3fv4(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib3fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib3s4(void* ptr, unsigned int index, short x, short y, short z)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib3s(index, x, y, z);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib3sv4(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib3sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib4Niv4(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib4Niv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib4Nsv4(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib4Nsv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib4Nub4(void* ptr, unsigned int index, char* x, char* y, char* z, char* w)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib4Nub(index, *static_cast<GLubyte*>(static_cast<void*>(x)), *static_cast<GLubyte*>(static_cast<void*>(y)), *static_cast<GLubyte*>(static_cast<void*>(z)), *static_cast<GLubyte*>(static_cast<void*>(w)));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib4Nubv4(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib4Nubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib4Nuiv4(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib4Nuiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib4Nusv4(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib4Nusv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib4f4(void* ptr, unsigned int index, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib4f(index, x, y, z, w);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib4fv4(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib4fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib4iv4(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib4s4(void* ptr, unsigned int index, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib4s(index, x, y, z, w);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib4sv4(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib4sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib4ubv4(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib4ubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib4uiv4(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttrib4usv4(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttrib4usv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttribI1i4(void* ptr, unsigned int index, int x)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttribI1i(index, x);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttribI1iv4(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttribI1iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttribI1ui4(void* ptr, unsigned int index, unsigned int x)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttribI1ui(index, x);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttribI1uiv4(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttribI1uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttribI2i4(void* ptr, unsigned int index, int x, int y)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttribI2i(index, x, y);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttribI2iv4(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttribI2iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttribI2ui4(void* ptr, unsigned int index, unsigned int x, unsigned int y)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttribI2ui(index, x, y);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttribI2uiv4(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttribI2uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttribI3i4(void* ptr, unsigned int index, int x, int y, int z)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttribI3i(index, x, y, z);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttribI3iv4(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttribI3iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttribI3ui4(void* ptr, unsigned int index, unsigned int x, unsigned int y, unsigned int z)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttribI3ui(index, x, y, z);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttribI3uiv4(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttribI3uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttribI4i4(void* ptr, unsigned int index, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttribI4i(index, x, y, z, w);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttribI4iv4(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttribI4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttribI4sv4(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttribI4sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttribI4ubv4(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttribI4ubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttribI4ui4(void* ptr, unsigned int index, unsigned int x, unsigned int y, unsigned int z, unsigned int w)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttribI4ui(index, x, y, z, w);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttribI4uiv4(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttribI4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttribI4usv4(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttribI4usv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttribIPointer4(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttribIPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexAttribPointer4(void* ptr, unsigned int index, int size, unsigned int ty, char normalized, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexAttribPointer(index, size, ty, normalized != 0, stride, pointer);
}
void QOpenGLFunctions_3_2_Compatibility_GlVertexPointer4(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glVertexPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_3_2_Compatibility_GlViewport4(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_3_2_Compatibility_GlWindowPos2f4(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glWindowPos2f(x, y);
}
void QOpenGLFunctions_3_2_Compatibility_GlWindowPos2fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glWindowPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlWindowPos2i4(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glWindowPos2i(x, y);
}
void QOpenGLFunctions_3_2_Compatibility_GlWindowPos2iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glWindowPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlWindowPos2s4(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glWindowPos2s(x, y);
}
void QOpenGLFunctions_3_2_Compatibility_GlWindowPos2sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glWindowPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlWindowPos3f4(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glWindowPos3f(x, y, z);
}
void QOpenGLFunctions_3_2_Compatibility_GlWindowPos3fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glWindowPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlWindowPos3i4(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glWindowPos3i(x, y, z);
}
void QOpenGLFunctions_3_2_Compatibility_GlWindowPos3iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glWindowPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_GlWindowPos3s4(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glWindowPos3s(x, y, z);
}
void QOpenGLFunctions_3_2_Compatibility_GlWindowPos3sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->glWindowPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_2_Compatibility_DestroyQOpenGLFunctions_3_2_Compatibility4(void* ptr)
{
static_cast<QOpenGLFunctions_3_2_Compatibility*>(ptr)->~QOpenGLFunctions_3_2_Compatibility();
}
void QOpenGLFunctions_3_2_Compatibility_DestroyQOpenGLFunctions_3_2_Compatibility4Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_3_2_Core: public QOpenGLFunctions_3_2_Core
{
public:
MyQOpenGLFunctions_3_2_Core() : QOpenGLFunctions_3_2_Core() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_3_2_Core_InitializeOpenGLFunctions4(this) != 0; };
~MyQOpenGLFunctions_3_2_Core() { callbackQOpenGLFunctions_3_2_Core_DestroyQOpenGLFunctions_3_2_Core4(this); };
};
char QOpenGLFunctions_3_2_Core_GlIsBuffer4(void* ptr, unsigned int buffer)
{
return static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glIsBuffer(buffer);
}
char QOpenGLFunctions_3_2_Core_GlIsEnabled4(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_3_2_Core_GlIsEnabledi4(void* ptr, unsigned int target, unsigned int index)
{
return static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glIsEnabledi(target, index);
}
char QOpenGLFunctions_3_2_Core_GlIsFramebuffer4(void* ptr, unsigned int framebuffer)
{
return static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glIsFramebuffer(framebuffer);
}
char QOpenGLFunctions_3_2_Core_GlIsProgram4(void* ptr, unsigned int program)
{
return static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glIsProgram(program);
}
char QOpenGLFunctions_3_2_Core_GlIsQuery4(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glIsQuery(id);
}
char QOpenGLFunctions_3_2_Core_GlIsRenderbuffer4(void* ptr, unsigned int renderbuffer)
{
return static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glIsRenderbuffer(renderbuffer);
}
char QOpenGLFunctions_3_2_Core_GlIsShader4(void* ptr, unsigned int shader)
{
return static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glIsShader(shader);
}
char QOpenGLFunctions_3_2_Core_GlIsTexture4(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glIsTexture(texture);
}
char QOpenGLFunctions_3_2_Core_GlIsVertexArray4(void* ptr, unsigned int array)
{
return static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glIsVertexArray(array);
}
char QOpenGLFunctions_3_2_Core_GlUnmapBuffer4(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUnmapBuffer(target);
}
unsigned int QOpenGLFunctions_3_2_Core_GlCheckFramebufferStatus4(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glCheckFramebufferStatus(target);
}
unsigned int QOpenGLFunctions_3_2_Core_GlGetError4(void* ptr)
{
return static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetError();
}
unsigned int QOpenGLFunctions_3_2_Core_GlCreateProgram4(void* ptr)
{
return static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glCreateProgram();
}
unsigned int QOpenGLFunctions_3_2_Core_GlCreateShader4(void* ptr, unsigned int ty)
{
return static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glCreateShader(ty);
}
void* QOpenGLFunctions_3_2_Core_GlMapBuffer4(void* ptr, unsigned int target, unsigned int access)
{
return static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glMapBuffer(target, access);
}
void* QOpenGLFunctions_3_2_Core_NewQOpenGLFunctions_3_2_Core4()
{
return new MyQOpenGLFunctions_3_2_Core();
}
char QOpenGLFunctions_3_2_Core_InitializeOpenGLFunctions4(void* ptr)
{
return static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_3_2_Core_InitializeOpenGLFunctions4Default(void* ptr)
{
return static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->QOpenGLFunctions_3_2_Core::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_3_2_Core_GlGetString4(void* ptr, unsigned int name)
{
return ({ char* tb15178 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetString(name)))); QtGui_PackedString { tb15178, -1 }; });
}
struct QtGui_PackedString QOpenGLFunctions_3_2_Core_GlGetStringi4(void* ptr, unsigned int name, unsigned int index)
{
return ({ char* t5b0d9f = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetStringi(name, index)))); QtGui_PackedString { t5b0d9f, -1 }; });
}
void QOpenGLFunctions_3_2_Core_GlActiveTexture4(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glActiveTexture(texture);
}
void QOpenGLFunctions_3_2_Core_GlAttachShader4(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glAttachShader(program, shader);
}
void QOpenGLFunctions_3_2_Core_GlBeginConditionalRender4(void* ptr, unsigned int id, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glBeginConditionalRender(id, mode);
}
void QOpenGLFunctions_3_2_Core_GlBeginQuery4(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glBeginQuery(target, id);
}
void QOpenGLFunctions_3_2_Core_GlBeginTransformFeedback4(void* ptr, unsigned int primitiveMode)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glBeginTransformFeedback(primitiveMode);
}
void QOpenGLFunctions_3_2_Core_GlBindBuffer4(void* ptr, unsigned int target, unsigned int buffer)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glBindBuffer(target, buffer);
}
void QOpenGLFunctions_3_2_Core_GlBindBufferBase4(void* ptr, unsigned int target, unsigned int index, unsigned int buffer)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glBindBufferBase(target, index, buffer);
}
void QOpenGLFunctions_3_2_Core_GlBindFramebuffer4(void* ptr, unsigned int target, unsigned int framebuffer)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glBindFramebuffer(target, framebuffer);
}
void QOpenGLFunctions_3_2_Core_GlBindRenderbuffer4(void* ptr, unsigned int target, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glBindRenderbuffer(target, renderbuffer);
}
void QOpenGLFunctions_3_2_Core_GlBindTexture4(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_3_2_Core_GlBindVertexArray4(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glBindVertexArray(array);
}
void QOpenGLFunctions_3_2_Core_GlBlendColor4(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_3_2_Core_GlBlendEquation4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_3_2_Core_GlBlendEquationSeparate4(void* ptr, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glBlendEquationSeparate(modeRGB, modeAlpha);
}
void QOpenGLFunctions_3_2_Core_GlBlendFunc4(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_3_2_Core_GlBlendFuncSeparate4(void* ptr, unsigned int sfactorRGB, unsigned int dfactorRGB, unsigned int sfactorAlpha, unsigned int dfactorAlpha)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void QOpenGLFunctions_3_2_Core_GlBlitFramebuffer4(void* ptr, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, unsigned int mask, unsigned int filter)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
void QOpenGLFunctions_3_2_Core_GlClampColor4(void* ptr, unsigned int target, unsigned int clamp)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glClampColor(target, clamp);
}
void QOpenGLFunctions_3_2_Core_GlClear4(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_3_2_Core_GlClearBufferfi4(void* ptr, unsigned int buffer, int drawbuffer, float depth, int stencil)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glClearBufferfi(buffer, drawbuffer, depth, stencil);
}
void QOpenGLFunctions_3_2_Core_GlClearBufferfv4(void* ptr, unsigned int buffer, int drawbuffer, float value)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glClearBufferfv(buffer, drawbuffer, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Core_GlClearBufferiv4(void* ptr, unsigned int buffer, int drawbuffer, int value)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glClearBufferiv(buffer, drawbuffer, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_2_Core_GlClearBufferuiv4(void* ptr, unsigned int buffer, int drawbuffer, unsigned int value)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glClearBufferuiv(buffer, drawbuffer, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_2_Core_GlClearColor4(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_3_2_Core_GlClearStencil4(void* ptr, int s)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_3_2_Core_GlColorMask4(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_3_2_Core_GlColorMaski4(void* ptr, unsigned int index, char r, char g, char b, char a)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glColorMaski(index, r != 0, g != 0, b != 0, a != 0);
}
void QOpenGLFunctions_3_2_Core_GlCompileShader4(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glCompileShader(shader);
}
void QOpenGLFunctions_3_2_Core_GlCompressedTexImage1D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
void QOpenGLFunctions_3_2_Core_GlCompressedTexImage2D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void QOpenGLFunctions_3_2_Core_GlCompressedTexImage3D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int depth, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void QOpenGLFunctions_3_2_Core_GlCompressedTexSubImage1D4(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_3_2_Core_GlCompressedTexSubImage2D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_3_2_Core_GlCompressedTexSubImage3D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_3_2_Core_GlCopyTexImage1D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_3_2_Core_GlCopyTexImage2D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_3_2_Core_GlCopyTexSubImage1D4(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_3_2_Core_GlCopyTexSubImage2D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_3_2_Core_GlCopyTexSubImage3D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_3_2_Core_GlCullFace4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_3_2_Core_GlDeleteBuffers4(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glDeleteBuffers(n, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_3_2_Core_GlDeleteFramebuffers4(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glDeleteFramebuffers(n, const_cast<const GLuint*>(&framebuffers));
}
void QOpenGLFunctions_3_2_Core_GlDeleteProgram4(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glDeleteProgram(program);
}
void QOpenGLFunctions_3_2_Core_GlDeleteQueries4(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glDeleteQueries(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_3_2_Core_GlDeleteRenderbuffers4(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glDeleteRenderbuffers(n, const_cast<const GLuint*>(&renderbuffers));
}
void QOpenGLFunctions_3_2_Core_GlDeleteShader4(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glDeleteShader(shader);
}
void QOpenGLFunctions_3_2_Core_GlDeleteTextures4(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_3_2_Core_GlDeleteVertexArrays4(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glDeleteVertexArrays(n, const_cast<const GLuint*>(&arrays));
}
void QOpenGLFunctions_3_2_Core_GlDepthFunc4(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_3_2_Core_GlDepthMask4(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_3_2_Core_GlDetachShader4(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glDetachShader(program, shader);
}
void QOpenGLFunctions_3_2_Core_GlDisable4(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_3_2_Core_GlDisableVertexAttribArray4(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glDisableVertexAttribArray(index);
}
void QOpenGLFunctions_3_2_Core_GlDisablei4(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glDisablei(target, index);
}
void QOpenGLFunctions_3_2_Core_GlDrawArrays4(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_3_2_Core_GlDrawArraysInstanced4(void* ptr, unsigned int mode, int first, int count, int instancecount)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glDrawArraysInstanced(mode, first, count, instancecount);
}
void QOpenGLFunctions_3_2_Core_GlDrawBuffer4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glDrawBuffer(mode);
}
void QOpenGLFunctions_3_2_Core_GlDrawBuffers4(void* ptr, int n, unsigned int bufs)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glDrawBuffers(n, const_cast<const GLenum*>(&bufs));
}
void QOpenGLFunctions_3_2_Core_GlDrawElements4(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_3_2_Core_GlDrawElementsBaseVertex4(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glDrawElementsBaseVertex(mode, count, ty, indices, basevertex);
}
void QOpenGLFunctions_3_2_Core_GlDrawElementsInstanced4(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glDrawElementsInstanced(mode, count, ty, indices, instancecount);
}
void QOpenGLFunctions_3_2_Core_GlDrawElementsInstancedBaseVertex4(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glDrawElementsInstancedBaseVertex(mode, count, ty, indices, instancecount, basevertex);
}
void QOpenGLFunctions_3_2_Core_GlDrawRangeElements4(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLFunctions_3_2_Core_GlDrawRangeElementsBaseVertex4(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glDrawRangeElementsBaseVertex(mode, start, end, count, ty, indices, basevertex);
}
void QOpenGLFunctions_3_2_Core_GlEnable4(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_3_2_Core_GlEnableVertexAttribArray4(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glEnableVertexAttribArray(index);
}
void QOpenGLFunctions_3_2_Core_GlEnablei4(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glEnablei(target, index);
}
void QOpenGLFunctions_3_2_Core_GlEndConditionalRender4(void* ptr)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glEndConditionalRender();
}
void QOpenGLFunctions_3_2_Core_GlEndQuery4(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glEndQuery(target);
}
void QOpenGLFunctions_3_2_Core_GlEndTransformFeedback4(void* ptr)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glEndTransformFeedback();
}
void QOpenGLFunctions_3_2_Core_GlFinish4(void* ptr)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glFinish();
}
void QOpenGLFunctions_3_2_Core_GlFlush4(void* ptr)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glFlush();
}
void QOpenGLFunctions_3_2_Core_GlFramebufferRenderbuffer4(void* ptr, unsigned int target, unsigned int attachment, unsigned int renderbuffertarget, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
void QOpenGLFunctions_3_2_Core_GlFramebufferTexture4(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glFramebufferTexture(target, attachment, texture, level);
}
void QOpenGLFunctions_3_2_Core_GlFramebufferTexture1D4(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glFramebufferTexture1D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_3_2_Core_GlFramebufferTexture2D4(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_3_2_Core_GlFramebufferTexture3D4(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level, int zoffset)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}
void QOpenGLFunctions_3_2_Core_GlFramebufferTextureLayer4(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level, int layer)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glFramebufferTextureLayer(target, attachment, texture, level, layer);
}
void QOpenGLFunctions_3_2_Core_GlFrontFace4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_3_2_Core_GlGenBuffers4(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGenBuffers(n, &buffers);
}
void QOpenGLFunctions_3_2_Core_GlGenFramebuffers4(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGenFramebuffers(n, &framebuffers);
}
void QOpenGLFunctions_3_2_Core_GlGenQueries4(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGenQueries(n, &ids);
}
void QOpenGLFunctions_3_2_Core_GlGenRenderbuffers4(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGenRenderbuffers(n, &renderbuffers);
}
void QOpenGLFunctions_3_2_Core_GlGenTextures4(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_3_2_Core_GlGenVertexArrays4(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGenVertexArrays(n, &arrays);
}
void QOpenGLFunctions_3_2_Core_GlGenerateMipmap4(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGenerateMipmap(target);
}
void QOpenGLFunctions_3_2_Core_GlGetActiveUniformBlockiv4(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetActiveUniformsiv4(void* ptr, unsigned int program, int uniformCount, unsigned int uniformIndices, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetActiveUniformsiv(program, uniformCount, const_cast<const GLuint*>(&uniformIndices), pname, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetAttachedShaders4(void* ptr, unsigned int program, int maxCount, int count, unsigned int obj)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetAttachedShaders(program, maxCount, &count, &obj);
}
void QOpenGLFunctions_3_2_Core_GlGetBooleani_v4(void* ptr, unsigned int target, unsigned int index, char data)
{
Q_UNUSED(data);
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetBooleani_v(target, index, NULL);
}
void QOpenGLFunctions_3_2_Core_GlGetBooleanv4(void* ptr, unsigned int pname, char params)
{
Q_UNUSED(params);
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_3_2_Core_GlGetBufferParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetBufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetBufferPointerv4(void* ptr, unsigned int target, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetBufferPointerv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetCompressedTexImage4(void* ptr, unsigned int target, int level, void* img)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetCompressedTexImage(target, level, img);
}
void QOpenGLFunctions_3_2_Core_GlGetFloatv4(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetFloatv(pname, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetFramebufferAttachmentParameteriv4(void* ptr, unsigned int target, unsigned int attachment, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetFramebufferAttachmentParameteriv(target, attachment, pname, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetIntegeri_v4(void* ptr, unsigned int target, unsigned int index, int data)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetIntegeri_v(target, index, &data);
}
void QOpenGLFunctions_3_2_Core_GlGetIntegerv4(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetIntegerv(pname, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetMultisamplefv4(void* ptr, unsigned int pname, unsigned int index, float val)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetMultisamplefv(pname, index, &val);
}
void QOpenGLFunctions_3_2_Core_GlGetPointerv4(void* ptr, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetPointerv(pname, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetProgramiv4(void* ptr, unsigned int program, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetProgramiv(program, pname, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetQueryObjectiv4(void* ptr, unsigned int id, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetQueryObjectiv(id, pname, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetQueryObjectuiv4(void* ptr, unsigned int id, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetQueryObjectuiv(id, pname, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetQueryiv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetQueryiv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetRenderbufferParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetRenderbufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetShaderiv4(void* ptr, unsigned int shader, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetShaderiv(shader, pname, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetTexImage4(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_3_2_Core_GlGetTexLevelParameterfv4(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetTexLevelParameteriv4(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetTexParameterIiv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetTexParameterIiv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetTexParameterIuiv4(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetTexParameterIuiv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetTexParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetTexParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetUniformfv4(void* ptr, unsigned int program, int location, float params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetUniformfv(program, location, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetUniformiv4(void* ptr, unsigned int program, int location, int params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetUniformiv(program, location, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetUniformuiv4(void* ptr, unsigned int program, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetUniformuiv(program, location, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetVertexAttribIiv4(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetVertexAttribIiv(index, pname, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetVertexAttribIuiv4(void* ptr, unsigned int index, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetVertexAttribIuiv(index, pname, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetVertexAttribPointerv4(void* ptr, unsigned int index, unsigned int pname, void* pointer)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetVertexAttribPointerv(index, pname, &pointer);
}
void QOpenGLFunctions_3_2_Core_GlGetVertexAttribfv4(void* ptr, unsigned int index, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetVertexAttribfv(index, pname, &params);
}
void QOpenGLFunctions_3_2_Core_GlGetVertexAttribiv4(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glGetVertexAttribiv(index, pname, &params);
}
void QOpenGLFunctions_3_2_Core_GlHint4(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_3_2_Core_GlIndexub4(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glIndexub(*static_cast<GLubyte*>(static_cast<void*>(c)));
}
void QOpenGLFunctions_3_2_Core_GlIndexubv4(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glIndexubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(c))));
}
void QOpenGLFunctions_3_2_Core_GlLineWidth4(void* ptr, float width)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_3_2_Core_GlLinkProgram4(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glLinkProgram(program);
}
void QOpenGLFunctions_3_2_Core_GlLogicOp4(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_3_2_Core_GlMultiDrawArrays4(void* ptr, unsigned int mode, int first, int count, int drawcount)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glMultiDrawArrays(mode, const_cast<const GLint*>(&first), const_cast<const GLsizei*>(&count), drawcount);
}
void QOpenGLFunctions_3_2_Core_GlPixelStoref4(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_3_2_Core_GlPixelStorei4(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_3_2_Core_GlPointParameterf4(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glPointParameterf(pname, param);
}
void QOpenGLFunctions_3_2_Core_GlPointParameterfv4(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glPointParameterfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_2_Core_GlPointParameteri4(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glPointParameteri(pname, param);
}
void QOpenGLFunctions_3_2_Core_GlPointParameteriv4(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glPointParameteriv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_2_Core_GlPointSize4(void* ptr, float size)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_3_2_Core_GlPolygonMode4(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_3_2_Core_GlPolygonOffset4(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_3_2_Core_GlPrimitiveRestartIndex4(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glPrimitiveRestartIndex(index);
}
void QOpenGLFunctions_3_2_Core_GlProvokingVertex4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glProvokingVertex(mode);
}
void QOpenGLFunctions_3_2_Core_GlReadBuffer4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glReadBuffer(mode);
}
void QOpenGLFunctions_3_2_Core_GlReadPixels4(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_3_2_Core_GlRenderbufferStorage4(void* ptr, unsigned int target, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glRenderbufferStorage(target, internalformat, width, height);
}
void QOpenGLFunctions_3_2_Core_GlRenderbufferStorageMultisample4(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
}
void QOpenGLFunctions_3_2_Core_GlSampleCoverage4(void* ptr, float value, char invert)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glSampleCoverage(value, invert != 0);
}
void QOpenGLFunctions_3_2_Core_GlSampleMaski4(void* ptr, unsigned int index, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glSampleMaski(index, mask);
}
void QOpenGLFunctions_3_2_Core_GlScissor4(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_3_2_Core_GlStencilFunc4(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_3_2_Core_GlStencilFuncSeparate4(void* ptr, unsigned int face, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glStencilFuncSeparate(face, fu, ref, mask);
}
void QOpenGLFunctions_3_2_Core_GlStencilMask4(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_3_2_Core_GlStencilMaskSeparate4(void* ptr, unsigned int face, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glStencilMaskSeparate(face, mask);
}
void QOpenGLFunctions_3_2_Core_GlStencilOp4(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_3_2_Core_GlStencilOpSeparate4(void* ptr, unsigned int face, unsigned int sfail, unsigned int dpfail, unsigned int dppass)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glStencilOpSeparate(face, sfail, dpfail, dppass);
}
void QOpenGLFunctions_3_2_Core_GlTexBuffer4(void* ptr, unsigned int target, unsigned int internalformat, unsigned int buffer)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glTexBuffer(target, internalformat, buffer);
}
void QOpenGLFunctions_3_2_Core_GlTexImage1D4(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_3_2_Core_GlTexImage2D4(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_3_2_Core_GlTexImage2DMultisample4(void* ptr, unsigned int target, int samples, int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLFunctions_3_2_Core_GlTexImage3D4(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLFunctions_3_2_Core_GlTexImage3DMultisample4(void* ptr, unsigned int target, int samples, int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLFunctions_3_2_Core_GlTexParameterIiv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glTexParameterIiv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_2_Core_GlTexParameterIuiv4(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glTexParameterIuiv(target, pname, const_cast<const GLuint*>(&params));
}
void QOpenGLFunctions_3_2_Core_GlTexParameterf4(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_3_2_Core_GlTexParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_2_Core_GlTexParameteri4(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_3_2_Core_GlTexParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_2_Core_GlTexSubImage1D4(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_3_2_Core_GlTexSubImage2D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_3_2_Core_GlTexSubImage3D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_3_2_Core_GlUniform1f4(void* ptr, int location, float v0)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniform1f(location, v0);
}
void QOpenGLFunctions_3_2_Core_GlUniform1fv4(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniform1fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Core_GlUniform1i4(void* ptr, int location, int v0)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniform1i(location, v0);
}
void QOpenGLFunctions_3_2_Core_GlUniform1iv4(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniform1iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_2_Core_GlUniform1ui4(void* ptr, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniform1ui(location, v0);
}
void QOpenGLFunctions_3_2_Core_GlUniform1uiv4(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniform1uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_2_Core_GlUniform2f4(void* ptr, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniform2f(location, v0, v1);
}
void QOpenGLFunctions_3_2_Core_GlUniform2fv4(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniform2fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Core_GlUniform2i4(void* ptr, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniform2i(location, v0, v1);
}
void QOpenGLFunctions_3_2_Core_GlUniform2iv4(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniform2iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_2_Core_GlUniform2ui4(void* ptr, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniform2ui(location, v0, v1);
}
void QOpenGLFunctions_3_2_Core_GlUniform2uiv4(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniform2uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_2_Core_GlUniform3f4(void* ptr, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniform3f(location, v0, v1, v2);
}
void QOpenGLFunctions_3_2_Core_GlUniform3fv4(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniform3fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Core_GlUniform3i4(void* ptr, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniform3i(location, v0, v1, v2);
}
void QOpenGLFunctions_3_2_Core_GlUniform3iv4(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniform3iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_2_Core_GlUniform3ui4(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniform3ui(location, v0, v1, v2);
}
void QOpenGLFunctions_3_2_Core_GlUniform3uiv4(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniform3uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_2_Core_GlUniform4f4(void* ptr, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniform4f(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_3_2_Core_GlUniform4fv4(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniform4fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Core_GlUniform4i4(void* ptr, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniform4i(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_3_2_Core_GlUniform4iv4(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniform4iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_2_Core_GlUniform4ui4(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniform4ui(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_3_2_Core_GlUniform4uiv4(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniform4uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_2_Core_GlUniformBlockBinding4(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int uniformBlockBinding)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}
void QOpenGLFunctions_3_2_Core_GlUniformMatrix2fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniformMatrix2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Core_GlUniformMatrix2x3fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniformMatrix2x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Core_GlUniformMatrix2x4fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniformMatrix2x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Core_GlUniformMatrix3fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniformMatrix3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Core_GlUniformMatrix3x2fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniformMatrix3x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Core_GlUniformMatrix3x4fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniformMatrix3x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Core_GlUniformMatrix4fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniformMatrix4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Core_GlUniformMatrix4x2fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniformMatrix4x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Core_GlUniformMatrix4x3fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUniformMatrix4x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_2_Core_GlUseProgram4(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glUseProgram(program);
}
void QOpenGLFunctions_3_2_Core_GlValidateProgram4(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glValidateProgram(program);
}
void QOpenGLFunctions_3_2_Core_GlVertexAttribIPointer4(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glVertexAttribIPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_3_2_Core_GlVertexAttribPointer4(void* ptr, unsigned int index, int size, unsigned int ty, char normalized, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glVertexAttribPointer(index, size, ty, normalized != 0, stride, pointer);
}
void QOpenGLFunctions_3_2_Core_GlViewport4(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_3_2_Core_DestroyQOpenGLFunctions_3_2_Core4(void* ptr)
{
static_cast<QOpenGLFunctions_3_2_Core*>(ptr)->~QOpenGLFunctions_3_2_Core();
}
void QOpenGLFunctions_3_2_Core_DestroyQOpenGLFunctions_3_2_Core4Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_3_3_Compatibility: public QOpenGLFunctions_3_3_Compatibility
{
public:
MyQOpenGLFunctions_3_3_Compatibility() : QOpenGLFunctions_3_3_Compatibility() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_3_3_Compatibility_InitializeOpenGLFunctions4(this) != 0; };
~MyQOpenGLFunctions_3_3_Compatibility() { callbackQOpenGLFunctions_3_3_Compatibility_DestroyQOpenGLFunctions_3_3_Compatibility4(this); };
};
char QOpenGLFunctions_3_3_Compatibility_GlAreTexturesResident4(void* ptr, int n, unsigned int textures, char residences)
{
Q_UNUSED(residences);
return static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glAreTexturesResident(n, const_cast<const GLuint*>(&textures), NULL);
}
char QOpenGLFunctions_3_3_Compatibility_GlIsBuffer4(void* ptr, unsigned int buffer)
{
return static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glIsBuffer(buffer);
}
char QOpenGLFunctions_3_3_Compatibility_GlIsEnabled4(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_3_3_Compatibility_GlIsEnabledi4(void* ptr, unsigned int target, unsigned int index)
{
return static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glIsEnabledi(target, index);
}
char QOpenGLFunctions_3_3_Compatibility_GlIsFramebuffer4(void* ptr, unsigned int framebuffer)
{
return static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glIsFramebuffer(framebuffer);
}
char QOpenGLFunctions_3_3_Compatibility_GlIsList4(void* ptr, unsigned int list)
{
return static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glIsList(list);
}
char QOpenGLFunctions_3_3_Compatibility_GlIsProgram4(void* ptr, unsigned int program)
{
return static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glIsProgram(program);
}
char QOpenGLFunctions_3_3_Compatibility_GlIsQuery4(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glIsQuery(id);
}
char QOpenGLFunctions_3_3_Compatibility_GlIsRenderbuffer4(void* ptr, unsigned int renderbuffer)
{
return static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glIsRenderbuffer(renderbuffer);
}
char QOpenGLFunctions_3_3_Compatibility_GlIsSampler4(void* ptr, unsigned int sampler)
{
return static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glIsSampler(sampler);
}
char QOpenGLFunctions_3_3_Compatibility_GlIsShader4(void* ptr, unsigned int shader)
{
return static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glIsShader(shader);
}
char QOpenGLFunctions_3_3_Compatibility_GlIsTexture4(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glIsTexture(texture);
}
char QOpenGLFunctions_3_3_Compatibility_GlIsVertexArray4(void* ptr, unsigned int array)
{
return static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glIsVertexArray(array);
}
char QOpenGLFunctions_3_3_Compatibility_GlUnmapBuffer4(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUnmapBuffer(target);
}
unsigned int QOpenGLFunctions_3_3_Compatibility_GlCheckFramebufferStatus4(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glCheckFramebufferStatus(target);
}
unsigned int QOpenGLFunctions_3_3_Compatibility_GlGetError4(void* ptr)
{
return static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetError();
}
int QOpenGLFunctions_3_3_Compatibility_GlRenderMode4(void* ptr, unsigned int mode)
{
return static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRenderMode(mode);
}
unsigned int QOpenGLFunctions_3_3_Compatibility_GlCreateProgram4(void* ptr)
{
return static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glCreateProgram();
}
unsigned int QOpenGLFunctions_3_3_Compatibility_GlCreateShader4(void* ptr, unsigned int ty)
{
return static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glCreateShader(ty);
}
unsigned int QOpenGLFunctions_3_3_Compatibility_GlGenLists4(void* ptr, int ran)
{
return static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGenLists(ran);
}
void* QOpenGLFunctions_3_3_Compatibility_GlMapBuffer4(void* ptr, unsigned int target, unsigned int access)
{
return static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMapBuffer(target, access);
}
void* QOpenGLFunctions_3_3_Compatibility_NewQOpenGLFunctions_3_3_Compatibility4()
{
return new MyQOpenGLFunctions_3_3_Compatibility();
}
char QOpenGLFunctions_3_3_Compatibility_InitializeOpenGLFunctions4(void* ptr)
{
return static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_3_3_Compatibility_InitializeOpenGLFunctions4Default(void* ptr)
{
return static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->QOpenGLFunctions_3_3_Compatibility::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_3_3_Compatibility_GlGetString4(void* ptr, unsigned int name)
{
return ({ char* t77eaa8 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetString(name)))); QtGui_PackedString { t77eaa8, -1 }; });
}
struct QtGui_PackedString QOpenGLFunctions_3_3_Compatibility_GlGetStringi4(void* ptr, unsigned int name, unsigned int index)
{
return ({ char* t9343fd = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetStringi(name, index)))); QtGui_PackedString { t9343fd, -1 }; });
}
void QOpenGLFunctions_3_3_Compatibility_GlAccum4(void* ptr, unsigned int op, float value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glAccum(op, value);
}
void QOpenGLFunctions_3_3_Compatibility_GlActiveTexture4(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glActiveTexture(texture);
}
void QOpenGLFunctions_3_3_Compatibility_GlAlphaFunc4(void* ptr, unsigned int fu, float ref)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glAlphaFunc(fu, ref);
}
void QOpenGLFunctions_3_3_Compatibility_GlArrayElement4(void* ptr, int i)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glArrayElement(i);
}
void QOpenGLFunctions_3_3_Compatibility_GlAttachShader4(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glAttachShader(program, shader);
}
void QOpenGLFunctions_3_3_Compatibility_GlBegin4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glBegin(mode);
}
void QOpenGLFunctions_3_3_Compatibility_GlBeginConditionalRender4(void* ptr, unsigned int id, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glBeginConditionalRender(id, mode);
}
void QOpenGLFunctions_3_3_Compatibility_GlBeginQuery4(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glBeginQuery(target, id);
}
void QOpenGLFunctions_3_3_Compatibility_GlBeginTransformFeedback4(void* ptr, unsigned int primitiveMode)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glBeginTransformFeedback(primitiveMode);
}
void QOpenGLFunctions_3_3_Compatibility_GlBindBuffer4(void* ptr, unsigned int target, unsigned int buffer)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glBindBuffer(target, buffer);
}
void QOpenGLFunctions_3_3_Compatibility_GlBindBufferBase4(void* ptr, unsigned int target, unsigned int index, unsigned int buffer)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glBindBufferBase(target, index, buffer);
}
void QOpenGLFunctions_3_3_Compatibility_GlBindFramebuffer4(void* ptr, unsigned int target, unsigned int framebuffer)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glBindFramebuffer(target, framebuffer);
}
void QOpenGLFunctions_3_3_Compatibility_GlBindRenderbuffer4(void* ptr, unsigned int target, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glBindRenderbuffer(target, renderbuffer);
}
void QOpenGLFunctions_3_3_Compatibility_GlBindSampler4(void* ptr, unsigned int unit, unsigned int sampler)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glBindSampler(unit, sampler);
}
void QOpenGLFunctions_3_3_Compatibility_GlBindTexture4(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_3_3_Compatibility_GlBindVertexArray4(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glBindVertexArray(array);
}
void QOpenGLFunctions_3_3_Compatibility_GlBitmap4(void* ptr, int width, int height, float xorig, float yorig, float xmove, float ymove, char* bitmap)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glBitmap(width, height, xorig, yorig, xmove, ymove, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(bitmap))));
}
void QOpenGLFunctions_3_3_Compatibility_GlBlendColor4(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_3_3_Compatibility_GlBlendEquation4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_3_3_Compatibility_GlBlendEquationSeparate4(void* ptr, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glBlendEquationSeparate(modeRGB, modeAlpha);
}
void QOpenGLFunctions_3_3_Compatibility_GlBlendFunc4(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_3_3_Compatibility_GlBlendFuncSeparate4(void* ptr, unsigned int sfactorRGB, unsigned int dfactorRGB, unsigned int sfactorAlpha, unsigned int dfactorAlpha)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void QOpenGLFunctions_3_3_Compatibility_GlBlitFramebuffer4(void* ptr, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, unsigned int mask, unsigned int filter)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
void QOpenGLFunctions_3_3_Compatibility_GlCallList4(void* ptr, unsigned int list)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glCallList(list);
}
void QOpenGLFunctions_3_3_Compatibility_GlCallLists4(void* ptr, int n, unsigned int ty, void* lists)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glCallLists(n, ty, lists);
}
void QOpenGLFunctions_3_3_Compatibility_GlClampColor4(void* ptr, unsigned int target, unsigned int clamp)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glClampColor(target, clamp);
}
void QOpenGLFunctions_3_3_Compatibility_GlClear4(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_3_3_Compatibility_GlClearAccum4(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glClearAccum(red, green, blue, alpha);
}
void QOpenGLFunctions_3_3_Compatibility_GlClearBufferfi4(void* ptr, unsigned int buffer, int drawbuffer, float depth, int stencil)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glClearBufferfi(buffer, drawbuffer, depth, stencil);
}
void QOpenGLFunctions_3_3_Compatibility_GlClearBufferfv4(void* ptr, unsigned int buffer, int drawbuffer, float value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glClearBufferfv(buffer, drawbuffer, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlClearBufferiv4(void* ptr, unsigned int buffer, int drawbuffer, int value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glClearBufferiv(buffer, drawbuffer, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlClearBufferuiv4(void* ptr, unsigned int buffer, int drawbuffer, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glClearBufferuiv(buffer, drawbuffer, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlClearColor4(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_3_3_Compatibility_GlClearIndex4(void* ptr, float c)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glClearIndex(c);
}
void QOpenGLFunctions_3_3_Compatibility_GlClearStencil4(void* ptr, int s)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_3_3_Compatibility_GlClientActiveTexture4(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glClientActiveTexture(texture);
}
void QOpenGLFunctions_3_3_Compatibility_GlColor3f4(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColor3f(red, green, blue);
}
void QOpenGLFunctions_3_3_Compatibility_GlColor3fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlColor3i4(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColor3i(red, green, blue);
}
void QOpenGLFunctions_3_3_Compatibility_GlColor3iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlColor3s4(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColor3s(red, green, blue);
}
void QOpenGLFunctions_3_3_Compatibility_GlColor3sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlColor3ub4(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_3_3_Compatibility_GlColor3ubv4(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_3_3_Compatibility_GlColor3ui4(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColor3ui(red, green, blue);
}
void QOpenGLFunctions_3_3_Compatibility_GlColor3uiv4(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlColor3us4(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColor3us(red, green, blue);
}
void QOpenGLFunctions_3_3_Compatibility_GlColor3usv4(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlColor4f4(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColor4f(red, green, blue, alpha);
}
void QOpenGLFunctions_3_3_Compatibility_GlColor4fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColor4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlColor4i4(void* ptr, int red, int green, int blue, int alpha)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColor4i(red, green, blue, alpha);
}
void QOpenGLFunctions_3_3_Compatibility_GlColor4iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColor4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlColor4s4(void* ptr, short red, short green, short blue, short alpha)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColor4s(red, green, blue, alpha);
}
void QOpenGLFunctions_3_3_Compatibility_GlColor4sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColor4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlColor4ub4(void* ptr, char* red, char* green, char* blue, char* alpha)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColor4ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)), *static_cast<GLubyte*>(static_cast<void*>(alpha)));
}
void QOpenGLFunctions_3_3_Compatibility_GlColor4ubv4(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColor4ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_3_3_Compatibility_GlColor4ui4(void* ptr, unsigned int red, unsigned int green, unsigned int blue, unsigned int alpha)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColor4ui(red, green, blue, alpha);
}
void QOpenGLFunctions_3_3_Compatibility_GlColor4uiv4(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColor4uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlColor4us4(void* ptr, unsigned short red, unsigned short green, unsigned short blue, unsigned short alpha)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColor4us(red, green, blue, alpha);
}
void QOpenGLFunctions_3_3_Compatibility_GlColor4usv4(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColor4usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlColorMask4(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_3_3_Compatibility_GlColorMaski4(void* ptr, unsigned int index, char r, char g, char b, char a)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColorMaski(index, r != 0, g != 0, b != 0, a != 0);
}
void QOpenGLFunctions_3_3_Compatibility_GlColorMaterial4(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColorMaterial(face, mode);
}
void QOpenGLFunctions_3_3_Compatibility_GlColorP3ui4(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColorP3ui(ty, color);
}
void QOpenGLFunctions_3_3_Compatibility_GlColorP3uiv4(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColorP3uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_3_3_Compatibility_GlColorP4ui4(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColorP4ui(ty, color);
}
void QOpenGLFunctions_3_3_Compatibility_GlColorP4uiv4(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColorP4uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_3_3_Compatibility_GlColorPointer4(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_3_3_Compatibility_GlColorSubTable4(void* ptr, unsigned int target, int start, int count, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColorSubTable(target, start, count, format, ty, data);
}
void QOpenGLFunctions_3_3_Compatibility_GlColorTable4(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColorTable(target, internalformat, width, format, ty, table);
}
void QOpenGLFunctions_3_3_Compatibility_GlColorTableParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColorTableParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_3_Compatibility_GlColorTableParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glColorTableParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_3_Compatibility_GlCompileShader4(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glCompileShader(shader);
}
void QOpenGLFunctions_3_3_Compatibility_GlCompressedTexImage1D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
void QOpenGLFunctions_3_3_Compatibility_GlCompressedTexImage2D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void QOpenGLFunctions_3_3_Compatibility_GlCompressedTexImage3D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int depth, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void QOpenGLFunctions_3_3_Compatibility_GlCompressedTexSubImage1D4(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_3_3_Compatibility_GlCompressedTexSubImage2D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_3_3_Compatibility_GlCompressedTexSubImage3D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_3_3_Compatibility_GlConvolutionFilter1D4(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glConvolutionFilter1D(target, internalformat, width, format, ty, image);
}
void QOpenGLFunctions_3_3_Compatibility_GlConvolutionFilter2D4(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glConvolutionFilter2D(target, internalformat, width, height, format, ty, image);
}
void QOpenGLFunctions_3_3_Compatibility_GlConvolutionParameterf4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glConvolutionParameterf(target, pname, params);
}
void QOpenGLFunctions_3_3_Compatibility_GlConvolutionParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glConvolutionParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_3_Compatibility_GlConvolutionParameteri4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glConvolutionParameteri(target, pname, params);
}
void QOpenGLFunctions_3_3_Compatibility_GlConvolutionParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glConvolutionParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_3_Compatibility_GlCopyColorSubTable4(void* ptr, unsigned int target, int start, int x, int y, int width)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glCopyColorSubTable(target, start, x, y, width);
}
void QOpenGLFunctions_3_3_Compatibility_GlCopyColorTable4(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glCopyColorTable(target, internalformat, x, y, width);
}
void QOpenGLFunctions_3_3_Compatibility_GlCopyConvolutionFilter1D4(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glCopyConvolutionFilter1D(target, internalformat, x, y, width);
}
void QOpenGLFunctions_3_3_Compatibility_GlCopyConvolutionFilter2D4(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);
}
void QOpenGLFunctions_3_3_Compatibility_GlCopyPixels4(void* ptr, int x, int y, int width, int height, unsigned int ty)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glCopyPixels(x, y, width, height, ty);
}
void QOpenGLFunctions_3_3_Compatibility_GlCopyTexImage1D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_3_3_Compatibility_GlCopyTexImage2D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_3_3_Compatibility_GlCopyTexSubImage1D4(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_3_3_Compatibility_GlCopyTexSubImage2D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_3_3_Compatibility_GlCopyTexSubImage3D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_3_3_Compatibility_GlCullFace4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_3_3_Compatibility_GlDeleteBuffers4(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDeleteBuffers(n, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_3_3_Compatibility_GlDeleteFramebuffers4(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDeleteFramebuffers(n, const_cast<const GLuint*>(&framebuffers));
}
void QOpenGLFunctions_3_3_Compatibility_GlDeleteLists4(void* ptr, unsigned int list, int ran)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDeleteLists(list, ran);
}
void QOpenGLFunctions_3_3_Compatibility_GlDeleteProgram4(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDeleteProgram(program);
}
void QOpenGLFunctions_3_3_Compatibility_GlDeleteQueries4(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDeleteQueries(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_3_3_Compatibility_GlDeleteRenderbuffers4(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDeleteRenderbuffers(n, const_cast<const GLuint*>(&renderbuffers));
}
void QOpenGLFunctions_3_3_Compatibility_GlDeleteSamplers4(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDeleteSamplers(count, const_cast<const GLuint*>(&samplers));
}
void QOpenGLFunctions_3_3_Compatibility_GlDeleteShader4(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDeleteShader(shader);
}
void QOpenGLFunctions_3_3_Compatibility_GlDeleteTextures4(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_3_3_Compatibility_GlDeleteVertexArrays4(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDeleteVertexArrays(n, const_cast<const GLuint*>(&arrays));
}
void QOpenGLFunctions_3_3_Compatibility_GlDepthFunc4(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_3_3_Compatibility_GlDepthMask4(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_3_3_Compatibility_GlDetachShader4(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDetachShader(program, shader);
}
void QOpenGLFunctions_3_3_Compatibility_GlDisable4(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_3_3_Compatibility_GlDisableClientState4(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDisableClientState(array);
}
void QOpenGLFunctions_3_3_Compatibility_GlDisableVertexAttribArray4(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDisableVertexAttribArray(index);
}
void QOpenGLFunctions_3_3_Compatibility_GlDisablei4(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDisablei(target, index);
}
void QOpenGLFunctions_3_3_Compatibility_GlDrawArrays4(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_3_3_Compatibility_GlDrawArraysInstanced4(void* ptr, unsigned int mode, int first, int count, int instancecount)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDrawArraysInstanced(mode, first, count, instancecount);
}
void QOpenGLFunctions_3_3_Compatibility_GlDrawBuffer4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDrawBuffer(mode);
}
void QOpenGLFunctions_3_3_Compatibility_GlDrawBuffers4(void* ptr, int n, unsigned int bufs)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDrawBuffers(n, const_cast<const GLenum*>(&bufs));
}
void QOpenGLFunctions_3_3_Compatibility_GlDrawElements4(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_3_3_Compatibility_GlDrawElementsBaseVertex4(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDrawElementsBaseVertex(mode, count, ty, indices, basevertex);
}
void QOpenGLFunctions_3_3_Compatibility_GlDrawElementsInstanced4(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDrawElementsInstanced(mode, count, ty, indices, instancecount);
}
void QOpenGLFunctions_3_3_Compatibility_GlDrawElementsInstancedBaseVertex4(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDrawElementsInstancedBaseVertex(mode, count, ty, indices, instancecount, basevertex);
}
void QOpenGLFunctions_3_3_Compatibility_GlDrawPixels4(void* ptr, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDrawPixels(width, height, format, ty, pixels);
}
void QOpenGLFunctions_3_3_Compatibility_GlDrawRangeElements4(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLFunctions_3_3_Compatibility_GlDrawRangeElementsBaseVertex4(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glDrawRangeElementsBaseVertex(mode, start, end, count, ty, indices, basevertex);
}
void QOpenGLFunctions_3_3_Compatibility_GlEdgeFlag4(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glEdgeFlag(flag != 0);
}
void QOpenGLFunctions_3_3_Compatibility_GlEdgeFlagPointer4(void* ptr, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glEdgeFlagPointer(stride, pointer);
}
void QOpenGLFunctions_3_3_Compatibility_GlEdgeFlagv4(void* ptr, char flag)
{
Q_UNUSED(flag);
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glEdgeFlagv(NULL);
}
void QOpenGLFunctions_3_3_Compatibility_GlEnable4(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_3_3_Compatibility_GlEnableClientState4(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glEnableClientState(array);
}
void QOpenGLFunctions_3_3_Compatibility_GlEnableVertexAttribArray4(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glEnableVertexAttribArray(index);
}
void QOpenGLFunctions_3_3_Compatibility_GlEnablei4(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glEnablei(target, index);
}
void QOpenGLFunctions_3_3_Compatibility_GlEnd4(void* ptr)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glEnd();
}
void QOpenGLFunctions_3_3_Compatibility_GlEndConditionalRender4(void* ptr)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glEndConditionalRender();
}
void QOpenGLFunctions_3_3_Compatibility_GlEndList4(void* ptr)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glEndList();
}
void QOpenGLFunctions_3_3_Compatibility_GlEndQuery4(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glEndQuery(target);
}
void QOpenGLFunctions_3_3_Compatibility_GlEndTransformFeedback4(void* ptr)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glEndTransformFeedback();
}
void QOpenGLFunctions_3_3_Compatibility_GlEvalCoord1f4(void* ptr, float u)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glEvalCoord1f(u);
}
void QOpenGLFunctions_3_3_Compatibility_GlEvalCoord1fv4(void* ptr, float u)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glEvalCoord1fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_3_3_Compatibility_GlEvalCoord2f4(void* ptr, float u, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glEvalCoord2f(u, v);
}
void QOpenGLFunctions_3_3_Compatibility_GlEvalCoord2fv4(void* ptr, float u)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glEvalCoord2fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_3_3_Compatibility_GlEvalMesh14(void* ptr, unsigned int mode, int i1, int i2)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glEvalMesh1(mode, i1, i2);
}
void QOpenGLFunctions_3_3_Compatibility_GlEvalMesh24(void* ptr, unsigned int mode, int i1, int i2, int j1, int j2)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glEvalMesh2(mode, i1, i2, j1, j2);
}
void QOpenGLFunctions_3_3_Compatibility_GlEvalPoint14(void* ptr, int i)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glEvalPoint1(i);
}
void QOpenGLFunctions_3_3_Compatibility_GlEvalPoint24(void* ptr, int i, int j)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glEvalPoint2(i, j);
}
void QOpenGLFunctions_3_3_Compatibility_GlFeedbackBuffer4(void* ptr, int size, unsigned int ty, float buffer)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glFeedbackBuffer(size, ty, &buffer);
}
void QOpenGLFunctions_3_3_Compatibility_GlFinish4(void* ptr)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glFinish();
}
void QOpenGLFunctions_3_3_Compatibility_GlFlush4(void* ptr)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glFlush();
}
void QOpenGLFunctions_3_3_Compatibility_GlFogCoordPointer4(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glFogCoordPointer(ty, stride, pointer);
}
void QOpenGLFunctions_3_3_Compatibility_GlFogCoordf4(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glFogCoordf(coord);
}
void QOpenGLFunctions_3_3_Compatibility_GlFogCoordfv4(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glFogCoordfv(const_cast<const GLfloat*>(&coord));
}
void QOpenGLFunctions_3_3_Compatibility_GlFogf4(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glFogf(pname, param);
}
void QOpenGLFunctions_3_3_Compatibility_GlFogfv4(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glFogfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_3_Compatibility_GlFogi4(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glFogi(pname, param);
}
void QOpenGLFunctions_3_3_Compatibility_GlFogiv4(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glFogiv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_3_Compatibility_GlFramebufferRenderbuffer4(void* ptr, unsigned int target, unsigned int attachment, unsigned int renderbuffertarget, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
void QOpenGLFunctions_3_3_Compatibility_GlFramebufferTexture4(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glFramebufferTexture(target, attachment, texture, level);
}
void QOpenGLFunctions_3_3_Compatibility_GlFramebufferTexture1D4(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glFramebufferTexture1D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_3_3_Compatibility_GlFramebufferTexture2D4(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_3_3_Compatibility_GlFramebufferTexture3D4(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level, int zoffset)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}
void QOpenGLFunctions_3_3_Compatibility_GlFramebufferTextureLayer4(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level, int layer)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glFramebufferTextureLayer(target, attachment, texture, level, layer);
}
void QOpenGLFunctions_3_3_Compatibility_GlFrontFace4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_3_3_Compatibility_GlGenBuffers4(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGenBuffers(n, &buffers);
}
void QOpenGLFunctions_3_3_Compatibility_GlGenFramebuffers4(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGenFramebuffers(n, &framebuffers);
}
void QOpenGLFunctions_3_3_Compatibility_GlGenQueries4(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGenQueries(n, &ids);
}
void QOpenGLFunctions_3_3_Compatibility_GlGenRenderbuffers4(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGenRenderbuffers(n, &renderbuffers);
}
void QOpenGLFunctions_3_3_Compatibility_GlGenSamplers4(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGenSamplers(count, &samplers);
}
void QOpenGLFunctions_3_3_Compatibility_GlGenTextures4(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_3_3_Compatibility_GlGenVertexArrays4(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGenVertexArrays(n, &arrays);
}
void QOpenGLFunctions_3_3_Compatibility_GlGenerateMipmap4(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGenerateMipmap(target);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetActiveUniformBlockiv4(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetActiveUniformsiv4(void* ptr, unsigned int program, int uniformCount, unsigned int uniformIndices, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetActiveUniformsiv(program, uniformCount, const_cast<const GLuint*>(&uniformIndices), pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetAttachedShaders4(void* ptr, unsigned int program, int maxCount, int count, unsigned int obj)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetAttachedShaders(program, maxCount, &count, &obj);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetBooleani_v4(void* ptr, unsigned int target, unsigned int index, char data)
{
Q_UNUSED(data);
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetBooleani_v(target, index, NULL);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetBooleanv4(void* ptr, unsigned int pname, char params)
{
Q_UNUSED(params);
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetBufferParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetBufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetBufferPointerv4(void* ptr, unsigned int target, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetBufferPointerv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetColorTable4(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetColorTable(target, format, ty, table);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetColorTableParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetColorTableParameterfv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetColorTableParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetColorTableParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetCompressedTexImage4(void* ptr, unsigned int target, int level, void* img)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetCompressedTexImage(target, level, img);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetConvolutionFilter4(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetConvolutionFilter(target, format, ty, image);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetConvolutionParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetConvolutionParameterfv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetConvolutionParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetConvolutionParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetFloatv4(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetFloatv(pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetFramebufferAttachmentParameteriv4(void* ptr, unsigned int target, unsigned int attachment, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetFramebufferAttachmentParameteriv(target, attachment, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetHistogram4(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetHistogram(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetHistogramParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetHistogramParameterfv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetHistogramParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetHistogramParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetIntegeri_v4(void* ptr, unsigned int target, unsigned int index, int data)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetIntegeri_v(target, index, &data);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetIntegerv4(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetIntegerv(pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetLightfv4(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetLightfv(light, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetLightiv4(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetLightiv(light, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetMapfv4(void* ptr, unsigned int target, unsigned int query, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetMapfv(target, query, &v);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetMapiv4(void* ptr, unsigned int target, unsigned int query, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetMapiv(target, query, &v);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetMaterialfv4(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetMaterialfv(face, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetMaterialiv4(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetMaterialiv(face, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetMinmax4(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetMinmax(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetMinmaxParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetMinmaxParameterfv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetMinmaxParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetMinmaxParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetMultisamplefv4(void* ptr, unsigned int pname, unsigned int index, float val)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetMultisamplefv(pname, index, &val);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetPixelMapfv4(void* ptr, unsigned int m, float values)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetPixelMapfv(m, &values);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetPixelMapuiv4(void* ptr, unsigned int m, unsigned int values)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetPixelMapuiv(m, &values);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetPixelMapusv4(void* ptr, unsigned int m, unsigned short values)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetPixelMapusv(m, &values);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetPointerv4(void* ptr, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetPointerv(pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetPolygonStipple4(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetPolygonStipple(static_cast<GLubyte*>(static_cast<void*>(mask)));
}
void QOpenGLFunctions_3_3_Compatibility_GlGetProgramiv4(void* ptr, unsigned int program, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetProgramiv(program, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetQueryObjectiv4(void* ptr, unsigned int id, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetQueryObjectiv(id, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetQueryObjectuiv4(void* ptr, unsigned int id, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetQueryObjectuiv(id, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetQueryiv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetQueryiv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetRenderbufferParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetRenderbufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetSamplerParameterIiv4(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetSamplerParameterIiv(sampler, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetSamplerParameterIuiv4(void* ptr, unsigned int sampler, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetSamplerParameterIuiv(sampler, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetSamplerParameterfv4(void* ptr, unsigned int sampler, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetSamplerParameterfv(sampler, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetSamplerParameteriv4(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetSamplerParameteriv(sampler, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetSeparableFilter4(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* row, void* column, void* span)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetSeparableFilter(target, format, ty, row, column, span);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetShaderiv4(void* ptr, unsigned int shader, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetShaderiv(shader, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetTexEnvfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetTexEnvfv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetTexEnviv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetTexEnviv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetTexGenfv4(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetTexGenfv(coord, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetTexGeniv4(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetTexGeniv(coord, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetTexImage4(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetTexLevelParameterfv4(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetTexLevelParameteriv4(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetTexParameterIiv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetTexParameterIiv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetTexParameterIuiv4(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetTexParameterIuiv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetTexParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetTexParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetUniformfv4(void* ptr, unsigned int program, int location, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetUniformfv(program, location, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetUniformiv4(void* ptr, unsigned int program, int location, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetUniformiv(program, location, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetUniformuiv4(void* ptr, unsigned int program, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetUniformuiv(program, location, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetVertexAttribIiv4(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetVertexAttribIiv(index, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetVertexAttribIuiv4(void* ptr, unsigned int index, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetVertexAttribIuiv(index, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetVertexAttribPointerv4(void* ptr, unsigned int index, unsigned int pname, void* pointer)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetVertexAttribPointerv(index, pname, &pointer);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetVertexAttribfv4(void* ptr, unsigned int index, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetVertexAttribfv(index, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlGetVertexAttribiv4(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glGetVertexAttribiv(index, pname, &params);
}
void QOpenGLFunctions_3_3_Compatibility_GlHint4(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_3_3_Compatibility_GlHistogram4(void* ptr, unsigned int target, int width, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glHistogram(target, width, internalformat, sink != 0);
}
void QOpenGLFunctions_3_3_Compatibility_GlIndexMask4(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glIndexMask(mask);
}
void QOpenGLFunctions_3_3_Compatibility_GlIndexPointer4(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glIndexPointer(ty, stride, pointer);
}
void QOpenGLFunctions_3_3_Compatibility_GlIndexf4(void* ptr, float c)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glIndexf(c);
}
void QOpenGLFunctions_3_3_Compatibility_GlIndexfv4(void* ptr, float c)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glIndexfv(const_cast<const GLfloat*>(&c));
}
void QOpenGLFunctions_3_3_Compatibility_GlIndexi4(void* ptr, int c)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glIndexi(c);
}
void QOpenGLFunctions_3_3_Compatibility_GlIndexiv4(void* ptr, int c)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glIndexiv(const_cast<const GLint*>(&c));
}
void QOpenGLFunctions_3_3_Compatibility_GlIndexs4(void* ptr, short c)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glIndexs(c);
}
void QOpenGLFunctions_3_3_Compatibility_GlIndexsv4(void* ptr, short c)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glIndexsv(const_cast<const GLshort*>(&c));
}
void QOpenGLFunctions_3_3_Compatibility_GlIndexub4(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glIndexub(*static_cast<GLubyte*>(static_cast<void*>(c)));
}
void QOpenGLFunctions_3_3_Compatibility_GlIndexubv4(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glIndexubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(c))));
}
void QOpenGLFunctions_3_3_Compatibility_GlInitNames4(void* ptr)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glInitNames();
}
void QOpenGLFunctions_3_3_Compatibility_GlInterleavedArrays4(void* ptr, unsigned int format, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glInterleavedArrays(format, stride, pointer);
}
void QOpenGLFunctions_3_3_Compatibility_GlLightModelf4(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glLightModelf(pname, param);
}
void QOpenGLFunctions_3_3_Compatibility_GlLightModelfv4(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glLightModelfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_3_Compatibility_GlLightModeli4(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glLightModeli(pname, param);
}
void QOpenGLFunctions_3_3_Compatibility_GlLightModeliv4(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glLightModeliv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_3_Compatibility_GlLightf4(void* ptr, unsigned int light, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glLightf(light, pname, param);
}
void QOpenGLFunctions_3_3_Compatibility_GlLightfv4(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glLightfv(light, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_3_Compatibility_GlLighti4(void* ptr, unsigned int light, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glLighti(light, pname, param);
}
void QOpenGLFunctions_3_3_Compatibility_GlLightiv4(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glLightiv(light, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_3_Compatibility_GlLineStipple4(void* ptr, int factor, unsigned short pattern)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glLineStipple(factor, pattern);
}
void QOpenGLFunctions_3_3_Compatibility_GlLineWidth4(void* ptr, float width)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_3_3_Compatibility_GlLinkProgram4(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glLinkProgram(program);
}
void QOpenGLFunctions_3_3_Compatibility_GlListBase4(void* ptr, unsigned int base)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glListBase(base);
}
void QOpenGLFunctions_3_3_Compatibility_GlLoadIdentity4(void* ptr)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glLoadIdentity();
}
void QOpenGLFunctions_3_3_Compatibility_GlLoadMatrixf4(void* ptr, float m)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glLoadMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_3_3_Compatibility_GlLoadName4(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glLoadName(name);
}
void QOpenGLFunctions_3_3_Compatibility_GlLoadTransposeMatrixf4(void* ptr, float m)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glLoadTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_3_3_Compatibility_GlLogicOp4(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_3_3_Compatibility_GlMap1f4(void* ptr, unsigned int target, float u1, float u2, int stride, int order, float points)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMap1f(target, u1, u2, stride, order, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_3_3_Compatibility_GlMap2f4(void* ptr, unsigned int target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float points)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_3_3_Compatibility_GlMapGrid1f4(void* ptr, int un, float u1, float u2)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMapGrid1f(un, u1, u2);
}
void QOpenGLFunctions_3_3_Compatibility_GlMapGrid2f4(void* ptr, int un, float u1, float u2, int vn, float v1, float v2)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMapGrid2f(un, u1, u2, vn, v1, v2);
}
void QOpenGLFunctions_3_3_Compatibility_GlMaterialf4(void* ptr, unsigned int face, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMaterialf(face, pname, param);
}
void QOpenGLFunctions_3_3_Compatibility_GlMaterialfv4(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMaterialfv(face, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_3_Compatibility_GlMateriali4(void* ptr, unsigned int face, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMateriali(face, pname, param);
}
void QOpenGLFunctions_3_3_Compatibility_GlMaterialiv4(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMaterialiv(face, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_3_Compatibility_GlMatrixMode4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMatrixMode(mode);
}
void QOpenGLFunctions_3_3_Compatibility_GlMinmax4(void* ptr, unsigned int target, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMinmax(target, internalformat, sink != 0);
}
void QOpenGLFunctions_3_3_Compatibility_GlMultMatrixf4(void* ptr, float m)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_3_3_Compatibility_GlMultTransposeMatrixf4(void* ptr, float m)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiDrawArrays4(void* ptr, unsigned int mode, int first, int count, int drawcount)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiDrawArrays(mode, const_cast<const GLint*>(&first), const_cast<const GLsizei*>(&count), drawcount);
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoord1f4(void* ptr, unsigned int target, float s)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoord1f(target, s);
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoord1fv4(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoord1fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoord1i4(void* ptr, unsigned int target, int s)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoord1i(target, s);
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoord1iv4(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoord1iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoord1s4(void* ptr, unsigned int target, short s)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoord1s(target, s);
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoord1sv4(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoord1sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoord2f4(void* ptr, unsigned int target, float s, float t)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoord2f(target, s, t);
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoord2fv4(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoord2fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoord2i4(void* ptr, unsigned int target, int s, int t)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoord2i(target, s, t);
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoord2iv4(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoord2iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoord2s4(void* ptr, unsigned int target, short s, short t)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoord2s(target, s, t);
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoord2sv4(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoord2sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoord3f4(void* ptr, unsigned int target, float s, float t, float r)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoord3f(target, s, t, r);
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoord3fv4(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoord3fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoord3i4(void* ptr, unsigned int target, int s, int t, int r)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoord3i(target, s, t, r);
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoord3iv4(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoord3iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoord3s4(void* ptr, unsigned int target, short s, short t, short r)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoord3s(target, s, t, r);
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoord3sv4(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoord3sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoord4f4(void* ptr, unsigned int target, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoord4f(target, s, t, r, q);
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoord4fv4(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoord4fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoord4i4(void* ptr, unsigned int target, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoord4i(target, s, t, r, q);
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoord4iv4(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoord4iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoord4s4(void* ptr, unsigned int target, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoord4s(target, s, t, r, q);
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoord4sv4(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoord4sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoordP1ui4(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoordP1ui(texture, ty, coords);
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoordP1uiv4(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoordP1uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoordP2ui4(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoordP2ui(texture, ty, coords);
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoordP2uiv4(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoordP2uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoordP3ui4(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoordP3ui(texture, ty, coords);
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoordP3uiv4(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoordP3uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoordP4ui4(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoordP4ui(texture, ty, coords);
}
void QOpenGLFunctions_3_3_Compatibility_GlMultiTexCoordP4uiv4(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glMultiTexCoordP4uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_3_3_Compatibility_GlNewList4(void* ptr, unsigned int list, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glNewList(list, mode);
}
void QOpenGLFunctions_3_3_Compatibility_GlNormal3f4(void* ptr, float nx, float ny, float nz)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glNormal3f(nx, ny, nz);
}
void QOpenGLFunctions_3_3_Compatibility_GlNormal3fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glNormal3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlNormal3i4(void* ptr, int nx, int ny, int nz)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glNormal3i(nx, ny, nz);
}
void QOpenGLFunctions_3_3_Compatibility_GlNormal3iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glNormal3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlNormal3s4(void* ptr, short nx, short ny, short nz)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glNormal3s(nx, ny, nz);
}
void QOpenGLFunctions_3_3_Compatibility_GlNormal3sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glNormal3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlNormalP3ui4(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glNormalP3ui(ty, coords);
}
void QOpenGLFunctions_3_3_Compatibility_GlNormalP3uiv4(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glNormalP3uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_3_3_Compatibility_GlNormalPointer4(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glNormalPointer(ty, stride, pointer);
}
void QOpenGLFunctions_3_3_Compatibility_GlPassThrough4(void* ptr, float token)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPassThrough(token);
}
void QOpenGLFunctions_3_3_Compatibility_GlPixelMapfv4(void* ptr, unsigned int m, int mapsize, float values)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPixelMapfv(m, mapsize, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_3_3_Compatibility_GlPixelMapuiv4(void* ptr, unsigned int m, int mapsize, unsigned int values)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPixelMapuiv(m, mapsize, const_cast<const GLuint*>(&values));
}
void QOpenGLFunctions_3_3_Compatibility_GlPixelMapusv4(void* ptr, unsigned int m, int mapsize, unsigned short values)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPixelMapusv(m, mapsize, const_cast<const GLushort*>(&values));
}
void QOpenGLFunctions_3_3_Compatibility_GlPixelStoref4(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_3_3_Compatibility_GlPixelStorei4(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_3_3_Compatibility_GlPixelTransferf4(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPixelTransferf(pname, param);
}
void QOpenGLFunctions_3_3_Compatibility_GlPixelTransferi4(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPixelTransferi(pname, param);
}
void QOpenGLFunctions_3_3_Compatibility_GlPixelZoom4(void* ptr, float xfactor, float yfactor)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPixelZoom(xfactor, yfactor);
}
void QOpenGLFunctions_3_3_Compatibility_GlPointParameterf4(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPointParameterf(pname, param);
}
void QOpenGLFunctions_3_3_Compatibility_GlPointParameterfv4(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPointParameterfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_3_Compatibility_GlPointParameteri4(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPointParameteri(pname, param);
}
void QOpenGLFunctions_3_3_Compatibility_GlPointParameteriv4(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPointParameteriv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_3_Compatibility_GlPointSize4(void* ptr, float size)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_3_3_Compatibility_GlPolygonMode4(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_3_3_Compatibility_GlPolygonOffset4(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_3_3_Compatibility_GlPolygonStipple4(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPolygonStipple(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(mask))));
}
void QOpenGLFunctions_3_3_Compatibility_GlPopAttrib4(void* ptr)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPopAttrib();
}
void QOpenGLFunctions_3_3_Compatibility_GlPopClientAttrib4(void* ptr)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPopClientAttrib();
}
void QOpenGLFunctions_3_3_Compatibility_GlPopMatrix4(void* ptr)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPopMatrix();
}
void QOpenGLFunctions_3_3_Compatibility_GlPopName4(void* ptr)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPopName();
}
void QOpenGLFunctions_3_3_Compatibility_GlPrimitiveRestartIndex4(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPrimitiveRestartIndex(index);
}
void QOpenGLFunctions_3_3_Compatibility_GlPrioritizeTextures4(void* ptr, int n, unsigned int textures, float priorities)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPrioritizeTextures(n, const_cast<const GLuint*>(&textures), const_cast<const GLfloat*>(&priorities));
}
void QOpenGLFunctions_3_3_Compatibility_GlProvokingVertex4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glProvokingVertex(mode);
}
void QOpenGLFunctions_3_3_Compatibility_GlPushAttrib4(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPushAttrib(mask);
}
void QOpenGLFunctions_3_3_Compatibility_GlPushClientAttrib4(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPushClientAttrib(mask);
}
void QOpenGLFunctions_3_3_Compatibility_GlPushMatrix4(void* ptr)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPushMatrix();
}
void QOpenGLFunctions_3_3_Compatibility_GlPushName4(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glPushName(name);
}
void QOpenGLFunctions_3_3_Compatibility_GlQueryCounter4(void* ptr, unsigned int id, unsigned int target)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glQueryCounter(id, target);
}
void QOpenGLFunctions_3_3_Compatibility_GlRasterPos2f4(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRasterPos2f(x, y);
}
void QOpenGLFunctions_3_3_Compatibility_GlRasterPos2fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRasterPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlRasterPos2i4(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRasterPos2i(x, y);
}
void QOpenGLFunctions_3_3_Compatibility_GlRasterPos2iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRasterPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlRasterPos2s4(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRasterPos2s(x, y);
}
void QOpenGLFunctions_3_3_Compatibility_GlRasterPos2sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRasterPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlRasterPos3f4(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRasterPos3f(x, y, z);
}
void QOpenGLFunctions_3_3_Compatibility_GlRasterPos3fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRasterPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlRasterPos3i4(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRasterPos3i(x, y, z);
}
void QOpenGLFunctions_3_3_Compatibility_GlRasterPos3iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRasterPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlRasterPos3s4(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRasterPos3s(x, y, z);
}
void QOpenGLFunctions_3_3_Compatibility_GlRasterPos3sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRasterPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlRasterPos4f4(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRasterPos4f(x, y, z, w);
}
void QOpenGLFunctions_3_3_Compatibility_GlRasterPos4fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRasterPos4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlRasterPos4i4(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRasterPos4i(x, y, z, w);
}
void QOpenGLFunctions_3_3_Compatibility_GlRasterPos4iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRasterPos4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlRasterPos4s4(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRasterPos4s(x, y, z, w);
}
void QOpenGLFunctions_3_3_Compatibility_GlRasterPos4sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRasterPos4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlReadBuffer4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glReadBuffer(mode);
}
void QOpenGLFunctions_3_3_Compatibility_GlReadPixels4(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_3_3_Compatibility_GlRectf4(void* ptr, float x1, float y1, float x2, float y2)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRectf(x1, y1, x2, y2);
}
void QOpenGLFunctions_3_3_Compatibility_GlRectfv4(void* ptr, float v1, float v2)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRectfv(const_cast<const GLfloat*>(&v1), const_cast<const GLfloat*>(&v2));
}
void QOpenGLFunctions_3_3_Compatibility_GlRecti4(void* ptr, int x1, int y1, int x2, int y2)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRecti(x1, y1, x2, y2);
}
void QOpenGLFunctions_3_3_Compatibility_GlRectiv4(void* ptr, int v1, int v2)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRectiv(const_cast<const GLint*>(&v1), const_cast<const GLint*>(&v2));
}
void QOpenGLFunctions_3_3_Compatibility_GlRects4(void* ptr, short x1, short y1, short x2, short y2)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRects(x1, y1, x2, y2);
}
void QOpenGLFunctions_3_3_Compatibility_GlRectsv4(void* ptr, short v1, short v2)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRectsv(const_cast<const GLshort*>(&v1), const_cast<const GLshort*>(&v2));
}
void QOpenGLFunctions_3_3_Compatibility_GlRenderbufferStorage4(void* ptr, unsigned int target, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRenderbufferStorage(target, internalformat, width, height);
}
void QOpenGLFunctions_3_3_Compatibility_GlRenderbufferStorageMultisample4(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
}
void QOpenGLFunctions_3_3_Compatibility_GlResetHistogram4(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glResetHistogram(target);
}
void QOpenGLFunctions_3_3_Compatibility_GlResetMinmax4(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glResetMinmax(target);
}
void QOpenGLFunctions_3_3_Compatibility_GlRotatef4(void* ptr, float angle, float x, float y, float z)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glRotatef(angle, x, y, z);
}
void QOpenGLFunctions_3_3_Compatibility_GlSampleCoverage4(void* ptr, float value, char invert)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSampleCoverage(value, invert != 0);
}
void QOpenGLFunctions_3_3_Compatibility_GlSampleMaski4(void* ptr, unsigned int index, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSampleMaski(index, mask);
}
void QOpenGLFunctions_3_3_Compatibility_GlSamplerParameterIiv4(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSamplerParameterIiv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_3_3_Compatibility_GlSamplerParameterIuiv4(void* ptr, unsigned int sampler, unsigned int pname, unsigned int param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSamplerParameterIuiv(sampler, pname, const_cast<const GLuint*>(&param));
}
void QOpenGLFunctions_3_3_Compatibility_GlSamplerParameterf4(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSamplerParameterf(sampler, pname, param);
}
void QOpenGLFunctions_3_3_Compatibility_GlSamplerParameterfv4(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSamplerParameterfv(sampler, pname, const_cast<const GLfloat*>(&param));
}
void QOpenGLFunctions_3_3_Compatibility_GlSamplerParameteri4(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSamplerParameteri(sampler, pname, param);
}
void QOpenGLFunctions_3_3_Compatibility_GlSamplerParameteriv4(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSamplerParameteriv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_3_3_Compatibility_GlScalef4(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glScalef(x, y, z);
}
void QOpenGLFunctions_3_3_Compatibility_GlScissor4(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_3_3_Compatibility_GlSecondaryColor3f4(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSecondaryColor3f(red, green, blue);
}
void QOpenGLFunctions_3_3_Compatibility_GlSecondaryColor3fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSecondaryColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlSecondaryColor3i4(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSecondaryColor3i(red, green, blue);
}
void QOpenGLFunctions_3_3_Compatibility_GlSecondaryColor3iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSecondaryColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlSecondaryColor3s4(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSecondaryColor3s(red, green, blue);
}
void QOpenGLFunctions_3_3_Compatibility_GlSecondaryColor3sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSecondaryColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlSecondaryColor3ub4(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSecondaryColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_3_3_Compatibility_GlSecondaryColor3ubv4(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSecondaryColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_3_3_Compatibility_GlSecondaryColor3ui4(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSecondaryColor3ui(red, green, blue);
}
void QOpenGLFunctions_3_3_Compatibility_GlSecondaryColor3uiv4(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSecondaryColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlSecondaryColor3us4(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSecondaryColor3us(red, green, blue);
}
void QOpenGLFunctions_3_3_Compatibility_GlSecondaryColor3usv4(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSecondaryColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlSecondaryColorP3ui4(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSecondaryColorP3ui(ty, color);
}
void QOpenGLFunctions_3_3_Compatibility_GlSecondaryColorP3uiv4(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSecondaryColorP3uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_3_3_Compatibility_GlSecondaryColorPointer4(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSecondaryColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_3_3_Compatibility_GlSelectBuffer4(void* ptr, int size, unsigned int buffer)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSelectBuffer(size, &buffer);
}
void QOpenGLFunctions_3_3_Compatibility_GlSeparableFilter2D4(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* row, void* column)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glSeparableFilter2D(target, internalformat, width, height, format, ty, row, column);
}
void QOpenGLFunctions_3_3_Compatibility_GlShadeModel4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glShadeModel(mode);
}
void QOpenGLFunctions_3_3_Compatibility_GlStencilFunc4(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_3_3_Compatibility_GlStencilFuncSeparate4(void* ptr, unsigned int face, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glStencilFuncSeparate(face, fu, ref, mask);
}
void QOpenGLFunctions_3_3_Compatibility_GlStencilMask4(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_3_3_Compatibility_GlStencilMaskSeparate4(void* ptr, unsigned int face, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glStencilMaskSeparate(face, mask);
}
void QOpenGLFunctions_3_3_Compatibility_GlStencilOp4(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_3_3_Compatibility_GlStencilOpSeparate4(void* ptr, unsigned int face, unsigned int sfail, unsigned int dpfail, unsigned int dppass)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glStencilOpSeparate(face, sfail, dpfail, dppass);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexBuffer4(void* ptr, unsigned int target, unsigned int internalformat, unsigned int buffer)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexBuffer(target, internalformat, buffer);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoord1f4(void* ptr, float s)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoord1f(s);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoord1fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoord1fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoord1i4(void* ptr, int s)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoord1i(s);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoord1iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoord1iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoord1s4(void* ptr, short s)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoord1s(s);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoord1sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoord1sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoord2f4(void* ptr, float s, float t)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoord2f(s, t);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoord2fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoord2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoord2i4(void* ptr, int s, int t)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoord2i(s, t);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoord2iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoord2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoord2s4(void* ptr, short s, short t)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoord2s(s, t);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoord2sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoord2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoord3f4(void* ptr, float s, float t, float r)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoord3f(s, t, r);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoord3fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoord3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoord3i4(void* ptr, int s, int t, int r)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoord3i(s, t, r);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoord3iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoord3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoord3s4(void* ptr, short s, short t, short r)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoord3s(s, t, r);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoord3sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoord3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoord4f4(void* ptr, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoord4f(s, t, r, q);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoord4fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoord4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoord4i4(void* ptr, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoord4i(s, t, r, q);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoord4iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoord4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoord4s4(void* ptr, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoord4s(s, t, r, q);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoord4sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoord4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoordP1ui4(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoordP1ui(ty, coords);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoordP1uiv4(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoordP1uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoordP2ui4(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoordP2ui(ty, coords);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoordP2uiv4(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoordP2uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoordP3ui4(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoordP3ui(ty, coords);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoordP3uiv4(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoordP3uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoordP4ui4(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoordP4ui(ty, coords);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoordP4uiv4(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoordP4uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_3_3_Compatibility_GlTexCoordPointer4(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexCoordPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexEnvf4(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexEnvf(target, pname, param);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexEnvfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexEnvfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_3_Compatibility_GlTexEnvi4(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexEnvi(target, pname, param);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexEnviv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexEnviv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_3_Compatibility_GlTexGenf4(void* ptr, unsigned int coord, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexGenf(coord, pname, param);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexGenfv4(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexGenfv(coord, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_3_Compatibility_GlTexGeni4(void* ptr, unsigned int coord, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexGeni(coord, pname, param);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexGeniv4(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexGeniv(coord, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_3_Compatibility_GlTexImage1D4(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexImage2D4(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexImage2DMultisample4(void* ptr, unsigned int target, int samples, int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexImage3D4(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexImage3DMultisample4(void* ptr, unsigned int target, int samples, int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexParameterIiv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexParameterIiv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_3_Compatibility_GlTexParameterIuiv4(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexParameterIuiv(target, pname, const_cast<const GLuint*>(&params));
}
void QOpenGLFunctions_3_3_Compatibility_GlTexParameterf4(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_3_Compatibility_GlTexParameteri4(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_3_Compatibility_GlTexSubImage1D4(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexSubImage2D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_3_3_Compatibility_GlTexSubImage3D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_3_3_Compatibility_GlTranslatef4(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glTranslatef(x, y, z);
}
void QOpenGLFunctions_3_3_Compatibility_GlUniform1f4(void* ptr, int location, float v0)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniform1f(location, v0);
}
void QOpenGLFunctions_3_3_Compatibility_GlUniform1fv4(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniform1fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlUniform1i4(void* ptr, int location, int v0)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniform1i(location, v0);
}
void QOpenGLFunctions_3_3_Compatibility_GlUniform1iv4(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniform1iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlUniform1ui4(void* ptr, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniform1ui(location, v0);
}
void QOpenGLFunctions_3_3_Compatibility_GlUniform1uiv4(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniform1uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlUniform2f4(void* ptr, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniform2f(location, v0, v1);
}
void QOpenGLFunctions_3_3_Compatibility_GlUniform2fv4(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniform2fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlUniform2i4(void* ptr, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniform2i(location, v0, v1);
}
void QOpenGLFunctions_3_3_Compatibility_GlUniform2iv4(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniform2iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlUniform2ui4(void* ptr, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniform2ui(location, v0, v1);
}
void QOpenGLFunctions_3_3_Compatibility_GlUniform2uiv4(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniform2uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlUniform3f4(void* ptr, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniform3f(location, v0, v1, v2);
}
void QOpenGLFunctions_3_3_Compatibility_GlUniform3fv4(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniform3fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlUniform3i4(void* ptr, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniform3i(location, v0, v1, v2);
}
void QOpenGLFunctions_3_3_Compatibility_GlUniform3iv4(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniform3iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlUniform3ui4(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniform3ui(location, v0, v1, v2);
}
void QOpenGLFunctions_3_3_Compatibility_GlUniform3uiv4(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniform3uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlUniform4f4(void* ptr, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniform4f(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_3_3_Compatibility_GlUniform4fv4(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniform4fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlUniform4i4(void* ptr, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniform4i(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_3_3_Compatibility_GlUniform4iv4(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniform4iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlUniform4ui4(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniform4ui(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_3_3_Compatibility_GlUniform4uiv4(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniform4uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlUniformBlockBinding4(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int uniformBlockBinding)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}
void QOpenGLFunctions_3_3_Compatibility_GlUniformMatrix2fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniformMatrix2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlUniformMatrix2x3fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniformMatrix2x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlUniformMatrix2x4fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniformMatrix2x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlUniformMatrix3fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniformMatrix3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlUniformMatrix3x2fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniformMatrix3x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlUniformMatrix3x4fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniformMatrix3x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlUniformMatrix4fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniformMatrix4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlUniformMatrix4x2fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniformMatrix4x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlUniformMatrix4x3fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUniformMatrix4x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlUseProgram4(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glUseProgram(program);
}
void QOpenGLFunctions_3_3_Compatibility_GlValidateProgram4(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glValidateProgram(program);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertex2f4(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertex2f(x, y);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertex2fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertex2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertex2i4(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertex2i(x, y);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertex2iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertex2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertex2s4(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertex2s(x, y);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertex2sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertex2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertex3f4(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertex3f(x, y, z);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertex3fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertex3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertex3i4(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertex3i(x, y, z);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertex3iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertex3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertex3s4(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertex3s(x, y, z);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertex3sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertex3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertex4f4(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertex4f(x, y, z, w);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertex4fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertex4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertex4i4(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertex4i(x, y, z, w);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertex4iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertex4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertex4s4(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertex4s(x, y, z, w);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertex4sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertex4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib1f4(void* ptr, unsigned int index, float x)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib1f(index, x);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib1fv4(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib1fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib1s4(void* ptr, unsigned int index, short x)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib1s(index, x);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib1sv4(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib1sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib2f4(void* ptr, unsigned int index, float x, float y)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib2f(index, x, y);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib2fv4(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib2fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib2s4(void* ptr, unsigned int index, short x, short y)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib2s(index, x, y);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib2sv4(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib2sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib3f4(void* ptr, unsigned int index, float x, float y, float z)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib3f(index, x, y, z);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib3fv4(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib3fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib3s4(void* ptr, unsigned int index, short x, short y, short z)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib3s(index, x, y, z);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib3sv4(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib3sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib4Niv4(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib4Niv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib4Nsv4(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib4Nsv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib4Nub4(void* ptr, unsigned int index, char* x, char* y, char* z, char* w)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib4Nub(index, *static_cast<GLubyte*>(static_cast<void*>(x)), *static_cast<GLubyte*>(static_cast<void*>(y)), *static_cast<GLubyte*>(static_cast<void*>(z)), *static_cast<GLubyte*>(static_cast<void*>(w)));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib4Nubv4(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib4Nubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib4Nuiv4(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib4Nuiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib4Nusv4(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib4Nusv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib4f4(void* ptr, unsigned int index, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib4f(index, x, y, z, w);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib4fv4(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib4fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib4iv4(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib4s4(void* ptr, unsigned int index, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib4s(index, x, y, z, w);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib4sv4(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib4sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib4ubv4(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib4ubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib4uiv4(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttrib4usv4(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttrib4usv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribDivisor4(void* ptr, unsigned int index, unsigned int divisor)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribDivisor(index, divisor);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribI1i4(void* ptr, unsigned int index, int x)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribI1i(index, x);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribI1iv4(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribI1iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribI1ui4(void* ptr, unsigned int index, unsigned int x)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribI1ui(index, x);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribI1uiv4(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribI1uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribI2i4(void* ptr, unsigned int index, int x, int y)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribI2i(index, x, y);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribI2iv4(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribI2iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribI2ui4(void* ptr, unsigned int index, unsigned int x, unsigned int y)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribI2ui(index, x, y);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribI2uiv4(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribI2uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribI3i4(void* ptr, unsigned int index, int x, int y, int z)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribI3i(index, x, y, z);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribI3iv4(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribI3iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribI3ui4(void* ptr, unsigned int index, unsigned int x, unsigned int y, unsigned int z)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribI3ui(index, x, y, z);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribI3uiv4(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribI3uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribI4i4(void* ptr, unsigned int index, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribI4i(index, x, y, z, w);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribI4iv4(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribI4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribI4sv4(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribI4sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribI4ubv4(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribI4ubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribI4ui4(void* ptr, unsigned int index, unsigned int x, unsigned int y, unsigned int z, unsigned int w)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribI4ui(index, x, y, z, w);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribI4uiv4(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribI4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribI4usv4(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribI4usv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribIPointer4(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribIPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribP1ui4(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribP1ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribP1uiv4(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribP1uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribP2ui4(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribP2ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribP2uiv4(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribP2uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribP3ui4(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribP3ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribP3uiv4(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribP3uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribP4ui4(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribP4ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribP4uiv4(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribP4uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexAttribPointer4(void* ptr, unsigned int index, int size, unsigned int ty, char normalized, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexAttribPointer(index, size, ty, normalized != 0, stride, pointer);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexP2ui4(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexP2ui(ty, value);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexP2uiv4(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexP2uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexP3ui4(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexP3ui(ty, value);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexP3uiv4(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexP3uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexP4ui4(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexP4ui(ty, value);
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexP4uiv4(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexP4uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_3_Compatibility_GlVertexPointer4(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glVertexPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_3_3_Compatibility_GlViewport4(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_3_3_Compatibility_GlWindowPos2f4(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glWindowPos2f(x, y);
}
void QOpenGLFunctions_3_3_Compatibility_GlWindowPos2fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glWindowPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlWindowPos2i4(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glWindowPos2i(x, y);
}
void QOpenGLFunctions_3_3_Compatibility_GlWindowPos2iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glWindowPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlWindowPos2s4(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glWindowPos2s(x, y);
}
void QOpenGLFunctions_3_3_Compatibility_GlWindowPos2sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glWindowPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlWindowPos3f4(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glWindowPos3f(x, y, z);
}
void QOpenGLFunctions_3_3_Compatibility_GlWindowPos3fv4(void* ptr, float v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glWindowPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlWindowPos3i4(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glWindowPos3i(x, y, z);
}
void QOpenGLFunctions_3_3_Compatibility_GlWindowPos3iv4(void* ptr, int v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glWindowPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_GlWindowPos3s4(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glWindowPos3s(x, y, z);
}
void QOpenGLFunctions_3_3_Compatibility_GlWindowPos3sv4(void* ptr, short v)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->glWindowPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_3_3_Compatibility_DestroyQOpenGLFunctions_3_3_Compatibility4(void* ptr)
{
static_cast<QOpenGLFunctions_3_3_Compatibility*>(ptr)->~QOpenGLFunctions_3_3_Compatibility();
}
void QOpenGLFunctions_3_3_Compatibility_DestroyQOpenGLFunctions_3_3_Compatibility4Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_3_3_Core: public QOpenGLFunctions_3_3_Core
{
public:
MyQOpenGLFunctions_3_3_Core() : QOpenGLFunctions_3_3_Core() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_3_3_Core_InitializeOpenGLFunctions4(this) != 0; };
~MyQOpenGLFunctions_3_3_Core() { callbackQOpenGLFunctions_3_3_Core_DestroyQOpenGLFunctions_3_3_Core4(this); };
};
char QOpenGLFunctions_3_3_Core_GlIsBuffer4(void* ptr, unsigned int buffer)
{
return static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glIsBuffer(buffer);
}
char QOpenGLFunctions_3_3_Core_GlIsEnabled4(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_3_3_Core_GlIsEnabledi4(void* ptr, unsigned int target, unsigned int index)
{
return static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glIsEnabledi(target, index);
}
char QOpenGLFunctions_3_3_Core_GlIsFramebuffer4(void* ptr, unsigned int framebuffer)
{
return static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glIsFramebuffer(framebuffer);
}
char QOpenGLFunctions_3_3_Core_GlIsProgram4(void* ptr, unsigned int program)
{
return static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glIsProgram(program);
}
char QOpenGLFunctions_3_3_Core_GlIsQuery4(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glIsQuery(id);
}
char QOpenGLFunctions_3_3_Core_GlIsRenderbuffer4(void* ptr, unsigned int renderbuffer)
{
return static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glIsRenderbuffer(renderbuffer);
}
char QOpenGLFunctions_3_3_Core_GlIsSampler4(void* ptr, unsigned int sampler)
{
return static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glIsSampler(sampler);
}
char QOpenGLFunctions_3_3_Core_GlIsShader4(void* ptr, unsigned int shader)
{
return static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glIsShader(shader);
}
char QOpenGLFunctions_3_3_Core_GlIsTexture4(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glIsTexture(texture);
}
char QOpenGLFunctions_3_3_Core_GlIsVertexArray4(void* ptr, unsigned int array)
{
return static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glIsVertexArray(array);
}
char QOpenGLFunctions_3_3_Core_GlUnmapBuffer4(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUnmapBuffer(target);
}
unsigned int QOpenGLFunctions_3_3_Core_GlCheckFramebufferStatus4(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glCheckFramebufferStatus(target);
}
unsigned int QOpenGLFunctions_3_3_Core_GlGetError4(void* ptr)
{
return static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetError();
}
unsigned int QOpenGLFunctions_3_3_Core_GlCreateProgram4(void* ptr)
{
return static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glCreateProgram();
}
unsigned int QOpenGLFunctions_3_3_Core_GlCreateShader4(void* ptr, unsigned int ty)
{
return static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glCreateShader(ty);
}
void* QOpenGLFunctions_3_3_Core_GlMapBuffer4(void* ptr, unsigned int target, unsigned int access)
{
return static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glMapBuffer(target, access);
}
void* QOpenGLFunctions_3_3_Core_NewQOpenGLFunctions_3_3_Core4()
{
return new MyQOpenGLFunctions_3_3_Core();
}
char QOpenGLFunctions_3_3_Core_InitializeOpenGLFunctions4(void* ptr)
{
return static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_3_3_Core_InitializeOpenGLFunctions4Default(void* ptr)
{
return static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->QOpenGLFunctions_3_3_Core::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_3_3_Core_GlGetString4(void* ptr, unsigned int name)
{
return ({ char* tda4b85 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetString(name)))); QtGui_PackedString { tda4b85, -1 }; });
}
struct QtGui_PackedString QOpenGLFunctions_3_3_Core_GlGetStringi4(void* ptr, unsigned int name, unsigned int index)
{
return ({ char* tcdb60e = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetStringi(name, index)))); QtGui_PackedString { tcdb60e, -1 }; });
}
void QOpenGLFunctions_3_3_Core_GlActiveTexture4(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glActiveTexture(texture);
}
void QOpenGLFunctions_3_3_Core_GlAttachShader4(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glAttachShader(program, shader);
}
void QOpenGLFunctions_3_3_Core_GlBeginConditionalRender4(void* ptr, unsigned int id, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glBeginConditionalRender(id, mode);
}
void QOpenGLFunctions_3_3_Core_GlBeginQuery4(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glBeginQuery(target, id);
}
void QOpenGLFunctions_3_3_Core_GlBeginTransformFeedback4(void* ptr, unsigned int primitiveMode)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glBeginTransformFeedback(primitiveMode);
}
void QOpenGLFunctions_3_3_Core_GlBindBuffer4(void* ptr, unsigned int target, unsigned int buffer)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glBindBuffer(target, buffer);
}
void QOpenGLFunctions_3_3_Core_GlBindBufferBase4(void* ptr, unsigned int target, unsigned int index, unsigned int buffer)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glBindBufferBase(target, index, buffer);
}
void QOpenGLFunctions_3_3_Core_GlBindFramebuffer4(void* ptr, unsigned int target, unsigned int framebuffer)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glBindFramebuffer(target, framebuffer);
}
void QOpenGLFunctions_3_3_Core_GlBindRenderbuffer4(void* ptr, unsigned int target, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glBindRenderbuffer(target, renderbuffer);
}
void QOpenGLFunctions_3_3_Core_GlBindSampler4(void* ptr, unsigned int unit, unsigned int sampler)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glBindSampler(unit, sampler);
}
void QOpenGLFunctions_3_3_Core_GlBindTexture4(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_3_3_Core_GlBindVertexArray4(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glBindVertexArray(array);
}
void QOpenGLFunctions_3_3_Core_GlBlendColor4(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_3_3_Core_GlBlendEquation4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_3_3_Core_GlBlendEquationSeparate4(void* ptr, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glBlendEquationSeparate(modeRGB, modeAlpha);
}
void QOpenGLFunctions_3_3_Core_GlBlendFunc4(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_3_3_Core_GlBlendFuncSeparate4(void* ptr, unsigned int sfactorRGB, unsigned int dfactorRGB, unsigned int sfactorAlpha, unsigned int dfactorAlpha)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void QOpenGLFunctions_3_3_Core_GlBlitFramebuffer4(void* ptr, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, unsigned int mask, unsigned int filter)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
void QOpenGLFunctions_3_3_Core_GlClampColor4(void* ptr, unsigned int target, unsigned int clamp)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glClampColor(target, clamp);
}
void QOpenGLFunctions_3_3_Core_GlClear4(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_3_3_Core_GlClearBufferfi4(void* ptr, unsigned int buffer, int drawbuffer, float depth, int stencil)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glClearBufferfi(buffer, drawbuffer, depth, stencil);
}
void QOpenGLFunctions_3_3_Core_GlClearBufferfv4(void* ptr, unsigned int buffer, int drawbuffer, float value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glClearBufferfv(buffer, drawbuffer, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlClearBufferiv4(void* ptr, unsigned int buffer, int drawbuffer, int value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glClearBufferiv(buffer, drawbuffer, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlClearBufferuiv4(void* ptr, unsigned int buffer, int drawbuffer, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glClearBufferuiv(buffer, drawbuffer, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlClearColor4(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_3_3_Core_GlClearStencil4(void* ptr, int s)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_3_3_Core_GlColorMask4(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_3_3_Core_GlColorMaski4(void* ptr, unsigned int index, char r, char g, char b, char a)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glColorMaski(index, r != 0, g != 0, b != 0, a != 0);
}
void QOpenGLFunctions_3_3_Core_GlColorP3ui4(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glColorP3ui(ty, color);
}
void QOpenGLFunctions_3_3_Core_GlColorP3uiv4(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glColorP3uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_3_3_Core_GlColorP4ui4(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glColorP4ui(ty, color);
}
void QOpenGLFunctions_3_3_Core_GlColorP4uiv4(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glColorP4uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_3_3_Core_GlCompileShader4(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glCompileShader(shader);
}
void QOpenGLFunctions_3_3_Core_GlCompressedTexImage1D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
void QOpenGLFunctions_3_3_Core_GlCompressedTexImage2D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void QOpenGLFunctions_3_3_Core_GlCompressedTexImage3D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int depth, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void QOpenGLFunctions_3_3_Core_GlCompressedTexSubImage1D4(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_3_3_Core_GlCompressedTexSubImage2D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_3_3_Core_GlCompressedTexSubImage3D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_3_3_Core_GlCopyTexImage1D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_3_3_Core_GlCopyTexImage2D4(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_3_3_Core_GlCopyTexSubImage1D4(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_3_3_Core_GlCopyTexSubImage2D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_3_3_Core_GlCopyTexSubImage3D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_3_3_Core_GlCullFace4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_3_3_Core_GlDeleteBuffers4(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDeleteBuffers(n, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_3_3_Core_GlDeleteFramebuffers4(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDeleteFramebuffers(n, const_cast<const GLuint*>(&framebuffers));
}
void QOpenGLFunctions_3_3_Core_GlDeleteProgram4(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDeleteProgram(program);
}
void QOpenGLFunctions_3_3_Core_GlDeleteQueries4(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDeleteQueries(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_3_3_Core_GlDeleteRenderbuffers4(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDeleteRenderbuffers(n, const_cast<const GLuint*>(&renderbuffers));
}
void QOpenGLFunctions_3_3_Core_GlDeleteSamplers4(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDeleteSamplers(count, const_cast<const GLuint*>(&samplers));
}
void QOpenGLFunctions_3_3_Core_GlDeleteShader4(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDeleteShader(shader);
}
void QOpenGLFunctions_3_3_Core_GlDeleteTextures4(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_3_3_Core_GlDeleteVertexArrays4(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDeleteVertexArrays(n, const_cast<const GLuint*>(&arrays));
}
void QOpenGLFunctions_3_3_Core_GlDepthFunc4(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_3_3_Core_GlDepthMask4(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_3_3_Core_GlDetachShader4(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDetachShader(program, shader);
}
void QOpenGLFunctions_3_3_Core_GlDisable4(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_3_3_Core_GlDisableVertexAttribArray4(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDisableVertexAttribArray(index);
}
void QOpenGLFunctions_3_3_Core_GlDisablei4(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDisablei(target, index);
}
void QOpenGLFunctions_3_3_Core_GlDrawArrays4(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_3_3_Core_GlDrawArraysInstanced4(void* ptr, unsigned int mode, int first, int count, int instancecount)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDrawArraysInstanced(mode, first, count, instancecount);
}
void QOpenGLFunctions_3_3_Core_GlDrawBuffer4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDrawBuffer(mode);
}
void QOpenGLFunctions_3_3_Core_GlDrawBuffers4(void* ptr, int n, unsigned int bufs)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDrawBuffers(n, const_cast<const GLenum*>(&bufs));
}
void QOpenGLFunctions_3_3_Core_GlDrawElements4(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_3_3_Core_GlDrawElementsBaseVertex4(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDrawElementsBaseVertex(mode, count, ty, indices, basevertex);
}
void QOpenGLFunctions_3_3_Core_GlDrawElementsInstanced4(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDrawElementsInstanced(mode, count, ty, indices, instancecount);
}
void QOpenGLFunctions_3_3_Core_GlDrawElementsInstancedBaseVertex4(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDrawElementsInstancedBaseVertex(mode, count, ty, indices, instancecount, basevertex);
}
void QOpenGLFunctions_3_3_Core_GlDrawRangeElements4(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLFunctions_3_3_Core_GlDrawRangeElementsBaseVertex4(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glDrawRangeElementsBaseVertex(mode, start, end, count, ty, indices, basevertex);
}
void QOpenGLFunctions_3_3_Core_GlEnable4(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_3_3_Core_GlEnableVertexAttribArray4(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glEnableVertexAttribArray(index);
}
void QOpenGLFunctions_3_3_Core_GlEnablei4(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glEnablei(target, index);
}
void QOpenGLFunctions_3_3_Core_GlEndConditionalRender4(void* ptr)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glEndConditionalRender();
}
void QOpenGLFunctions_3_3_Core_GlEndQuery4(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glEndQuery(target);
}
void QOpenGLFunctions_3_3_Core_GlEndTransformFeedback4(void* ptr)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glEndTransformFeedback();
}
void QOpenGLFunctions_3_3_Core_GlFinish4(void* ptr)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glFinish();
}
void QOpenGLFunctions_3_3_Core_GlFlush4(void* ptr)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glFlush();
}
void QOpenGLFunctions_3_3_Core_GlFramebufferRenderbuffer4(void* ptr, unsigned int target, unsigned int attachment, unsigned int renderbuffertarget, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
void QOpenGLFunctions_3_3_Core_GlFramebufferTexture4(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glFramebufferTexture(target, attachment, texture, level);
}
void QOpenGLFunctions_3_3_Core_GlFramebufferTexture1D4(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glFramebufferTexture1D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_3_3_Core_GlFramebufferTexture2D4(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_3_3_Core_GlFramebufferTexture3D4(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level, int zoffset)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}
void QOpenGLFunctions_3_3_Core_GlFramebufferTextureLayer4(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level, int layer)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glFramebufferTextureLayer(target, attachment, texture, level, layer);
}
void QOpenGLFunctions_3_3_Core_GlFrontFace4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_3_3_Core_GlGenBuffers4(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGenBuffers(n, &buffers);
}
void QOpenGLFunctions_3_3_Core_GlGenFramebuffers4(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGenFramebuffers(n, &framebuffers);
}
void QOpenGLFunctions_3_3_Core_GlGenQueries4(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGenQueries(n, &ids);
}
void QOpenGLFunctions_3_3_Core_GlGenRenderbuffers4(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGenRenderbuffers(n, &renderbuffers);
}
void QOpenGLFunctions_3_3_Core_GlGenSamplers4(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGenSamplers(count, &samplers);
}
void QOpenGLFunctions_3_3_Core_GlGenTextures4(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_3_3_Core_GlGenVertexArrays4(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGenVertexArrays(n, &arrays);
}
void QOpenGLFunctions_3_3_Core_GlGenerateMipmap4(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGenerateMipmap(target);
}
void QOpenGLFunctions_3_3_Core_GlGetActiveUniformBlockiv4(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetActiveUniformsiv4(void* ptr, unsigned int program, int uniformCount, unsigned int uniformIndices, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetActiveUniformsiv(program, uniformCount, const_cast<const GLuint*>(&uniformIndices), pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetAttachedShaders4(void* ptr, unsigned int program, int maxCount, int count, unsigned int obj)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetAttachedShaders(program, maxCount, &count, &obj);
}
void QOpenGLFunctions_3_3_Core_GlGetBooleani_v4(void* ptr, unsigned int target, unsigned int index, char data)
{
Q_UNUSED(data);
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetBooleani_v(target, index, NULL);
}
void QOpenGLFunctions_3_3_Core_GlGetBooleanv4(void* ptr, unsigned int pname, char params)
{
Q_UNUSED(params);
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_3_3_Core_GlGetBufferParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetBufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetBufferPointerv4(void* ptr, unsigned int target, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetBufferPointerv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetCompressedTexImage4(void* ptr, unsigned int target, int level, void* img)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetCompressedTexImage(target, level, img);
}
void QOpenGLFunctions_3_3_Core_GlGetFloatv4(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetFloatv(pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetFramebufferAttachmentParameteriv4(void* ptr, unsigned int target, unsigned int attachment, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetFramebufferAttachmentParameteriv(target, attachment, pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetIntegeri_v4(void* ptr, unsigned int target, unsigned int index, int data)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetIntegeri_v(target, index, &data);
}
void QOpenGLFunctions_3_3_Core_GlGetIntegerv4(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetIntegerv(pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetMultisamplefv4(void* ptr, unsigned int pname, unsigned int index, float val)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetMultisamplefv(pname, index, &val);
}
void QOpenGLFunctions_3_3_Core_GlGetPointerv4(void* ptr, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetPointerv(pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetProgramiv4(void* ptr, unsigned int program, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetProgramiv(program, pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetQueryObjectiv4(void* ptr, unsigned int id, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetQueryObjectiv(id, pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetQueryObjectuiv4(void* ptr, unsigned int id, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetQueryObjectuiv(id, pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetQueryiv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetQueryiv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetRenderbufferParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetRenderbufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetSamplerParameterIiv4(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetSamplerParameterIiv(sampler, pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetSamplerParameterIuiv4(void* ptr, unsigned int sampler, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetSamplerParameterIuiv(sampler, pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetSamplerParameterfv4(void* ptr, unsigned int sampler, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetSamplerParameterfv(sampler, pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetSamplerParameteriv4(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetSamplerParameteriv(sampler, pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetShaderiv4(void* ptr, unsigned int shader, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetShaderiv(shader, pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetTexImage4(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_3_3_Core_GlGetTexLevelParameterfv4(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetTexLevelParameteriv4(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetTexParameterIiv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetTexParameterIiv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetTexParameterIuiv4(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetTexParameterIuiv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetTexParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetTexParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetUniformfv4(void* ptr, unsigned int program, int location, float params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetUniformfv(program, location, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetUniformiv4(void* ptr, unsigned int program, int location, int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetUniformiv(program, location, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetUniformuiv4(void* ptr, unsigned int program, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetUniformuiv(program, location, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetVertexAttribIiv4(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetVertexAttribIiv(index, pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetVertexAttribIuiv4(void* ptr, unsigned int index, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetVertexAttribIuiv(index, pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetVertexAttribPointerv4(void* ptr, unsigned int index, unsigned int pname, void* pointer)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetVertexAttribPointerv(index, pname, &pointer);
}
void QOpenGLFunctions_3_3_Core_GlGetVertexAttribfv4(void* ptr, unsigned int index, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetVertexAttribfv(index, pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlGetVertexAttribiv4(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glGetVertexAttribiv(index, pname, &params);
}
void QOpenGLFunctions_3_3_Core_GlHint4(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_3_3_Core_GlIndexub4(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glIndexub(*static_cast<GLubyte*>(static_cast<void*>(c)));
}
void QOpenGLFunctions_3_3_Core_GlIndexubv4(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glIndexubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(c))));
}
void QOpenGLFunctions_3_3_Core_GlLineWidth4(void* ptr, float width)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_3_3_Core_GlLinkProgram4(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glLinkProgram(program);
}
void QOpenGLFunctions_3_3_Core_GlLogicOp4(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_3_3_Core_GlMultiDrawArrays4(void* ptr, unsigned int mode, int first, int count, int drawcount)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glMultiDrawArrays(mode, const_cast<const GLint*>(&first), const_cast<const GLsizei*>(&count), drawcount);
}
void QOpenGLFunctions_3_3_Core_GlMultiTexCoordP1ui4(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glMultiTexCoordP1ui(texture, ty, coords);
}
void QOpenGLFunctions_3_3_Core_GlMultiTexCoordP1uiv4(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glMultiTexCoordP1uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_3_3_Core_GlMultiTexCoordP2ui4(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glMultiTexCoordP2ui(texture, ty, coords);
}
void QOpenGLFunctions_3_3_Core_GlMultiTexCoordP2uiv4(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glMultiTexCoordP2uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_3_3_Core_GlMultiTexCoordP3ui4(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glMultiTexCoordP3ui(texture, ty, coords);
}
void QOpenGLFunctions_3_3_Core_GlMultiTexCoordP3uiv4(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glMultiTexCoordP3uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_3_3_Core_GlMultiTexCoordP4ui4(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glMultiTexCoordP4ui(texture, ty, coords);
}
void QOpenGLFunctions_3_3_Core_GlMultiTexCoordP4uiv4(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glMultiTexCoordP4uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_3_3_Core_GlNormalP3ui4(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glNormalP3ui(ty, coords);
}
void QOpenGLFunctions_3_3_Core_GlNormalP3uiv4(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glNormalP3uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_3_3_Core_GlPixelStoref4(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_3_3_Core_GlPixelStorei4(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_3_3_Core_GlPointParameterf4(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glPointParameterf(pname, param);
}
void QOpenGLFunctions_3_3_Core_GlPointParameterfv4(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glPointParameterfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_3_Core_GlPointParameteri4(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glPointParameteri(pname, param);
}
void QOpenGLFunctions_3_3_Core_GlPointParameteriv4(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glPointParameteriv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_3_Core_GlPointSize4(void* ptr, float size)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_3_3_Core_GlPolygonMode4(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_3_3_Core_GlPolygonOffset4(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_3_3_Core_GlPrimitiveRestartIndex4(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glPrimitiveRestartIndex(index);
}
void QOpenGLFunctions_3_3_Core_GlProvokingVertex4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glProvokingVertex(mode);
}
void QOpenGLFunctions_3_3_Core_GlQueryCounter4(void* ptr, unsigned int id, unsigned int target)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glQueryCounter(id, target);
}
void QOpenGLFunctions_3_3_Core_GlReadBuffer4(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glReadBuffer(mode);
}
void QOpenGLFunctions_3_3_Core_GlReadPixels4(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_3_3_Core_GlRenderbufferStorage4(void* ptr, unsigned int target, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glRenderbufferStorage(target, internalformat, width, height);
}
void QOpenGLFunctions_3_3_Core_GlRenderbufferStorageMultisample4(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
}
void QOpenGLFunctions_3_3_Core_GlSampleCoverage4(void* ptr, float value, char invert)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glSampleCoverage(value, invert != 0);
}
void QOpenGLFunctions_3_3_Core_GlSampleMaski4(void* ptr, unsigned int index, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glSampleMaski(index, mask);
}
void QOpenGLFunctions_3_3_Core_GlSamplerParameterIiv4(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glSamplerParameterIiv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_3_3_Core_GlSamplerParameterIuiv4(void* ptr, unsigned int sampler, unsigned int pname, unsigned int param)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glSamplerParameterIuiv(sampler, pname, const_cast<const GLuint*>(&param));
}
void QOpenGLFunctions_3_3_Core_GlSamplerParameterf4(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glSamplerParameterf(sampler, pname, param);
}
void QOpenGLFunctions_3_3_Core_GlSamplerParameterfv4(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glSamplerParameterfv(sampler, pname, const_cast<const GLfloat*>(&param));
}
void QOpenGLFunctions_3_3_Core_GlSamplerParameteri4(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glSamplerParameteri(sampler, pname, param);
}
void QOpenGLFunctions_3_3_Core_GlSamplerParameteriv4(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glSamplerParameteriv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_3_3_Core_GlScissor4(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_3_3_Core_GlSecondaryColorP3ui4(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glSecondaryColorP3ui(ty, color);
}
void QOpenGLFunctions_3_3_Core_GlSecondaryColorP3uiv4(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glSecondaryColorP3uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_3_3_Core_GlStencilFunc4(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_3_3_Core_GlStencilFuncSeparate4(void* ptr, unsigned int face, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glStencilFuncSeparate(face, fu, ref, mask);
}
void QOpenGLFunctions_3_3_Core_GlStencilMask4(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_3_3_Core_GlStencilMaskSeparate4(void* ptr, unsigned int face, unsigned int mask)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glStencilMaskSeparate(face, mask);
}
void QOpenGLFunctions_3_3_Core_GlStencilOp4(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_3_3_Core_GlStencilOpSeparate4(void* ptr, unsigned int face, unsigned int sfail, unsigned int dpfail, unsigned int dppass)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glStencilOpSeparate(face, sfail, dpfail, dppass);
}
void QOpenGLFunctions_3_3_Core_GlTexBuffer4(void* ptr, unsigned int target, unsigned int internalformat, unsigned int buffer)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glTexBuffer(target, internalformat, buffer);
}
void QOpenGLFunctions_3_3_Core_GlTexCoordP1ui4(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glTexCoordP1ui(ty, coords);
}
void QOpenGLFunctions_3_3_Core_GlTexCoordP1uiv4(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glTexCoordP1uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_3_3_Core_GlTexCoordP2ui4(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glTexCoordP2ui(ty, coords);
}
void QOpenGLFunctions_3_3_Core_GlTexCoordP2uiv4(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glTexCoordP2uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_3_3_Core_GlTexCoordP3ui4(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glTexCoordP3ui(ty, coords);
}
void QOpenGLFunctions_3_3_Core_GlTexCoordP3uiv4(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glTexCoordP3uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_3_3_Core_GlTexCoordP4ui4(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glTexCoordP4ui(ty, coords);
}
void QOpenGLFunctions_3_3_Core_GlTexCoordP4uiv4(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glTexCoordP4uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_3_3_Core_GlTexImage1D4(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_3_3_Core_GlTexImage2D4(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_3_3_Core_GlTexImage2DMultisample4(void* ptr, unsigned int target, int samples, int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLFunctions_3_3_Core_GlTexImage3D4(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLFunctions_3_3_Core_GlTexImage3DMultisample4(void* ptr, unsigned int target, int samples, int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLFunctions_3_3_Core_GlTexParameterIiv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glTexParameterIiv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_3_Core_GlTexParameterIuiv4(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glTexParameterIuiv(target, pname, const_cast<const GLuint*>(&params));
}
void QOpenGLFunctions_3_3_Core_GlTexParameterf4(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_3_3_Core_GlTexParameterfv4(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_3_3_Core_GlTexParameteri4(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_3_3_Core_GlTexParameteriv4(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_3_3_Core_GlTexSubImage1D4(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_3_3_Core_GlTexSubImage2D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_3_3_Core_GlTexSubImage3D4(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_3_3_Core_GlUniform1f4(void* ptr, int location, float v0)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniform1f(location, v0);
}
void QOpenGLFunctions_3_3_Core_GlUniform1fv4(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniform1fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlUniform1i4(void* ptr, int location, int v0)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniform1i(location, v0);
}
void QOpenGLFunctions_3_3_Core_GlUniform1iv4(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniform1iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlUniform1ui4(void* ptr, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniform1ui(location, v0);
}
void QOpenGLFunctions_3_3_Core_GlUniform1uiv4(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniform1uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlUniform2f4(void* ptr, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniform2f(location, v0, v1);
}
void QOpenGLFunctions_3_3_Core_GlUniform2fv4(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniform2fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlUniform2i4(void* ptr, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniform2i(location, v0, v1);
}
void QOpenGLFunctions_3_3_Core_GlUniform2iv4(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniform2iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlUniform2ui4(void* ptr, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniform2ui(location, v0, v1);
}
void QOpenGLFunctions_3_3_Core_GlUniform2uiv4(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniform2uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlUniform3f4(void* ptr, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniform3f(location, v0, v1, v2);
}
void QOpenGLFunctions_3_3_Core_GlUniform3fv4(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniform3fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlUniform3i4(void* ptr, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniform3i(location, v0, v1, v2);
}
void QOpenGLFunctions_3_3_Core_GlUniform3iv4(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniform3iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlUniform3ui4(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniform3ui(location, v0, v1, v2);
}
void QOpenGLFunctions_3_3_Core_GlUniform3uiv4(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniform3uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlUniform4f4(void* ptr, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniform4f(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_3_3_Core_GlUniform4fv4(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniform4fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlUniform4i4(void* ptr, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniform4i(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_3_3_Core_GlUniform4iv4(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniform4iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlUniform4ui4(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniform4ui(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_3_3_Core_GlUniform4uiv4(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniform4uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlUniformBlockBinding4(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int uniformBlockBinding)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}
void QOpenGLFunctions_3_3_Core_GlUniformMatrix2fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniformMatrix2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlUniformMatrix2x3fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniformMatrix2x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlUniformMatrix2x4fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniformMatrix2x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlUniformMatrix3fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniformMatrix3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlUniformMatrix3x2fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniformMatrix3x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlUniformMatrix3x4fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniformMatrix3x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlUniformMatrix4fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniformMatrix4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlUniformMatrix4x2fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniformMatrix4x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlUniformMatrix4x3fv4(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUniformMatrix4x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlUseProgram4(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glUseProgram(program);
}
void QOpenGLFunctions_3_3_Core_GlValidateProgram4(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glValidateProgram(program);
}
void QOpenGLFunctions_3_3_Core_GlVertexAttribDivisor4(void* ptr, unsigned int index, unsigned int divisor)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glVertexAttribDivisor(index, divisor);
}
void QOpenGLFunctions_3_3_Core_GlVertexAttribIPointer4(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glVertexAttribIPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_3_3_Core_GlVertexAttribP1ui4(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glVertexAttribP1ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_3_3_Core_GlVertexAttribP1uiv4(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glVertexAttribP1uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlVertexAttribP2ui4(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glVertexAttribP2ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_3_3_Core_GlVertexAttribP2uiv4(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glVertexAttribP2uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlVertexAttribP3ui4(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glVertexAttribP3ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_3_3_Core_GlVertexAttribP3uiv4(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glVertexAttribP3uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlVertexAttribP4ui4(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glVertexAttribP4ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_3_3_Core_GlVertexAttribP4uiv4(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glVertexAttribP4uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlVertexAttribPointer4(void* ptr, unsigned int index, int size, unsigned int ty, char normalized, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glVertexAttribPointer(index, size, ty, normalized != 0, stride, pointer);
}
void QOpenGLFunctions_3_3_Core_GlVertexP2ui4(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glVertexP2ui(ty, value);
}
void QOpenGLFunctions_3_3_Core_GlVertexP2uiv4(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glVertexP2uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlVertexP3ui4(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glVertexP3ui(ty, value);
}
void QOpenGLFunctions_3_3_Core_GlVertexP3uiv4(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glVertexP3uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlVertexP4ui4(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glVertexP4ui(ty, value);
}
void QOpenGLFunctions_3_3_Core_GlVertexP4uiv4(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glVertexP4uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_3_3_Core_GlViewport4(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_3_3_Core_DestroyQOpenGLFunctions_3_3_Core4(void* ptr)
{
static_cast<QOpenGLFunctions_3_3_Core*>(ptr)->~QOpenGLFunctions_3_3_Core();
}
void QOpenGLFunctions_3_3_Core_DestroyQOpenGLFunctions_3_3_Core4Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_4_0_Compatibility: public QOpenGLFunctions_4_0_Compatibility
{
public:
MyQOpenGLFunctions_4_0_Compatibility() : QOpenGLFunctions_4_0_Compatibility() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_4_0_Compatibility_InitializeOpenGLFunctions5(this) != 0; };
~MyQOpenGLFunctions_4_0_Compatibility() { callbackQOpenGLFunctions_4_0_Compatibility_DestroyQOpenGLFunctions_4_0_Compatibility5(this); };
};
char QOpenGLFunctions_4_0_Compatibility_GlAreTexturesResident5(void* ptr, int n, unsigned int textures, char residences)
{
Q_UNUSED(residences);
return static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glAreTexturesResident(n, const_cast<const GLuint*>(&textures), NULL);
}
char QOpenGLFunctions_4_0_Compatibility_GlIsBuffer5(void* ptr, unsigned int buffer)
{
return static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glIsBuffer(buffer);
}
char QOpenGLFunctions_4_0_Compatibility_GlIsEnabled5(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_4_0_Compatibility_GlIsEnabledi5(void* ptr, unsigned int target, unsigned int index)
{
return static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glIsEnabledi(target, index);
}
char QOpenGLFunctions_4_0_Compatibility_GlIsFramebuffer5(void* ptr, unsigned int framebuffer)
{
return static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glIsFramebuffer(framebuffer);
}
char QOpenGLFunctions_4_0_Compatibility_GlIsList5(void* ptr, unsigned int list)
{
return static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glIsList(list);
}
char QOpenGLFunctions_4_0_Compatibility_GlIsProgram5(void* ptr, unsigned int program)
{
return static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glIsProgram(program);
}
char QOpenGLFunctions_4_0_Compatibility_GlIsQuery5(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glIsQuery(id);
}
char QOpenGLFunctions_4_0_Compatibility_GlIsRenderbuffer5(void* ptr, unsigned int renderbuffer)
{
return static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glIsRenderbuffer(renderbuffer);
}
char QOpenGLFunctions_4_0_Compatibility_GlIsSampler5(void* ptr, unsigned int sampler)
{
return static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glIsSampler(sampler);
}
char QOpenGLFunctions_4_0_Compatibility_GlIsShader5(void* ptr, unsigned int shader)
{
return static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glIsShader(shader);
}
char QOpenGLFunctions_4_0_Compatibility_GlIsTexture5(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glIsTexture(texture);
}
char QOpenGLFunctions_4_0_Compatibility_GlIsTransformFeedback5(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glIsTransformFeedback(id);
}
char QOpenGLFunctions_4_0_Compatibility_GlIsVertexArray5(void* ptr, unsigned int array)
{
return static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glIsVertexArray(array);
}
char QOpenGLFunctions_4_0_Compatibility_GlUnmapBuffer5(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUnmapBuffer(target);
}
unsigned int QOpenGLFunctions_4_0_Compatibility_GlCheckFramebufferStatus5(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glCheckFramebufferStatus(target);
}
unsigned int QOpenGLFunctions_4_0_Compatibility_GlGetError5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetError();
}
int QOpenGLFunctions_4_0_Compatibility_GlRenderMode5(void* ptr, unsigned int mode)
{
return static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRenderMode(mode);
}
unsigned int QOpenGLFunctions_4_0_Compatibility_GlCreateProgram5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glCreateProgram();
}
unsigned int QOpenGLFunctions_4_0_Compatibility_GlCreateShader5(void* ptr, unsigned int ty)
{
return static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glCreateShader(ty);
}
unsigned int QOpenGLFunctions_4_0_Compatibility_GlGenLists5(void* ptr, int ran)
{
return static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGenLists(ran);
}
void* QOpenGLFunctions_4_0_Compatibility_GlMapBuffer5(void* ptr, unsigned int target, unsigned int access)
{
return static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMapBuffer(target, access);
}
void* QOpenGLFunctions_4_0_Compatibility_NewQOpenGLFunctions_4_0_Compatibility5()
{
return new MyQOpenGLFunctions_4_0_Compatibility();
}
char QOpenGLFunctions_4_0_Compatibility_InitializeOpenGLFunctions5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_4_0_Compatibility_InitializeOpenGLFunctions5Default(void* ptr)
{
return static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->QOpenGLFunctions_4_0_Compatibility::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_4_0_Compatibility_GlGetString5(void* ptr, unsigned int name)
{
return ({ char* t3cd0a5 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetString(name)))); QtGui_PackedString { t3cd0a5, -1 }; });
}
struct QtGui_PackedString QOpenGLFunctions_4_0_Compatibility_GlGetStringi5(void* ptr, unsigned int name, unsigned int index)
{
return ({ char* t6fce34 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetStringi(name, index)))); QtGui_PackedString { t6fce34, -1 }; });
}
void QOpenGLFunctions_4_0_Compatibility_GlAccum5(void* ptr, unsigned int op, float value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glAccum(op, value);
}
void QOpenGLFunctions_4_0_Compatibility_GlActiveTexture5(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glActiveTexture(texture);
}
void QOpenGLFunctions_4_0_Compatibility_GlAlphaFunc5(void* ptr, unsigned int fu, float ref)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glAlphaFunc(fu, ref);
}
void QOpenGLFunctions_4_0_Compatibility_GlArrayElement5(void* ptr, int i)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glArrayElement(i);
}
void QOpenGLFunctions_4_0_Compatibility_GlAttachShader5(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glAttachShader(program, shader);
}
void QOpenGLFunctions_4_0_Compatibility_GlBegin5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glBegin(mode);
}
void QOpenGLFunctions_4_0_Compatibility_GlBeginConditionalRender5(void* ptr, unsigned int id, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glBeginConditionalRender(id, mode);
}
void QOpenGLFunctions_4_0_Compatibility_GlBeginQuery5(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glBeginQuery(target, id);
}
void QOpenGLFunctions_4_0_Compatibility_GlBeginQueryIndexed5(void* ptr, unsigned int target, unsigned int index, unsigned int id)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glBeginQueryIndexed(target, index, id);
}
void QOpenGLFunctions_4_0_Compatibility_GlBeginTransformFeedback5(void* ptr, unsigned int primitiveMode)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glBeginTransformFeedback(primitiveMode);
}
void QOpenGLFunctions_4_0_Compatibility_GlBindBuffer5(void* ptr, unsigned int target, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glBindBuffer(target, buffer);
}
void QOpenGLFunctions_4_0_Compatibility_GlBindBufferBase5(void* ptr, unsigned int target, unsigned int index, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glBindBufferBase(target, index, buffer);
}
void QOpenGLFunctions_4_0_Compatibility_GlBindFramebuffer5(void* ptr, unsigned int target, unsigned int framebuffer)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glBindFramebuffer(target, framebuffer);
}
void QOpenGLFunctions_4_0_Compatibility_GlBindRenderbuffer5(void* ptr, unsigned int target, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glBindRenderbuffer(target, renderbuffer);
}
void QOpenGLFunctions_4_0_Compatibility_GlBindSampler5(void* ptr, unsigned int unit, unsigned int sampler)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glBindSampler(unit, sampler);
}
void QOpenGLFunctions_4_0_Compatibility_GlBindTexture5(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_4_0_Compatibility_GlBindTransformFeedback5(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glBindTransformFeedback(target, id);
}
void QOpenGLFunctions_4_0_Compatibility_GlBindVertexArray5(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glBindVertexArray(array);
}
void QOpenGLFunctions_4_0_Compatibility_GlBitmap5(void* ptr, int width, int height, float xorig, float yorig, float xmove, float ymove, char* bitmap)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glBitmap(width, height, xorig, yorig, xmove, ymove, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(bitmap))));
}
void QOpenGLFunctions_4_0_Compatibility_GlBlendColor5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_4_0_Compatibility_GlBlendEquation5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_4_0_Compatibility_GlBlendEquationSeparate5(void* ptr, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glBlendEquationSeparate(modeRGB, modeAlpha);
}
void QOpenGLFunctions_4_0_Compatibility_GlBlendEquationSeparatei5(void* ptr, unsigned int buf, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glBlendEquationSeparatei(buf, modeRGB, modeAlpha);
}
void QOpenGLFunctions_4_0_Compatibility_GlBlendEquationi5(void* ptr, unsigned int buf, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glBlendEquationi(buf, mode);
}
void QOpenGLFunctions_4_0_Compatibility_GlBlendFunc5(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_4_0_Compatibility_GlBlendFuncSeparate5(void* ptr, unsigned int sfactorRGB, unsigned int dfactorRGB, unsigned int sfactorAlpha, unsigned int dfactorAlpha)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void QOpenGLFunctions_4_0_Compatibility_GlBlendFuncSeparatei5(void* ptr, unsigned int buf, unsigned int srcRGB, unsigned int dstRGB, unsigned int srcAlpha, unsigned int dstAlpha)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
void QOpenGLFunctions_4_0_Compatibility_GlBlendFunci5(void* ptr, unsigned int buf, unsigned int src, unsigned int dst)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glBlendFunci(buf, src, dst);
}
void QOpenGLFunctions_4_0_Compatibility_GlBlitFramebuffer5(void* ptr, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, unsigned int mask, unsigned int filter)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
void QOpenGLFunctions_4_0_Compatibility_GlCallList5(void* ptr, unsigned int list)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glCallList(list);
}
void QOpenGLFunctions_4_0_Compatibility_GlCallLists5(void* ptr, int n, unsigned int ty, void* lists)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glCallLists(n, ty, lists);
}
void QOpenGLFunctions_4_0_Compatibility_GlClampColor5(void* ptr, unsigned int target, unsigned int clamp)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glClampColor(target, clamp);
}
void QOpenGLFunctions_4_0_Compatibility_GlClear5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_4_0_Compatibility_GlClearAccum5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glClearAccum(red, green, blue, alpha);
}
void QOpenGLFunctions_4_0_Compatibility_GlClearBufferfi5(void* ptr, unsigned int buffer, int drawbuffer, float depth, int stencil)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glClearBufferfi(buffer, drawbuffer, depth, stencil);
}
void QOpenGLFunctions_4_0_Compatibility_GlClearBufferfv5(void* ptr, unsigned int buffer, int drawbuffer, float value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glClearBufferfv(buffer, drawbuffer, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlClearBufferiv5(void* ptr, unsigned int buffer, int drawbuffer, int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glClearBufferiv(buffer, drawbuffer, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlClearBufferuiv5(void* ptr, unsigned int buffer, int drawbuffer, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glClearBufferuiv(buffer, drawbuffer, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlClearColor5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_4_0_Compatibility_GlClearIndex5(void* ptr, float c)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glClearIndex(c);
}
void QOpenGLFunctions_4_0_Compatibility_GlClearStencil5(void* ptr, int s)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_4_0_Compatibility_GlClientActiveTexture5(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glClientActiveTexture(texture);
}
void QOpenGLFunctions_4_0_Compatibility_GlColor3f5(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColor3f(red, green, blue);
}
void QOpenGLFunctions_4_0_Compatibility_GlColor3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlColor3i5(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColor3i(red, green, blue);
}
void QOpenGLFunctions_4_0_Compatibility_GlColor3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlColor3s5(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColor3s(red, green, blue);
}
void QOpenGLFunctions_4_0_Compatibility_GlColor3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlColor3ub5(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_4_0_Compatibility_GlColor3ubv5(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_0_Compatibility_GlColor3ui5(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColor3ui(red, green, blue);
}
void QOpenGLFunctions_4_0_Compatibility_GlColor3uiv5(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlColor3us5(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColor3us(red, green, blue);
}
void QOpenGLFunctions_4_0_Compatibility_GlColor3usv5(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlColor4f5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColor4f(red, green, blue, alpha);
}
void QOpenGLFunctions_4_0_Compatibility_GlColor4fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColor4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlColor4i5(void* ptr, int red, int green, int blue, int alpha)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColor4i(red, green, blue, alpha);
}
void QOpenGLFunctions_4_0_Compatibility_GlColor4iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColor4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlColor4s5(void* ptr, short red, short green, short blue, short alpha)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColor4s(red, green, blue, alpha);
}
void QOpenGLFunctions_4_0_Compatibility_GlColor4sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColor4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlColor4ub5(void* ptr, char* red, char* green, char* blue, char* alpha)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColor4ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)), *static_cast<GLubyte*>(static_cast<void*>(alpha)));
}
void QOpenGLFunctions_4_0_Compatibility_GlColor4ubv5(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColor4ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_0_Compatibility_GlColor4ui5(void* ptr, unsigned int red, unsigned int green, unsigned int blue, unsigned int alpha)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColor4ui(red, green, blue, alpha);
}
void QOpenGLFunctions_4_0_Compatibility_GlColor4uiv5(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColor4uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlColor4us5(void* ptr, unsigned short red, unsigned short green, unsigned short blue, unsigned short alpha)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColor4us(red, green, blue, alpha);
}
void QOpenGLFunctions_4_0_Compatibility_GlColor4usv5(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColor4usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlColorMask5(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_4_0_Compatibility_GlColorMaski5(void* ptr, unsigned int index, char r, char g, char b, char a)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColorMaski(index, r != 0, g != 0, b != 0, a != 0);
}
void QOpenGLFunctions_4_0_Compatibility_GlColorMaterial5(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColorMaterial(face, mode);
}
void QOpenGLFunctions_4_0_Compatibility_GlColorP3ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColorP3ui(ty, color);
}
void QOpenGLFunctions_4_0_Compatibility_GlColorP3uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColorP3uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_0_Compatibility_GlColorP4ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColorP4ui(ty, color);
}
void QOpenGLFunctions_4_0_Compatibility_GlColorP4uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColorP4uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_0_Compatibility_GlColorPointer5(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_4_0_Compatibility_GlColorSubTable5(void* ptr, unsigned int target, int start, int count, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColorSubTable(target, start, count, format, ty, data);
}
void QOpenGLFunctions_4_0_Compatibility_GlColorTable5(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColorTable(target, internalformat, width, format, ty, table);
}
void QOpenGLFunctions_4_0_Compatibility_GlColorTableParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColorTableParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_0_Compatibility_GlColorTableParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glColorTableParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_0_Compatibility_GlCompileShader5(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glCompileShader(shader);
}
void QOpenGLFunctions_4_0_Compatibility_GlCompressedTexImage1D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
void QOpenGLFunctions_4_0_Compatibility_GlCompressedTexImage2D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void QOpenGLFunctions_4_0_Compatibility_GlCompressedTexImage3D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int depth, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void QOpenGLFunctions_4_0_Compatibility_GlCompressedTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_4_0_Compatibility_GlCompressedTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_4_0_Compatibility_GlCompressedTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_4_0_Compatibility_GlConvolutionFilter1D5(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glConvolutionFilter1D(target, internalformat, width, format, ty, image);
}
void QOpenGLFunctions_4_0_Compatibility_GlConvolutionFilter2D5(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glConvolutionFilter2D(target, internalformat, width, height, format, ty, image);
}
void QOpenGLFunctions_4_0_Compatibility_GlConvolutionParameterf5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glConvolutionParameterf(target, pname, params);
}
void QOpenGLFunctions_4_0_Compatibility_GlConvolutionParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glConvolutionParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_0_Compatibility_GlConvolutionParameteri5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glConvolutionParameteri(target, pname, params);
}
void QOpenGLFunctions_4_0_Compatibility_GlConvolutionParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glConvolutionParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_0_Compatibility_GlCopyColorSubTable5(void* ptr, unsigned int target, int start, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glCopyColorSubTable(target, start, x, y, width);
}
void QOpenGLFunctions_4_0_Compatibility_GlCopyColorTable5(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glCopyColorTable(target, internalformat, x, y, width);
}
void QOpenGLFunctions_4_0_Compatibility_GlCopyConvolutionFilter1D5(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glCopyConvolutionFilter1D(target, internalformat, x, y, width);
}
void QOpenGLFunctions_4_0_Compatibility_GlCopyConvolutionFilter2D5(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);
}
void QOpenGLFunctions_4_0_Compatibility_GlCopyPixels5(void* ptr, int x, int y, int width, int height, unsigned int ty)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glCopyPixels(x, y, width, height, ty);
}
void QOpenGLFunctions_4_0_Compatibility_GlCopyTexImage1D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_4_0_Compatibility_GlCopyTexImage2D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_4_0_Compatibility_GlCopyTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_4_0_Compatibility_GlCopyTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_4_0_Compatibility_GlCopyTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_4_0_Compatibility_GlCullFace5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_4_0_Compatibility_GlDeleteBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDeleteBuffers(n, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_4_0_Compatibility_GlDeleteFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDeleteFramebuffers(n, const_cast<const GLuint*>(&framebuffers));
}
void QOpenGLFunctions_4_0_Compatibility_GlDeleteLists5(void* ptr, unsigned int list, int ran)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDeleteLists(list, ran);
}
void QOpenGLFunctions_4_0_Compatibility_GlDeleteProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDeleteProgram(program);
}
void QOpenGLFunctions_4_0_Compatibility_GlDeleteQueries5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDeleteQueries(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_4_0_Compatibility_GlDeleteRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDeleteRenderbuffers(n, const_cast<const GLuint*>(&renderbuffers));
}
void QOpenGLFunctions_4_0_Compatibility_GlDeleteSamplers5(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDeleteSamplers(count, const_cast<const GLuint*>(&samplers));
}
void QOpenGLFunctions_4_0_Compatibility_GlDeleteShader5(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDeleteShader(shader);
}
void QOpenGLFunctions_4_0_Compatibility_GlDeleteTextures5(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_4_0_Compatibility_GlDeleteTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDeleteTransformFeedbacks(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_4_0_Compatibility_GlDeleteVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDeleteVertexArrays(n, const_cast<const GLuint*>(&arrays));
}
void QOpenGLFunctions_4_0_Compatibility_GlDepthFunc5(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_4_0_Compatibility_GlDepthMask5(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_4_0_Compatibility_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDetachShader(program, shader);
}
void QOpenGLFunctions_4_0_Compatibility_GlDisable5(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_4_0_Compatibility_GlDisableClientState5(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDisableClientState(array);
}
void QOpenGLFunctions_4_0_Compatibility_GlDisableVertexAttribArray5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDisableVertexAttribArray(index);
}
void QOpenGLFunctions_4_0_Compatibility_GlDisablei5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDisablei(target, index);
}
void QOpenGLFunctions_4_0_Compatibility_GlDrawArrays5(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_4_0_Compatibility_GlDrawArraysIndirect5(void* ptr, unsigned int mode, void* indirect)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDrawArraysIndirect(mode, indirect);
}
void QOpenGLFunctions_4_0_Compatibility_GlDrawArraysInstanced5(void* ptr, unsigned int mode, int first, int count, int instancecount)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDrawArraysInstanced(mode, first, count, instancecount);
}
void QOpenGLFunctions_4_0_Compatibility_GlDrawBuffer5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDrawBuffer(mode);
}
void QOpenGLFunctions_4_0_Compatibility_GlDrawBuffers5(void* ptr, int n, unsigned int bufs)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDrawBuffers(n, const_cast<const GLenum*>(&bufs));
}
void QOpenGLFunctions_4_0_Compatibility_GlDrawElements5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_4_0_Compatibility_GlDrawElementsBaseVertex5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDrawElementsBaseVertex(mode, count, ty, indices, basevertex);
}
void QOpenGLFunctions_4_0_Compatibility_GlDrawElementsIndirect5(void* ptr, unsigned int mode, unsigned int ty, void* indirect)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDrawElementsIndirect(mode, ty, indirect);
}
void QOpenGLFunctions_4_0_Compatibility_GlDrawElementsInstanced5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDrawElementsInstanced(mode, count, ty, indices, instancecount);
}
void QOpenGLFunctions_4_0_Compatibility_GlDrawElementsInstancedBaseVertex5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDrawElementsInstancedBaseVertex(mode, count, ty, indices, instancecount, basevertex);
}
void QOpenGLFunctions_4_0_Compatibility_GlDrawPixels5(void* ptr, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDrawPixels(width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_0_Compatibility_GlDrawRangeElements5(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLFunctions_4_0_Compatibility_GlDrawRangeElementsBaseVertex5(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDrawRangeElementsBaseVertex(mode, start, end, count, ty, indices, basevertex);
}
void QOpenGLFunctions_4_0_Compatibility_GlDrawTransformFeedback5(void* ptr, unsigned int mode, unsigned int id)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDrawTransformFeedback(mode, id);
}
void QOpenGLFunctions_4_0_Compatibility_GlDrawTransformFeedbackStream5(void* ptr, unsigned int mode, unsigned int id, unsigned int stream)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glDrawTransformFeedbackStream(mode, id, stream);
}
void QOpenGLFunctions_4_0_Compatibility_GlEdgeFlag5(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glEdgeFlag(flag != 0);
}
void QOpenGLFunctions_4_0_Compatibility_GlEdgeFlagPointer5(void* ptr, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glEdgeFlagPointer(stride, pointer);
}
void QOpenGLFunctions_4_0_Compatibility_GlEdgeFlagv5(void* ptr, char flag)
{
Q_UNUSED(flag);
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glEdgeFlagv(NULL);
}
void QOpenGLFunctions_4_0_Compatibility_GlEnable5(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_4_0_Compatibility_GlEnableClientState5(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glEnableClientState(array);
}
void QOpenGLFunctions_4_0_Compatibility_GlEnableVertexAttribArray5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glEnableVertexAttribArray(index);
}
void QOpenGLFunctions_4_0_Compatibility_GlEnablei5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glEnablei(target, index);
}
void QOpenGLFunctions_4_0_Compatibility_GlEnd5(void* ptr)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glEnd();
}
void QOpenGLFunctions_4_0_Compatibility_GlEndConditionalRender5(void* ptr)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glEndConditionalRender();
}
void QOpenGLFunctions_4_0_Compatibility_GlEndList5(void* ptr)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glEndList();
}
void QOpenGLFunctions_4_0_Compatibility_GlEndQuery5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glEndQuery(target);
}
void QOpenGLFunctions_4_0_Compatibility_GlEndQueryIndexed5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glEndQueryIndexed(target, index);
}
void QOpenGLFunctions_4_0_Compatibility_GlEndTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glEndTransformFeedback();
}
void QOpenGLFunctions_4_0_Compatibility_GlEvalCoord1f5(void* ptr, float u)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glEvalCoord1f(u);
}
void QOpenGLFunctions_4_0_Compatibility_GlEvalCoord1fv5(void* ptr, float u)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glEvalCoord1fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_4_0_Compatibility_GlEvalCoord2f5(void* ptr, float u, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glEvalCoord2f(u, v);
}
void QOpenGLFunctions_4_0_Compatibility_GlEvalCoord2fv5(void* ptr, float u)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glEvalCoord2fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_4_0_Compatibility_GlEvalMesh15(void* ptr, unsigned int mode, int i1, int i2)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glEvalMesh1(mode, i1, i2);
}
void QOpenGLFunctions_4_0_Compatibility_GlEvalMesh25(void* ptr, unsigned int mode, int i1, int i2, int j1, int j2)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glEvalMesh2(mode, i1, i2, j1, j2);
}
void QOpenGLFunctions_4_0_Compatibility_GlEvalPoint15(void* ptr, int i)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glEvalPoint1(i);
}
void QOpenGLFunctions_4_0_Compatibility_GlEvalPoint25(void* ptr, int i, int j)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glEvalPoint2(i, j);
}
void QOpenGLFunctions_4_0_Compatibility_GlFeedbackBuffer5(void* ptr, int size, unsigned int ty, float buffer)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glFeedbackBuffer(size, ty, &buffer);
}
void QOpenGLFunctions_4_0_Compatibility_GlFinish5(void* ptr)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glFinish();
}
void QOpenGLFunctions_4_0_Compatibility_GlFlush5(void* ptr)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glFlush();
}
void QOpenGLFunctions_4_0_Compatibility_GlFogCoordPointer5(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glFogCoordPointer(ty, stride, pointer);
}
void QOpenGLFunctions_4_0_Compatibility_GlFogCoordf5(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glFogCoordf(coord);
}
void QOpenGLFunctions_4_0_Compatibility_GlFogCoordfv5(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glFogCoordfv(const_cast<const GLfloat*>(&coord));
}
void QOpenGLFunctions_4_0_Compatibility_GlFogf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glFogf(pname, param);
}
void QOpenGLFunctions_4_0_Compatibility_GlFogfv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glFogfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_0_Compatibility_GlFogi5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glFogi(pname, param);
}
void QOpenGLFunctions_4_0_Compatibility_GlFogiv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glFogiv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_0_Compatibility_GlFramebufferRenderbuffer5(void* ptr, unsigned int target, unsigned int attachment, unsigned int renderbuffertarget, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
void QOpenGLFunctions_4_0_Compatibility_GlFramebufferTexture5(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glFramebufferTexture(target, attachment, texture, level);
}
void QOpenGLFunctions_4_0_Compatibility_GlFramebufferTexture1D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glFramebufferTexture1D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_4_0_Compatibility_GlFramebufferTexture2D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_4_0_Compatibility_GlFramebufferTexture3D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level, int zoffset)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}
void QOpenGLFunctions_4_0_Compatibility_GlFramebufferTextureLayer5(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level, int layer)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glFramebufferTextureLayer(target, attachment, texture, level, layer);
}
void QOpenGLFunctions_4_0_Compatibility_GlFrontFace5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_4_0_Compatibility_GlGenBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGenBuffers(n, &buffers);
}
void QOpenGLFunctions_4_0_Compatibility_GlGenFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGenFramebuffers(n, &framebuffers);
}
void QOpenGLFunctions_4_0_Compatibility_GlGenQueries5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGenQueries(n, &ids);
}
void QOpenGLFunctions_4_0_Compatibility_GlGenRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGenRenderbuffers(n, &renderbuffers);
}
void QOpenGLFunctions_4_0_Compatibility_GlGenSamplers5(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGenSamplers(count, &samplers);
}
void QOpenGLFunctions_4_0_Compatibility_GlGenTextures5(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_4_0_Compatibility_GlGenTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGenTransformFeedbacks(n, &ids);
}
void QOpenGLFunctions_4_0_Compatibility_GlGenVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGenVertexArrays(n, &arrays);
}
void QOpenGLFunctions_4_0_Compatibility_GlGenerateMipmap5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGenerateMipmap(target);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetActiveSubroutineUniformiv5(void* ptr, unsigned int program, unsigned int shadertype, unsigned int index, unsigned int pname, int values)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetActiveSubroutineUniformiv(program, shadertype, index, pname, &values);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetActiveUniformBlockiv5(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetActiveUniformsiv5(void* ptr, unsigned int program, int uniformCount, unsigned int uniformIndices, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetActiveUniformsiv(program, uniformCount, const_cast<const GLuint*>(&uniformIndices), pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetAttachedShaders5(void* ptr, unsigned int program, int maxCount, int count, unsigned int obj)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetAttachedShaders(program, maxCount, &count, &obj);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetBooleani_v5(void* ptr, unsigned int target, unsigned int index, char data)
{
Q_UNUSED(data);
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetBooleani_v(target, index, NULL);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetBooleanv5(void* ptr, unsigned int pname, char params)
{
Q_UNUSED(params);
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetBufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetBufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetBufferPointerv5(void* ptr, unsigned int target, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetBufferPointerv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetColorTable5(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetColorTable(target, format, ty, table);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetColorTableParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetColorTableParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetColorTableParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetColorTableParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetCompressedTexImage5(void* ptr, unsigned int target, int level, void* img)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetCompressedTexImage(target, level, img);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetConvolutionFilter5(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetConvolutionFilter(target, format, ty, image);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetConvolutionParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetConvolutionParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetConvolutionParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetConvolutionParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetFloatv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetFloatv(pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetFramebufferAttachmentParameteriv5(void* ptr, unsigned int target, unsigned int attachment, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetFramebufferAttachmentParameteriv(target, attachment, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetHistogram5(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetHistogram(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetHistogramParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetHistogramParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetHistogramParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetHistogramParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetIntegeri_v5(void* ptr, unsigned int target, unsigned int index, int data)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetIntegeri_v(target, index, &data);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetIntegerv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetIntegerv(pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetLightfv5(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetLightfv(light, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetLightiv5(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetLightiv(light, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetMapfv5(void* ptr, unsigned int target, unsigned int query, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetMapfv(target, query, &v);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetMapiv5(void* ptr, unsigned int target, unsigned int query, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetMapiv(target, query, &v);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetMaterialfv5(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetMaterialfv(face, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetMaterialiv5(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetMaterialiv(face, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetMinmax5(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetMinmax(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetMinmaxParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetMinmaxParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetMinmaxParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetMinmaxParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetMultisamplefv5(void* ptr, unsigned int pname, unsigned int index, float val)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetMultisamplefv(pname, index, &val);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetPixelMapfv5(void* ptr, unsigned int m, float values)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetPixelMapfv(m, &values);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetPixelMapuiv5(void* ptr, unsigned int m, unsigned int values)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetPixelMapuiv(m, &values);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetPixelMapusv5(void* ptr, unsigned int m, unsigned short values)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetPixelMapusv(m, &values);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetPointerv5(void* ptr, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetPointerv(pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetPolygonStipple5(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetPolygonStipple(static_cast<GLubyte*>(static_cast<void*>(mask)));
}
void QOpenGLFunctions_4_0_Compatibility_GlGetProgramStageiv5(void* ptr, unsigned int program, unsigned int shadertype, unsigned int pname, int values)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetProgramStageiv(program, shadertype, pname, &values);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetProgramiv5(void* ptr, unsigned int program, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetProgramiv(program, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetQueryIndexediv5(void* ptr, unsigned int target, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetQueryIndexediv(target, index, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetQueryObjectiv5(void* ptr, unsigned int id, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetQueryObjectiv(id, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetQueryObjectuiv5(void* ptr, unsigned int id, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetQueryObjectuiv(id, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetQueryiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetQueryiv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetRenderbufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetRenderbufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetSamplerParameterIiv5(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetSamplerParameterIiv(sampler, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetSamplerParameterIuiv5(void* ptr, unsigned int sampler, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetSamplerParameterIuiv(sampler, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetSamplerParameterfv5(void* ptr, unsigned int sampler, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetSamplerParameterfv(sampler, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetSamplerParameteriv5(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetSamplerParameteriv(sampler, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetSeparableFilter5(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* row, void* column, void* span)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetSeparableFilter(target, format, ty, row, column, span);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetShaderiv5(void* ptr, unsigned int shader, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetShaderiv(shader, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetTexEnvfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetTexEnvfv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetTexEnviv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetTexEnviv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetTexGenfv5(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetTexGenfv(coord, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetTexGeniv5(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetTexGeniv(coord, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetTexImage5(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetTexLevelParameterfv5(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetTexLevelParameteriv5(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetTexParameterIiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetTexParameterIiv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetTexParameterIuiv5(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetTexParameterIuiv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetTexParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetTexParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetUniformSubroutineuiv5(void* ptr, unsigned int shadertype, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetUniformSubroutineuiv(shadertype, location, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetUniformfv5(void* ptr, unsigned int program, int location, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetUniformfv(program, location, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetUniformiv5(void* ptr, unsigned int program, int location, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetUniformiv(program, location, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetUniformuiv5(void* ptr, unsigned int program, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetUniformuiv(program, location, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetVertexAttribIiv5(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetVertexAttribIiv(index, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetVertexAttribIuiv5(void* ptr, unsigned int index, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetVertexAttribIuiv(index, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetVertexAttribPointerv5(void* ptr, unsigned int index, unsigned int pname, void* pointer)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetVertexAttribPointerv(index, pname, &pointer);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetVertexAttribfv5(void* ptr, unsigned int index, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetVertexAttribfv(index, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlGetVertexAttribiv5(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glGetVertexAttribiv(index, pname, &params);
}
void QOpenGLFunctions_4_0_Compatibility_GlHint5(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_4_0_Compatibility_GlHistogram5(void* ptr, unsigned int target, int width, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glHistogram(target, width, internalformat, sink != 0);
}
void QOpenGLFunctions_4_0_Compatibility_GlIndexMask5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glIndexMask(mask);
}
void QOpenGLFunctions_4_0_Compatibility_GlIndexPointer5(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glIndexPointer(ty, stride, pointer);
}
void QOpenGLFunctions_4_0_Compatibility_GlIndexf5(void* ptr, float c)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glIndexf(c);
}
void QOpenGLFunctions_4_0_Compatibility_GlIndexfv5(void* ptr, float c)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glIndexfv(const_cast<const GLfloat*>(&c));
}
void QOpenGLFunctions_4_0_Compatibility_GlIndexi5(void* ptr, int c)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glIndexi(c);
}
void QOpenGLFunctions_4_0_Compatibility_GlIndexiv5(void* ptr, int c)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glIndexiv(const_cast<const GLint*>(&c));
}
void QOpenGLFunctions_4_0_Compatibility_GlIndexs5(void* ptr, short c)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glIndexs(c);
}
void QOpenGLFunctions_4_0_Compatibility_GlIndexsv5(void* ptr, short c)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glIndexsv(const_cast<const GLshort*>(&c));
}
void QOpenGLFunctions_4_0_Compatibility_GlIndexub5(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glIndexub(*static_cast<GLubyte*>(static_cast<void*>(c)));
}
void QOpenGLFunctions_4_0_Compatibility_GlIndexubv5(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glIndexubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(c))));
}
void QOpenGLFunctions_4_0_Compatibility_GlInitNames5(void* ptr)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glInitNames();
}
void QOpenGLFunctions_4_0_Compatibility_GlInterleavedArrays5(void* ptr, unsigned int format, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glInterleavedArrays(format, stride, pointer);
}
void QOpenGLFunctions_4_0_Compatibility_GlLightModelf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glLightModelf(pname, param);
}
void QOpenGLFunctions_4_0_Compatibility_GlLightModelfv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glLightModelfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_0_Compatibility_GlLightModeli5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glLightModeli(pname, param);
}
void QOpenGLFunctions_4_0_Compatibility_GlLightModeliv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glLightModeliv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_0_Compatibility_GlLightf5(void* ptr, unsigned int light, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glLightf(light, pname, param);
}
void QOpenGLFunctions_4_0_Compatibility_GlLightfv5(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glLightfv(light, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_0_Compatibility_GlLighti5(void* ptr, unsigned int light, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glLighti(light, pname, param);
}
void QOpenGLFunctions_4_0_Compatibility_GlLightiv5(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glLightiv(light, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_0_Compatibility_GlLineStipple5(void* ptr, int factor, unsigned short pattern)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glLineStipple(factor, pattern);
}
void QOpenGLFunctions_4_0_Compatibility_GlLineWidth5(void* ptr, float width)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_4_0_Compatibility_GlLinkProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glLinkProgram(program);
}
void QOpenGLFunctions_4_0_Compatibility_GlListBase5(void* ptr, unsigned int base)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glListBase(base);
}
void QOpenGLFunctions_4_0_Compatibility_GlLoadIdentity5(void* ptr)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glLoadIdentity();
}
void QOpenGLFunctions_4_0_Compatibility_GlLoadMatrixf5(void* ptr, float m)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glLoadMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_4_0_Compatibility_GlLoadName5(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glLoadName(name);
}
void QOpenGLFunctions_4_0_Compatibility_GlLoadTransposeMatrixf5(void* ptr, float m)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glLoadTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_4_0_Compatibility_GlLogicOp5(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_4_0_Compatibility_GlMap1f5(void* ptr, unsigned int target, float u1, float u2, int stride, int order, float points)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMap1f(target, u1, u2, stride, order, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_4_0_Compatibility_GlMap2f5(void* ptr, unsigned int target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float points)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_4_0_Compatibility_GlMapGrid1f5(void* ptr, int un, float u1, float u2)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMapGrid1f(un, u1, u2);
}
void QOpenGLFunctions_4_0_Compatibility_GlMapGrid2f5(void* ptr, int un, float u1, float u2, int vn, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMapGrid2f(un, u1, u2, vn, v1, v2);
}
void QOpenGLFunctions_4_0_Compatibility_GlMaterialf5(void* ptr, unsigned int face, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMaterialf(face, pname, param);
}
void QOpenGLFunctions_4_0_Compatibility_GlMaterialfv5(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMaterialfv(face, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_0_Compatibility_GlMateriali5(void* ptr, unsigned int face, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMateriali(face, pname, param);
}
void QOpenGLFunctions_4_0_Compatibility_GlMaterialiv5(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMaterialiv(face, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_0_Compatibility_GlMatrixMode5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMatrixMode(mode);
}
void QOpenGLFunctions_4_0_Compatibility_GlMinSampleShading5(void* ptr, float value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMinSampleShading(value);
}
void QOpenGLFunctions_4_0_Compatibility_GlMinmax5(void* ptr, unsigned int target, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMinmax(target, internalformat, sink != 0);
}
void QOpenGLFunctions_4_0_Compatibility_GlMultMatrixf5(void* ptr, float m)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_4_0_Compatibility_GlMultTransposeMatrixf5(void* ptr, float m)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiDrawArrays5(void* ptr, unsigned int mode, int first, int count, int drawcount)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiDrawArrays(mode, const_cast<const GLint*>(&first), const_cast<const GLsizei*>(&count), drawcount);
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoord1f5(void* ptr, unsigned int target, float s)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoord1f(target, s);
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoord1fv5(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoord1fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoord1i5(void* ptr, unsigned int target, int s)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoord1i(target, s);
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoord1iv5(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoord1iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoord1s5(void* ptr, unsigned int target, short s)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoord1s(target, s);
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoord1sv5(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoord1sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoord2f5(void* ptr, unsigned int target, float s, float t)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoord2f(target, s, t);
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoord2fv5(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoord2fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoord2i5(void* ptr, unsigned int target, int s, int t)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoord2i(target, s, t);
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoord2iv5(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoord2iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoord2s5(void* ptr, unsigned int target, short s, short t)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoord2s(target, s, t);
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoord2sv5(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoord2sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoord3f5(void* ptr, unsigned int target, float s, float t, float r)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoord3f(target, s, t, r);
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoord3fv5(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoord3fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoord3i5(void* ptr, unsigned int target, int s, int t, int r)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoord3i(target, s, t, r);
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoord3iv5(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoord3iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoord3s5(void* ptr, unsigned int target, short s, short t, short r)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoord3s(target, s, t, r);
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoord3sv5(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoord3sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoord4f5(void* ptr, unsigned int target, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoord4f(target, s, t, r, q);
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoord4fv5(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoord4fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoord4i5(void* ptr, unsigned int target, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoord4i(target, s, t, r, q);
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoord4iv5(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoord4iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoord4s5(void* ptr, unsigned int target, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoord4s(target, s, t, r, q);
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoord4sv5(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoord4sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoordP1ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoordP1ui(texture, ty, coords);
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoordP1uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoordP1uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoordP2ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoordP2ui(texture, ty, coords);
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoordP2uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoordP2uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoordP3ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoordP3ui(texture, ty, coords);
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoordP3uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoordP3uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoordP4ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoordP4ui(texture, ty, coords);
}
void QOpenGLFunctions_4_0_Compatibility_GlMultiTexCoordP4uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glMultiTexCoordP4uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_0_Compatibility_GlNewList5(void* ptr, unsigned int list, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glNewList(list, mode);
}
void QOpenGLFunctions_4_0_Compatibility_GlNormal3f5(void* ptr, float nx, float ny, float nz)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glNormal3f(nx, ny, nz);
}
void QOpenGLFunctions_4_0_Compatibility_GlNormal3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glNormal3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlNormal3i5(void* ptr, int nx, int ny, int nz)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glNormal3i(nx, ny, nz);
}
void QOpenGLFunctions_4_0_Compatibility_GlNormal3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glNormal3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlNormal3s5(void* ptr, short nx, short ny, short nz)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glNormal3s(nx, ny, nz);
}
void QOpenGLFunctions_4_0_Compatibility_GlNormal3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glNormal3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlNormalP3ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glNormalP3ui(ty, coords);
}
void QOpenGLFunctions_4_0_Compatibility_GlNormalP3uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glNormalP3uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_0_Compatibility_GlNormalPointer5(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glNormalPointer(ty, stride, pointer);
}
void QOpenGLFunctions_4_0_Compatibility_GlPassThrough5(void* ptr, float token)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPassThrough(token);
}
void QOpenGLFunctions_4_0_Compatibility_GlPatchParameterfv5(void* ptr, unsigned int pname, float values)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPatchParameterfv(pname, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_4_0_Compatibility_GlPatchParameteri5(void* ptr, unsigned int pname, int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPatchParameteri(pname, value);
}
void QOpenGLFunctions_4_0_Compatibility_GlPauseTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPauseTransformFeedback();
}
void QOpenGLFunctions_4_0_Compatibility_GlPixelMapfv5(void* ptr, unsigned int m, int mapsize, float values)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPixelMapfv(m, mapsize, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_4_0_Compatibility_GlPixelMapuiv5(void* ptr, unsigned int m, int mapsize, unsigned int values)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPixelMapuiv(m, mapsize, const_cast<const GLuint*>(&values));
}
void QOpenGLFunctions_4_0_Compatibility_GlPixelMapusv5(void* ptr, unsigned int m, int mapsize, unsigned short values)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPixelMapusv(m, mapsize, const_cast<const GLushort*>(&values));
}
void QOpenGLFunctions_4_0_Compatibility_GlPixelStoref5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_4_0_Compatibility_GlPixelStorei5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_4_0_Compatibility_GlPixelTransferf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPixelTransferf(pname, param);
}
void QOpenGLFunctions_4_0_Compatibility_GlPixelTransferi5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPixelTransferi(pname, param);
}
void QOpenGLFunctions_4_0_Compatibility_GlPixelZoom5(void* ptr, float xfactor, float yfactor)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPixelZoom(xfactor, yfactor);
}
void QOpenGLFunctions_4_0_Compatibility_GlPointParameterf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPointParameterf(pname, param);
}
void QOpenGLFunctions_4_0_Compatibility_GlPointParameterfv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPointParameterfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_0_Compatibility_GlPointParameteri5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPointParameteri(pname, param);
}
void QOpenGLFunctions_4_0_Compatibility_GlPointParameteriv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPointParameteriv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_0_Compatibility_GlPointSize5(void* ptr, float size)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_4_0_Compatibility_GlPolygonMode5(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_4_0_Compatibility_GlPolygonOffset5(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_4_0_Compatibility_GlPolygonStipple5(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPolygonStipple(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(mask))));
}
void QOpenGLFunctions_4_0_Compatibility_GlPopAttrib5(void* ptr)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPopAttrib();
}
void QOpenGLFunctions_4_0_Compatibility_GlPopClientAttrib5(void* ptr)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPopClientAttrib();
}
void QOpenGLFunctions_4_0_Compatibility_GlPopMatrix5(void* ptr)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPopMatrix();
}
void QOpenGLFunctions_4_0_Compatibility_GlPopName5(void* ptr)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPopName();
}
void QOpenGLFunctions_4_0_Compatibility_GlPrimitiveRestartIndex5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPrimitiveRestartIndex(index);
}
void QOpenGLFunctions_4_0_Compatibility_GlPrioritizeTextures5(void* ptr, int n, unsigned int textures, float priorities)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPrioritizeTextures(n, const_cast<const GLuint*>(&textures), const_cast<const GLfloat*>(&priorities));
}
void QOpenGLFunctions_4_0_Compatibility_GlProvokingVertex5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glProvokingVertex(mode);
}
void QOpenGLFunctions_4_0_Compatibility_GlPushAttrib5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPushAttrib(mask);
}
void QOpenGLFunctions_4_0_Compatibility_GlPushClientAttrib5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPushClientAttrib(mask);
}
void QOpenGLFunctions_4_0_Compatibility_GlPushMatrix5(void* ptr)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPushMatrix();
}
void QOpenGLFunctions_4_0_Compatibility_GlPushName5(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glPushName(name);
}
void QOpenGLFunctions_4_0_Compatibility_GlQueryCounter5(void* ptr, unsigned int id, unsigned int target)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glQueryCounter(id, target);
}
void QOpenGLFunctions_4_0_Compatibility_GlRasterPos2f5(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRasterPos2f(x, y);
}
void QOpenGLFunctions_4_0_Compatibility_GlRasterPos2fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRasterPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlRasterPos2i5(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRasterPos2i(x, y);
}
void QOpenGLFunctions_4_0_Compatibility_GlRasterPos2iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRasterPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlRasterPos2s5(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRasterPos2s(x, y);
}
void QOpenGLFunctions_4_0_Compatibility_GlRasterPos2sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRasterPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlRasterPos3f5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRasterPos3f(x, y, z);
}
void QOpenGLFunctions_4_0_Compatibility_GlRasterPos3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRasterPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlRasterPos3i5(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRasterPos3i(x, y, z);
}
void QOpenGLFunctions_4_0_Compatibility_GlRasterPos3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRasterPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlRasterPos3s5(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRasterPos3s(x, y, z);
}
void QOpenGLFunctions_4_0_Compatibility_GlRasterPos3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRasterPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlRasterPos4f5(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRasterPos4f(x, y, z, w);
}
void QOpenGLFunctions_4_0_Compatibility_GlRasterPos4fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRasterPos4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlRasterPos4i5(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRasterPos4i(x, y, z, w);
}
void QOpenGLFunctions_4_0_Compatibility_GlRasterPos4iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRasterPos4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlRasterPos4s5(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRasterPos4s(x, y, z, w);
}
void QOpenGLFunctions_4_0_Compatibility_GlRasterPos4sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRasterPos4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlReadBuffer5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glReadBuffer(mode);
}
void QOpenGLFunctions_4_0_Compatibility_GlReadPixels5(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_0_Compatibility_GlRectf5(void* ptr, float x1, float y1, float x2, float y2)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRectf(x1, y1, x2, y2);
}
void QOpenGLFunctions_4_0_Compatibility_GlRectfv5(void* ptr, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRectfv(const_cast<const GLfloat*>(&v1), const_cast<const GLfloat*>(&v2));
}
void QOpenGLFunctions_4_0_Compatibility_GlRecti5(void* ptr, int x1, int y1, int x2, int y2)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRecti(x1, y1, x2, y2);
}
void QOpenGLFunctions_4_0_Compatibility_GlRectiv5(void* ptr, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRectiv(const_cast<const GLint*>(&v1), const_cast<const GLint*>(&v2));
}
void QOpenGLFunctions_4_0_Compatibility_GlRects5(void* ptr, short x1, short y1, short x2, short y2)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRects(x1, y1, x2, y2);
}
void QOpenGLFunctions_4_0_Compatibility_GlRectsv5(void* ptr, short v1, short v2)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRectsv(const_cast<const GLshort*>(&v1), const_cast<const GLshort*>(&v2));
}
void QOpenGLFunctions_4_0_Compatibility_GlRenderbufferStorage5(void* ptr, unsigned int target, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRenderbufferStorage(target, internalformat, width, height);
}
void QOpenGLFunctions_4_0_Compatibility_GlRenderbufferStorageMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
}
void QOpenGLFunctions_4_0_Compatibility_GlResetHistogram5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glResetHistogram(target);
}
void QOpenGLFunctions_4_0_Compatibility_GlResetMinmax5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glResetMinmax(target);
}
void QOpenGLFunctions_4_0_Compatibility_GlResumeTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glResumeTransformFeedback();
}
void QOpenGLFunctions_4_0_Compatibility_GlRotatef5(void* ptr, float angle, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glRotatef(angle, x, y, z);
}
void QOpenGLFunctions_4_0_Compatibility_GlSampleCoverage5(void* ptr, float value, char invert)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSampleCoverage(value, invert != 0);
}
void QOpenGLFunctions_4_0_Compatibility_GlSampleMaski5(void* ptr, unsigned int index, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSampleMaski(index, mask);
}
void QOpenGLFunctions_4_0_Compatibility_GlSamplerParameterIiv5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSamplerParameterIiv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_0_Compatibility_GlSamplerParameterIuiv5(void* ptr, unsigned int sampler, unsigned int pname, unsigned int param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSamplerParameterIuiv(sampler, pname, const_cast<const GLuint*>(&param));
}
void QOpenGLFunctions_4_0_Compatibility_GlSamplerParameterf5(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSamplerParameterf(sampler, pname, param);
}
void QOpenGLFunctions_4_0_Compatibility_GlSamplerParameterfv5(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSamplerParameterfv(sampler, pname, const_cast<const GLfloat*>(&param));
}
void QOpenGLFunctions_4_0_Compatibility_GlSamplerParameteri5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSamplerParameteri(sampler, pname, param);
}
void QOpenGLFunctions_4_0_Compatibility_GlSamplerParameteriv5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSamplerParameteriv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_0_Compatibility_GlScalef5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glScalef(x, y, z);
}
void QOpenGLFunctions_4_0_Compatibility_GlScissor5(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_4_0_Compatibility_GlSecondaryColor3f5(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSecondaryColor3f(red, green, blue);
}
void QOpenGLFunctions_4_0_Compatibility_GlSecondaryColor3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSecondaryColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlSecondaryColor3i5(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSecondaryColor3i(red, green, blue);
}
void QOpenGLFunctions_4_0_Compatibility_GlSecondaryColor3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSecondaryColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlSecondaryColor3s5(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSecondaryColor3s(red, green, blue);
}
void QOpenGLFunctions_4_0_Compatibility_GlSecondaryColor3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSecondaryColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlSecondaryColor3ub5(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSecondaryColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_4_0_Compatibility_GlSecondaryColor3ubv5(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSecondaryColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_0_Compatibility_GlSecondaryColor3ui5(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSecondaryColor3ui(red, green, blue);
}
void QOpenGLFunctions_4_0_Compatibility_GlSecondaryColor3uiv5(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSecondaryColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlSecondaryColor3us5(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSecondaryColor3us(red, green, blue);
}
void QOpenGLFunctions_4_0_Compatibility_GlSecondaryColor3usv5(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSecondaryColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlSecondaryColorP3ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSecondaryColorP3ui(ty, color);
}
void QOpenGLFunctions_4_0_Compatibility_GlSecondaryColorP3uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSecondaryColorP3uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_0_Compatibility_GlSecondaryColorPointer5(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSecondaryColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_4_0_Compatibility_GlSelectBuffer5(void* ptr, int size, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSelectBuffer(size, &buffer);
}
void QOpenGLFunctions_4_0_Compatibility_GlSeparableFilter2D5(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* row, void* column)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glSeparableFilter2D(target, internalformat, width, height, format, ty, row, column);
}
void QOpenGLFunctions_4_0_Compatibility_GlShadeModel5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glShadeModel(mode);
}
void QOpenGLFunctions_4_0_Compatibility_GlStencilFunc5(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_4_0_Compatibility_GlStencilFuncSeparate5(void* ptr, unsigned int face, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glStencilFuncSeparate(face, fu, ref, mask);
}
void QOpenGLFunctions_4_0_Compatibility_GlStencilMask5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_4_0_Compatibility_GlStencilMaskSeparate5(void* ptr, unsigned int face, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glStencilMaskSeparate(face, mask);
}
void QOpenGLFunctions_4_0_Compatibility_GlStencilOp5(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_4_0_Compatibility_GlStencilOpSeparate5(void* ptr, unsigned int face, unsigned int sfail, unsigned int dpfail, unsigned int dppass)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glStencilOpSeparate(face, sfail, dpfail, dppass);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexBuffer5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexBuffer(target, internalformat, buffer);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoord1f5(void* ptr, float s)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoord1f(s);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoord1fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoord1fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoord1i5(void* ptr, int s)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoord1i(s);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoord1iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoord1iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoord1s5(void* ptr, short s)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoord1s(s);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoord1sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoord1sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoord2f5(void* ptr, float s, float t)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoord2f(s, t);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoord2fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoord2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoord2i5(void* ptr, int s, int t)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoord2i(s, t);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoord2iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoord2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoord2s5(void* ptr, short s, short t)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoord2s(s, t);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoord2sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoord2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoord3f5(void* ptr, float s, float t, float r)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoord3f(s, t, r);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoord3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoord3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoord3i5(void* ptr, int s, int t, int r)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoord3i(s, t, r);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoord3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoord3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoord3s5(void* ptr, short s, short t, short r)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoord3s(s, t, r);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoord3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoord3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoord4f5(void* ptr, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoord4f(s, t, r, q);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoord4fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoord4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoord4i5(void* ptr, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoord4i(s, t, r, q);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoord4iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoord4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoord4s5(void* ptr, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoord4s(s, t, r, q);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoord4sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoord4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoordP1ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoordP1ui(ty, coords);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoordP1uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoordP1uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoordP2ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoordP2ui(ty, coords);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoordP2uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoordP2uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoordP3ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoordP3ui(ty, coords);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoordP3uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoordP3uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoordP4ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoordP4ui(ty, coords);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoordP4uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoordP4uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_0_Compatibility_GlTexCoordPointer5(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexCoordPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexEnvf5(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexEnvf(target, pname, param);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexEnvfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexEnvfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_0_Compatibility_GlTexEnvi5(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexEnvi(target, pname, param);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexEnviv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexEnviv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_0_Compatibility_GlTexGenf5(void* ptr, unsigned int coord, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexGenf(coord, pname, param);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexGenfv5(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexGenfv(coord, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_0_Compatibility_GlTexGeni5(void* ptr, unsigned int coord, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexGeni(coord, pname, param);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexGeniv5(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexGeniv(coord, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_0_Compatibility_GlTexImage1D5(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexImage2D5(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexImage2DMultisample5(void* ptr, unsigned int target, int samples, int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexImage3D5(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexImage3DMultisample5(void* ptr, unsigned int target, int samples, int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexParameterIiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexParameterIiv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_0_Compatibility_GlTexParameterIuiv5(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexParameterIuiv(target, pname, const_cast<const GLuint*>(&params));
}
void QOpenGLFunctions_4_0_Compatibility_GlTexParameterf5(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_0_Compatibility_GlTexParameteri5(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_0_Compatibility_GlTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_0_Compatibility_GlTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_4_0_Compatibility_GlTranslatef5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glTranslatef(x, y, z);
}
void QOpenGLFunctions_4_0_Compatibility_GlUniform1f5(void* ptr, int location, float v0)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniform1f(location, v0);
}
void QOpenGLFunctions_4_0_Compatibility_GlUniform1fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniform1fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlUniform1i5(void* ptr, int location, int v0)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniform1i(location, v0);
}
void QOpenGLFunctions_4_0_Compatibility_GlUniform1iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniform1iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlUniform1ui5(void* ptr, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniform1ui(location, v0);
}
void QOpenGLFunctions_4_0_Compatibility_GlUniform1uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniform1uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlUniform2f5(void* ptr, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniform2f(location, v0, v1);
}
void QOpenGLFunctions_4_0_Compatibility_GlUniform2fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniform2fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlUniform2i5(void* ptr, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniform2i(location, v0, v1);
}
void QOpenGLFunctions_4_0_Compatibility_GlUniform2iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniform2iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlUniform2ui5(void* ptr, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniform2ui(location, v0, v1);
}
void QOpenGLFunctions_4_0_Compatibility_GlUniform2uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniform2uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlUniform3f5(void* ptr, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniform3f(location, v0, v1, v2);
}
void QOpenGLFunctions_4_0_Compatibility_GlUniform3fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniform3fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlUniform3i5(void* ptr, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniform3i(location, v0, v1, v2);
}
void QOpenGLFunctions_4_0_Compatibility_GlUniform3iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniform3iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlUniform3ui5(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniform3ui(location, v0, v1, v2);
}
void QOpenGLFunctions_4_0_Compatibility_GlUniform3uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniform3uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlUniform4f5(void* ptr, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniform4f(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_0_Compatibility_GlUniform4fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniform4fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlUniform4i5(void* ptr, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniform4i(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_0_Compatibility_GlUniform4iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniform4iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlUniform4ui5(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniform4ui(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_0_Compatibility_GlUniform4uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniform4uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlUniformBlockBinding5(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int uniformBlockBinding)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}
void QOpenGLFunctions_4_0_Compatibility_GlUniformMatrix2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniformMatrix2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlUniformMatrix2x3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniformMatrix2x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlUniformMatrix2x4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniformMatrix2x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlUniformMatrix3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniformMatrix3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlUniformMatrix3x2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniformMatrix3x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlUniformMatrix3x4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniformMatrix3x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlUniformMatrix4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniformMatrix4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlUniformMatrix4x2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniformMatrix4x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlUniformMatrix4x3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniformMatrix4x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlUniformSubroutinesuiv5(void* ptr, unsigned int shadertype, int count, unsigned int indices)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUniformSubroutinesuiv(shadertype, count, const_cast<const GLuint*>(&indices));
}
void QOpenGLFunctions_4_0_Compatibility_GlUseProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glUseProgram(program);
}
void QOpenGLFunctions_4_0_Compatibility_GlValidateProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glValidateProgram(program);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertex2f5(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertex2f(x, y);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertex2fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertex2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertex2i5(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertex2i(x, y);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertex2iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertex2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertex2s5(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertex2s(x, y);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertex2sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertex2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertex3f5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertex3f(x, y, z);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertex3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertex3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertex3i5(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertex3i(x, y, z);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertex3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertex3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertex3s5(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertex3s(x, y, z);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertex3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertex3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertex4f5(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertex4f(x, y, z, w);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertex4fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertex4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertex4i5(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertex4i(x, y, z, w);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertex4iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertex4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertex4s5(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertex4s(x, y, z, w);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertex4sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertex4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib1f5(void* ptr, unsigned int index, float x)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib1f(index, x);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib1fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib1fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib1s5(void* ptr, unsigned int index, short x)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib1s(index, x);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib1sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib1sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib2f5(void* ptr, unsigned int index, float x, float y)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib2f(index, x, y);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib2fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib2fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib2s5(void* ptr, unsigned int index, short x, short y)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib2s(index, x, y);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib2sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib2sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib3f5(void* ptr, unsigned int index, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib3f(index, x, y, z);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib3fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib3fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib3s5(void* ptr, unsigned int index, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib3s(index, x, y, z);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib3sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib3sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib4Niv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib4Niv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib4Nsv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib4Nsv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib4Nub5(void* ptr, unsigned int index, char* x, char* y, char* z, char* w)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib4Nub(index, *static_cast<GLubyte*>(static_cast<void*>(x)), *static_cast<GLubyte*>(static_cast<void*>(y)), *static_cast<GLubyte*>(static_cast<void*>(z)), *static_cast<GLubyte*>(static_cast<void*>(w)));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib4Nubv5(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib4Nubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib4Nuiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib4Nuiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib4Nusv5(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib4Nusv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib4f5(void* ptr, unsigned int index, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib4f(index, x, y, z, w);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib4fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib4fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib4iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib4s5(void* ptr, unsigned int index, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib4s(index, x, y, z, w);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib4sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib4sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib4ubv5(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib4ubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib4uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttrib4usv5(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttrib4usv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribDivisor5(void* ptr, unsigned int index, unsigned int divisor)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribDivisor(index, divisor);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribI1i5(void* ptr, unsigned int index, int x)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribI1i(index, x);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribI1iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribI1iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribI1ui5(void* ptr, unsigned int index, unsigned int x)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribI1ui(index, x);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribI1uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribI1uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribI2i5(void* ptr, unsigned int index, int x, int y)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribI2i(index, x, y);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribI2iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribI2iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribI2ui5(void* ptr, unsigned int index, unsigned int x, unsigned int y)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribI2ui(index, x, y);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribI2uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribI2uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribI3i5(void* ptr, unsigned int index, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribI3i(index, x, y, z);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribI3iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribI3iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribI3ui5(void* ptr, unsigned int index, unsigned int x, unsigned int y, unsigned int z)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribI3ui(index, x, y, z);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribI3uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribI3uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribI4i5(void* ptr, unsigned int index, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribI4i(index, x, y, z, w);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribI4iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribI4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribI4sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribI4sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribI4ubv5(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribI4ubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribI4ui5(void* ptr, unsigned int index, unsigned int x, unsigned int y, unsigned int z, unsigned int w)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribI4ui(index, x, y, z, w);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribI4uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribI4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribI4usv5(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribI4usv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribIPointer5(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribIPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribP1ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribP1ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribP1uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribP1uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribP2ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribP2ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribP2uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribP2uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribP3ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribP3ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribP3uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribP3uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribP4ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribP4ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribP4uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribP4uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexAttribPointer5(void* ptr, unsigned int index, int size, unsigned int ty, char normalized, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexAttribPointer(index, size, ty, normalized != 0, stride, pointer);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexP2ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexP2ui(ty, value);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexP2uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexP2uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexP3ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexP3ui(ty, value);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexP3uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexP3uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexP4ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexP4ui(ty, value);
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexP4uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexP4uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_0_Compatibility_GlVertexPointer5(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glVertexPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_4_0_Compatibility_GlViewport5(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_4_0_Compatibility_GlWindowPos2f5(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glWindowPos2f(x, y);
}
void QOpenGLFunctions_4_0_Compatibility_GlWindowPos2fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glWindowPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlWindowPos2i5(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glWindowPos2i(x, y);
}
void QOpenGLFunctions_4_0_Compatibility_GlWindowPos2iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glWindowPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlWindowPos2s5(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glWindowPos2s(x, y);
}
void QOpenGLFunctions_4_0_Compatibility_GlWindowPos2sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glWindowPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlWindowPos3f5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glWindowPos3f(x, y, z);
}
void QOpenGLFunctions_4_0_Compatibility_GlWindowPos3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glWindowPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlWindowPos3i5(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glWindowPos3i(x, y, z);
}
void QOpenGLFunctions_4_0_Compatibility_GlWindowPos3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glWindowPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_GlWindowPos3s5(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glWindowPos3s(x, y, z);
}
void QOpenGLFunctions_4_0_Compatibility_GlWindowPos3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->glWindowPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_0_Compatibility_DestroyQOpenGLFunctions_4_0_Compatibility5(void* ptr)
{
static_cast<QOpenGLFunctions_4_0_Compatibility*>(ptr)->~QOpenGLFunctions_4_0_Compatibility();
}
void QOpenGLFunctions_4_0_Compatibility_DestroyQOpenGLFunctions_4_0_Compatibility5Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_4_0_Core: public QOpenGLFunctions_4_0_Core
{
public:
MyQOpenGLFunctions_4_0_Core() : QOpenGLFunctions_4_0_Core() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_4_0_Core_InitializeOpenGLFunctions5(this) != 0; };
~MyQOpenGLFunctions_4_0_Core() { callbackQOpenGLFunctions_4_0_Core_DestroyQOpenGLFunctions_4_0_Core5(this); };
};
char QOpenGLFunctions_4_0_Core_GlIsBuffer5(void* ptr, unsigned int buffer)
{
return static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glIsBuffer(buffer);
}
char QOpenGLFunctions_4_0_Core_GlIsEnabled5(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_4_0_Core_GlIsEnabledi5(void* ptr, unsigned int target, unsigned int index)
{
return static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glIsEnabledi(target, index);
}
char QOpenGLFunctions_4_0_Core_GlIsFramebuffer5(void* ptr, unsigned int framebuffer)
{
return static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glIsFramebuffer(framebuffer);
}
char QOpenGLFunctions_4_0_Core_GlIsProgram5(void* ptr, unsigned int program)
{
return static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glIsProgram(program);
}
char QOpenGLFunctions_4_0_Core_GlIsQuery5(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glIsQuery(id);
}
char QOpenGLFunctions_4_0_Core_GlIsRenderbuffer5(void* ptr, unsigned int renderbuffer)
{
return static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glIsRenderbuffer(renderbuffer);
}
char QOpenGLFunctions_4_0_Core_GlIsSampler5(void* ptr, unsigned int sampler)
{
return static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glIsSampler(sampler);
}
char QOpenGLFunctions_4_0_Core_GlIsShader5(void* ptr, unsigned int shader)
{
return static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glIsShader(shader);
}
char QOpenGLFunctions_4_0_Core_GlIsTexture5(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glIsTexture(texture);
}
char QOpenGLFunctions_4_0_Core_GlIsTransformFeedback5(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glIsTransformFeedback(id);
}
char QOpenGLFunctions_4_0_Core_GlIsVertexArray5(void* ptr, unsigned int array)
{
return static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glIsVertexArray(array);
}
char QOpenGLFunctions_4_0_Core_GlUnmapBuffer5(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUnmapBuffer(target);
}
unsigned int QOpenGLFunctions_4_0_Core_GlCheckFramebufferStatus5(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glCheckFramebufferStatus(target);
}
unsigned int QOpenGLFunctions_4_0_Core_GlGetError5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetError();
}
unsigned int QOpenGLFunctions_4_0_Core_GlCreateProgram5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glCreateProgram();
}
unsigned int QOpenGLFunctions_4_0_Core_GlCreateShader5(void* ptr, unsigned int ty)
{
return static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glCreateShader(ty);
}
void* QOpenGLFunctions_4_0_Core_GlMapBuffer5(void* ptr, unsigned int target, unsigned int access)
{
return static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glMapBuffer(target, access);
}
void* QOpenGLFunctions_4_0_Core_NewQOpenGLFunctions_4_0_Core5()
{
return new MyQOpenGLFunctions_4_0_Core();
}
char QOpenGLFunctions_4_0_Core_InitializeOpenGLFunctions5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_4_0_Core_InitializeOpenGLFunctions5Default(void* ptr)
{
return static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->QOpenGLFunctions_4_0_Core::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_4_0_Core_GlGetString5(void* ptr, unsigned int name)
{
return ({ char* td46c02 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetString(name)))); QtGui_PackedString { td46c02, -1 }; });
}
struct QtGui_PackedString QOpenGLFunctions_4_0_Core_GlGetStringi5(void* ptr, unsigned int name, unsigned int index)
{
return ({ char* tfae32f = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetStringi(name, index)))); QtGui_PackedString { tfae32f, -1 }; });
}
void QOpenGLFunctions_4_0_Core_GlActiveTexture5(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glActiveTexture(texture);
}
void QOpenGLFunctions_4_0_Core_GlAttachShader5(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glAttachShader(program, shader);
}
void QOpenGLFunctions_4_0_Core_GlBeginConditionalRender5(void* ptr, unsigned int id, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glBeginConditionalRender(id, mode);
}
void QOpenGLFunctions_4_0_Core_GlBeginQuery5(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glBeginQuery(target, id);
}
void QOpenGLFunctions_4_0_Core_GlBeginQueryIndexed5(void* ptr, unsigned int target, unsigned int index, unsigned int id)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glBeginQueryIndexed(target, index, id);
}
void QOpenGLFunctions_4_0_Core_GlBeginTransformFeedback5(void* ptr, unsigned int primitiveMode)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glBeginTransformFeedback(primitiveMode);
}
void QOpenGLFunctions_4_0_Core_GlBindBuffer5(void* ptr, unsigned int target, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glBindBuffer(target, buffer);
}
void QOpenGLFunctions_4_0_Core_GlBindBufferBase5(void* ptr, unsigned int target, unsigned int index, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glBindBufferBase(target, index, buffer);
}
void QOpenGLFunctions_4_0_Core_GlBindFramebuffer5(void* ptr, unsigned int target, unsigned int framebuffer)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glBindFramebuffer(target, framebuffer);
}
void QOpenGLFunctions_4_0_Core_GlBindRenderbuffer5(void* ptr, unsigned int target, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glBindRenderbuffer(target, renderbuffer);
}
void QOpenGLFunctions_4_0_Core_GlBindSampler5(void* ptr, unsigned int unit, unsigned int sampler)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glBindSampler(unit, sampler);
}
void QOpenGLFunctions_4_0_Core_GlBindTexture5(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_4_0_Core_GlBindTransformFeedback5(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glBindTransformFeedback(target, id);
}
void QOpenGLFunctions_4_0_Core_GlBindVertexArray5(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glBindVertexArray(array);
}
void QOpenGLFunctions_4_0_Core_GlBlendColor5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_4_0_Core_GlBlendEquation5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_4_0_Core_GlBlendEquationSeparate5(void* ptr, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glBlendEquationSeparate(modeRGB, modeAlpha);
}
void QOpenGLFunctions_4_0_Core_GlBlendEquationSeparatei5(void* ptr, unsigned int buf, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glBlendEquationSeparatei(buf, modeRGB, modeAlpha);
}
void QOpenGLFunctions_4_0_Core_GlBlendEquationi5(void* ptr, unsigned int buf, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glBlendEquationi(buf, mode);
}
void QOpenGLFunctions_4_0_Core_GlBlendFunc5(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_4_0_Core_GlBlendFuncSeparate5(void* ptr, unsigned int sfactorRGB, unsigned int dfactorRGB, unsigned int sfactorAlpha, unsigned int dfactorAlpha)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void QOpenGLFunctions_4_0_Core_GlBlendFuncSeparatei5(void* ptr, unsigned int buf, unsigned int srcRGB, unsigned int dstRGB, unsigned int srcAlpha, unsigned int dstAlpha)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
void QOpenGLFunctions_4_0_Core_GlBlendFunci5(void* ptr, unsigned int buf, unsigned int src, unsigned int dst)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glBlendFunci(buf, src, dst);
}
void QOpenGLFunctions_4_0_Core_GlBlitFramebuffer5(void* ptr, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, unsigned int mask, unsigned int filter)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
void QOpenGLFunctions_4_0_Core_GlClampColor5(void* ptr, unsigned int target, unsigned int clamp)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glClampColor(target, clamp);
}
void QOpenGLFunctions_4_0_Core_GlClear5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_4_0_Core_GlClearBufferfi5(void* ptr, unsigned int buffer, int drawbuffer, float depth, int stencil)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glClearBufferfi(buffer, drawbuffer, depth, stencil);
}
void QOpenGLFunctions_4_0_Core_GlClearBufferfv5(void* ptr, unsigned int buffer, int drawbuffer, float value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glClearBufferfv(buffer, drawbuffer, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlClearBufferiv5(void* ptr, unsigned int buffer, int drawbuffer, int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glClearBufferiv(buffer, drawbuffer, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlClearBufferuiv5(void* ptr, unsigned int buffer, int drawbuffer, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glClearBufferuiv(buffer, drawbuffer, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlClearColor5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_4_0_Core_GlClearStencil5(void* ptr, int s)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_4_0_Core_GlColorMask5(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_4_0_Core_GlColorMaski5(void* ptr, unsigned int index, char r, char g, char b, char a)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glColorMaski(index, r != 0, g != 0, b != 0, a != 0);
}
void QOpenGLFunctions_4_0_Core_GlColorP3ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glColorP3ui(ty, color);
}
void QOpenGLFunctions_4_0_Core_GlColorP3uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glColorP3uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_0_Core_GlColorP4ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glColorP4ui(ty, color);
}
void QOpenGLFunctions_4_0_Core_GlColorP4uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glColorP4uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_0_Core_GlCompileShader5(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glCompileShader(shader);
}
void QOpenGLFunctions_4_0_Core_GlCompressedTexImage1D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
void QOpenGLFunctions_4_0_Core_GlCompressedTexImage2D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void QOpenGLFunctions_4_0_Core_GlCompressedTexImage3D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int depth, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void QOpenGLFunctions_4_0_Core_GlCompressedTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_4_0_Core_GlCompressedTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_4_0_Core_GlCompressedTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_4_0_Core_GlCopyTexImage1D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_4_0_Core_GlCopyTexImage2D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_4_0_Core_GlCopyTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_4_0_Core_GlCopyTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_4_0_Core_GlCopyTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_4_0_Core_GlCullFace5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_4_0_Core_GlDeleteBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDeleteBuffers(n, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_4_0_Core_GlDeleteFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDeleteFramebuffers(n, const_cast<const GLuint*>(&framebuffers));
}
void QOpenGLFunctions_4_0_Core_GlDeleteProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDeleteProgram(program);
}
void QOpenGLFunctions_4_0_Core_GlDeleteQueries5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDeleteQueries(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_4_0_Core_GlDeleteRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDeleteRenderbuffers(n, const_cast<const GLuint*>(&renderbuffers));
}
void QOpenGLFunctions_4_0_Core_GlDeleteSamplers5(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDeleteSamplers(count, const_cast<const GLuint*>(&samplers));
}
void QOpenGLFunctions_4_0_Core_GlDeleteShader5(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDeleteShader(shader);
}
void QOpenGLFunctions_4_0_Core_GlDeleteTextures5(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_4_0_Core_GlDeleteTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDeleteTransformFeedbacks(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_4_0_Core_GlDeleteVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDeleteVertexArrays(n, const_cast<const GLuint*>(&arrays));
}
void QOpenGLFunctions_4_0_Core_GlDepthFunc5(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_4_0_Core_GlDepthMask5(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_4_0_Core_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDetachShader(program, shader);
}
void QOpenGLFunctions_4_0_Core_GlDisable5(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_4_0_Core_GlDisableVertexAttribArray5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDisableVertexAttribArray(index);
}
void QOpenGLFunctions_4_0_Core_GlDisablei5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDisablei(target, index);
}
void QOpenGLFunctions_4_0_Core_GlDrawArrays5(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_4_0_Core_GlDrawArraysIndirect5(void* ptr, unsigned int mode, void* indirect)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDrawArraysIndirect(mode, indirect);
}
void QOpenGLFunctions_4_0_Core_GlDrawArraysInstanced5(void* ptr, unsigned int mode, int first, int count, int instancecount)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDrawArraysInstanced(mode, first, count, instancecount);
}
void QOpenGLFunctions_4_0_Core_GlDrawBuffer5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDrawBuffer(mode);
}
void QOpenGLFunctions_4_0_Core_GlDrawBuffers5(void* ptr, int n, unsigned int bufs)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDrawBuffers(n, const_cast<const GLenum*>(&bufs));
}
void QOpenGLFunctions_4_0_Core_GlDrawElements5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_4_0_Core_GlDrawElementsBaseVertex5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDrawElementsBaseVertex(mode, count, ty, indices, basevertex);
}
void QOpenGLFunctions_4_0_Core_GlDrawElementsIndirect5(void* ptr, unsigned int mode, unsigned int ty, void* indirect)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDrawElementsIndirect(mode, ty, indirect);
}
void QOpenGLFunctions_4_0_Core_GlDrawElementsInstanced5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDrawElementsInstanced(mode, count, ty, indices, instancecount);
}
void QOpenGLFunctions_4_0_Core_GlDrawElementsInstancedBaseVertex5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDrawElementsInstancedBaseVertex(mode, count, ty, indices, instancecount, basevertex);
}
void QOpenGLFunctions_4_0_Core_GlDrawRangeElements5(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLFunctions_4_0_Core_GlDrawRangeElementsBaseVertex5(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDrawRangeElementsBaseVertex(mode, start, end, count, ty, indices, basevertex);
}
void QOpenGLFunctions_4_0_Core_GlDrawTransformFeedback5(void* ptr, unsigned int mode, unsigned int id)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDrawTransformFeedback(mode, id);
}
void QOpenGLFunctions_4_0_Core_GlDrawTransformFeedbackStream5(void* ptr, unsigned int mode, unsigned int id, unsigned int stream)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glDrawTransformFeedbackStream(mode, id, stream);
}
void QOpenGLFunctions_4_0_Core_GlEnable5(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_4_0_Core_GlEnableVertexAttribArray5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glEnableVertexAttribArray(index);
}
void QOpenGLFunctions_4_0_Core_GlEnablei5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glEnablei(target, index);
}
void QOpenGLFunctions_4_0_Core_GlEndConditionalRender5(void* ptr)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glEndConditionalRender();
}
void QOpenGLFunctions_4_0_Core_GlEndQuery5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glEndQuery(target);
}
void QOpenGLFunctions_4_0_Core_GlEndQueryIndexed5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glEndQueryIndexed(target, index);
}
void QOpenGLFunctions_4_0_Core_GlEndTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glEndTransformFeedback();
}
void QOpenGLFunctions_4_0_Core_GlFinish5(void* ptr)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glFinish();
}
void QOpenGLFunctions_4_0_Core_GlFlush5(void* ptr)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glFlush();
}
void QOpenGLFunctions_4_0_Core_GlFramebufferRenderbuffer5(void* ptr, unsigned int target, unsigned int attachment, unsigned int renderbuffertarget, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
void QOpenGLFunctions_4_0_Core_GlFramebufferTexture5(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glFramebufferTexture(target, attachment, texture, level);
}
void QOpenGLFunctions_4_0_Core_GlFramebufferTexture1D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glFramebufferTexture1D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_4_0_Core_GlFramebufferTexture2D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_4_0_Core_GlFramebufferTexture3D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level, int zoffset)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}
void QOpenGLFunctions_4_0_Core_GlFramebufferTextureLayer5(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level, int layer)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glFramebufferTextureLayer(target, attachment, texture, level, layer);
}
void QOpenGLFunctions_4_0_Core_GlFrontFace5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_4_0_Core_GlGenBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGenBuffers(n, &buffers);
}
void QOpenGLFunctions_4_0_Core_GlGenFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGenFramebuffers(n, &framebuffers);
}
void QOpenGLFunctions_4_0_Core_GlGenQueries5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGenQueries(n, &ids);
}
void QOpenGLFunctions_4_0_Core_GlGenRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGenRenderbuffers(n, &renderbuffers);
}
void QOpenGLFunctions_4_0_Core_GlGenSamplers5(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGenSamplers(count, &samplers);
}
void QOpenGLFunctions_4_0_Core_GlGenTextures5(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_4_0_Core_GlGenTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGenTransformFeedbacks(n, &ids);
}
void QOpenGLFunctions_4_0_Core_GlGenVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGenVertexArrays(n, &arrays);
}
void QOpenGLFunctions_4_0_Core_GlGenerateMipmap5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGenerateMipmap(target);
}
void QOpenGLFunctions_4_0_Core_GlGetActiveSubroutineUniformiv5(void* ptr, unsigned int program, unsigned int shadertype, unsigned int index, unsigned int pname, int values)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetActiveSubroutineUniformiv(program, shadertype, index, pname, &values);
}
void QOpenGLFunctions_4_0_Core_GlGetActiveUniformBlockiv5(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetActiveUniformsiv5(void* ptr, unsigned int program, int uniformCount, unsigned int uniformIndices, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetActiveUniformsiv(program, uniformCount, const_cast<const GLuint*>(&uniformIndices), pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetAttachedShaders5(void* ptr, unsigned int program, int maxCount, int count, unsigned int obj)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetAttachedShaders(program, maxCount, &count, &obj);
}
void QOpenGLFunctions_4_0_Core_GlGetBooleani_v5(void* ptr, unsigned int target, unsigned int index, char data)
{
Q_UNUSED(data);
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetBooleani_v(target, index, NULL);
}
void QOpenGLFunctions_4_0_Core_GlGetBooleanv5(void* ptr, unsigned int pname, char params)
{
Q_UNUSED(params);
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_4_0_Core_GlGetBufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetBufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetBufferPointerv5(void* ptr, unsigned int target, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetBufferPointerv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetCompressedTexImage5(void* ptr, unsigned int target, int level, void* img)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetCompressedTexImage(target, level, img);
}
void QOpenGLFunctions_4_0_Core_GlGetFloatv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetFloatv(pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetFramebufferAttachmentParameteriv5(void* ptr, unsigned int target, unsigned int attachment, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetFramebufferAttachmentParameteriv(target, attachment, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetIntegeri_v5(void* ptr, unsigned int target, unsigned int index, int data)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetIntegeri_v(target, index, &data);
}
void QOpenGLFunctions_4_0_Core_GlGetIntegerv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetIntegerv(pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetMultisamplefv5(void* ptr, unsigned int pname, unsigned int index, float val)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetMultisamplefv(pname, index, &val);
}
void QOpenGLFunctions_4_0_Core_GlGetPointerv5(void* ptr, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetPointerv(pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetProgramStageiv5(void* ptr, unsigned int program, unsigned int shadertype, unsigned int pname, int values)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetProgramStageiv(program, shadertype, pname, &values);
}
void QOpenGLFunctions_4_0_Core_GlGetProgramiv5(void* ptr, unsigned int program, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetProgramiv(program, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetQueryIndexediv5(void* ptr, unsigned int target, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetQueryIndexediv(target, index, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetQueryObjectiv5(void* ptr, unsigned int id, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetQueryObjectiv(id, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetQueryObjectuiv5(void* ptr, unsigned int id, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetQueryObjectuiv(id, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetQueryiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetQueryiv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetRenderbufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetRenderbufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetSamplerParameterIiv5(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetSamplerParameterIiv(sampler, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetSamplerParameterIuiv5(void* ptr, unsigned int sampler, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetSamplerParameterIuiv(sampler, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetSamplerParameterfv5(void* ptr, unsigned int sampler, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetSamplerParameterfv(sampler, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetSamplerParameteriv5(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetSamplerParameteriv(sampler, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetShaderiv5(void* ptr, unsigned int shader, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetShaderiv(shader, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetTexImage5(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_4_0_Core_GlGetTexLevelParameterfv5(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetTexLevelParameteriv5(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetTexParameterIiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetTexParameterIiv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetTexParameterIuiv5(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetTexParameterIuiv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetTexParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetTexParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetUniformSubroutineuiv5(void* ptr, unsigned int shadertype, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetUniformSubroutineuiv(shadertype, location, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetUniformfv5(void* ptr, unsigned int program, int location, float params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetUniformfv(program, location, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetUniformiv5(void* ptr, unsigned int program, int location, int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetUniformiv(program, location, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetUniformuiv5(void* ptr, unsigned int program, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetUniformuiv(program, location, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetVertexAttribIiv5(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetVertexAttribIiv(index, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetVertexAttribIuiv5(void* ptr, unsigned int index, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetVertexAttribIuiv(index, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetVertexAttribPointerv5(void* ptr, unsigned int index, unsigned int pname, void* pointer)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetVertexAttribPointerv(index, pname, &pointer);
}
void QOpenGLFunctions_4_0_Core_GlGetVertexAttribfv5(void* ptr, unsigned int index, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetVertexAttribfv(index, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlGetVertexAttribiv5(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glGetVertexAttribiv(index, pname, &params);
}
void QOpenGLFunctions_4_0_Core_GlHint5(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_4_0_Core_GlIndexub5(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glIndexub(*static_cast<GLubyte*>(static_cast<void*>(c)));
}
void QOpenGLFunctions_4_0_Core_GlIndexubv5(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glIndexubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(c))));
}
void QOpenGLFunctions_4_0_Core_GlLineWidth5(void* ptr, float width)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_4_0_Core_GlLinkProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glLinkProgram(program);
}
void QOpenGLFunctions_4_0_Core_GlLogicOp5(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_4_0_Core_GlMinSampleShading5(void* ptr, float value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glMinSampleShading(value);
}
void QOpenGLFunctions_4_0_Core_GlMultiDrawArrays5(void* ptr, unsigned int mode, int first, int count, int drawcount)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glMultiDrawArrays(mode, const_cast<const GLint*>(&first), const_cast<const GLsizei*>(&count), drawcount);
}
void QOpenGLFunctions_4_0_Core_GlMultiTexCoordP1ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glMultiTexCoordP1ui(texture, ty, coords);
}
void QOpenGLFunctions_4_0_Core_GlMultiTexCoordP1uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glMultiTexCoordP1uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_0_Core_GlMultiTexCoordP2ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glMultiTexCoordP2ui(texture, ty, coords);
}
void QOpenGLFunctions_4_0_Core_GlMultiTexCoordP2uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glMultiTexCoordP2uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_0_Core_GlMultiTexCoordP3ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glMultiTexCoordP3ui(texture, ty, coords);
}
void QOpenGLFunctions_4_0_Core_GlMultiTexCoordP3uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glMultiTexCoordP3uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_0_Core_GlMultiTexCoordP4ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glMultiTexCoordP4ui(texture, ty, coords);
}
void QOpenGLFunctions_4_0_Core_GlMultiTexCoordP4uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glMultiTexCoordP4uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_0_Core_GlNormalP3ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glNormalP3ui(ty, coords);
}
void QOpenGLFunctions_4_0_Core_GlNormalP3uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glNormalP3uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_0_Core_GlPatchParameterfv5(void* ptr, unsigned int pname, float values)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glPatchParameterfv(pname, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_4_0_Core_GlPatchParameteri5(void* ptr, unsigned int pname, int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glPatchParameteri(pname, value);
}
void QOpenGLFunctions_4_0_Core_GlPauseTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glPauseTransformFeedback();
}
void QOpenGLFunctions_4_0_Core_GlPixelStoref5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_4_0_Core_GlPixelStorei5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_4_0_Core_GlPointParameterf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glPointParameterf(pname, param);
}
void QOpenGLFunctions_4_0_Core_GlPointParameterfv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glPointParameterfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_0_Core_GlPointParameteri5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glPointParameteri(pname, param);
}
void QOpenGLFunctions_4_0_Core_GlPointParameteriv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glPointParameteriv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_0_Core_GlPointSize5(void* ptr, float size)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_4_0_Core_GlPolygonMode5(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_4_0_Core_GlPolygonOffset5(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_4_0_Core_GlPrimitiveRestartIndex5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glPrimitiveRestartIndex(index);
}
void QOpenGLFunctions_4_0_Core_GlProvokingVertex5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glProvokingVertex(mode);
}
void QOpenGLFunctions_4_0_Core_GlQueryCounter5(void* ptr, unsigned int id, unsigned int target)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glQueryCounter(id, target);
}
void QOpenGLFunctions_4_0_Core_GlReadBuffer5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glReadBuffer(mode);
}
void QOpenGLFunctions_4_0_Core_GlReadPixels5(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_0_Core_GlRenderbufferStorage5(void* ptr, unsigned int target, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glRenderbufferStorage(target, internalformat, width, height);
}
void QOpenGLFunctions_4_0_Core_GlRenderbufferStorageMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
}
void QOpenGLFunctions_4_0_Core_GlResumeTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glResumeTransformFeedback();
}
void QOpenGLFunctions_4_0_Core_GlSampleCoverage5(void* ptr, float value, char invert)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glSampleCoverage(value, invert != 0);
}
void QOpenGLFunctions_4_0_Core_GlSampleMaski5(void* ptr, unsigned int index, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glSampleMaski(index, mask);
}
void QOpenGLFunctions_4_0_Core_GlSamplerParameterIiv5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glSamplerParameterIiv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_0_Core_GlSamplerParameterIuiv5(void* ptr, unsigned int sampler, unsigned int pname, unsigned int param)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glSamplerParameterIuiv(sampler, pname, const_cast<const GLuint*>(&param));
}
void QOpenGLFunctions_4_0_Core_GlSamplerParameterf5(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glSamplerParameterf(sampler, pname, param);
}
void QOpenGLFunctions_4_0_Core_GlSamplerParameterfv5(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glSamplerParameterfv(sampler, pname, const_cast<const GLfloat*>(&param));
}
void QOpenGLFunctions_4_0_Core_GlSamplerParameteri5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glSamplerParameteri(sampler, pname, param);
}
void QOpenGLFunctions_4_0_Core_GlSamplerParameteriv5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glSamplerParameteriv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_0_Core_GlScissor5(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_4_0_Core_GlSecondaryColorP3ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glSecondaryColorP3ui(ty, color);
}
void QOpenGLFunctions_4_0_Core_GlSecondaryColorP3uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glSecondaryColorP3uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_0_Core_GlStencilFunc5(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_4_0_Core_GlStencilFuncSeparate5(void* ptr, unsigned int face, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glStencilFuncSeparate(face, fu, ref, mask);
}
void QOpenGLFunctions_4_0_Core_GlStencilMask5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_4_0_Core_GlStencilMaskSeparate5(void* ptr, unsigned int face, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glStencilMaskSeparate(face, mask);
}
void QOpenGLFunctions_4_0_Core_GlStencilOp5(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_4_0_Core_GlStencilOpSeparate5(void* ptr, unsigned int face, unsigned int sfail, unsigned int dpfail, unsigned int dppass)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glStencilOpSeparate(face, sfail, dpfail, dppass);
}
void QOpenGLFunctions_4_0_Core_GlTexBuffer5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glTexBuffer(target, internalformat, buffer);
}
void QOpenGLFunctions_4_0_Core_GlTexCoordP1ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glTexCoordP1ui(ty, coords);
}
void QOpenGLFunctions_4_0_Core_GlTexCoordP1uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glTexCoordP1uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_0_Core_GlTexCoordP2ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glTexCoordP2ui(ty, coords);
}
void QOpenGLFunctions_4_0_Core_GlTexCoordP2uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glTexCoordP2uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_0_Core_GlTexCoordP3ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glTexCoordP3ui(ty, coords);
}
void QOpenGLFunctions_4_0_Core_GlTexCoordP3uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glTexCoordP3uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_0_Core_GlTexCoordP4ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glTexCoordP4ui(ty, coords);
}
void QOpenGLFunctions_4_0_Core_GlTexCoordP4uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glTexCoordP4uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_0_Core_GlTexImage1D5(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_4_0_Core_GlTexImage2D5(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_4_0_Core_GlTexImage2DMultisample5(void* ptr, unsigned int target, int samples, int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_0_Core_GlTexImage3D5(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLFunctions_4_0_Core_GlTexImage3DMultisample5(void* ptr, unsigned int target, int samples, int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_0_Core_GlTexParameterIiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glTexParameterIiv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_0_Core_GlTexParameterIuiv5(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glTexParameterIuiv(target, pname, const_cast<const GLuint*>(&params));
}
void QOpenGLFunctions_4_0_Core_GlTexParameterf5(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_4_0_Core_GlTexParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_0_Core_GlTexParameteri5(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_4_0_Core_GlTexParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_0_Core_GlTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_4_0_Core_GlTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_0_Core_GlTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_4_0_Core_GlUniform1f5(void* ptr, int location, float v0)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniform1f(location, v0);
}
void QOpenGLFunctions_4_0_Core_GlUniform1fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniform1fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlUniform1i5(void* ptr, int location, int v0)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniform1i(location, v0);
}
void QOpenGLFunctions_4_0_Core_GlUniform1iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniform1iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlUniform1ui5(void* ptr, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniform1ui(location, v0);
}
void QOpenGLFunctions_4_0_Core_GlUniform1uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniform1uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlUniform2f5(void* ptr, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniform2f(location, v0, v1);
}
void QOpenGLFunctions_4_0_Core_GlUniform2fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniform2fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlUniform2i5(void* ptr, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniform2i(location, v0, v1);
}
void QOpenGLFunctions_4_0_Core_GlUniform2iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniform2iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlUniform2ui5(void* ptr, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniform2ui(location, v0, v1);
}
void QOpenGLFunctions_4_0_Core_GlUniform2uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniform2uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlUniform3f5(void* ptr, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniform3f(location, v0, v1, v2);
}
void QOpenGLFunctions_4_0_Core_GlUniform3fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniform3fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlUniform3i5(void* ptr, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniform3i(location, v0, v1, v2);
}
void QOpenGLFunctions_4_0_Core_GlUniform3iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniform3iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlUniform3ui5(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniform3ui(location, v0, v1, v2);
}
void QOpenGLFunctions_4_0_Core_GlUniform3uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniform3uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlUniform4f5(void* ptr, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniform4f(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_0_Core_GlUniform4fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniform4fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlUniform4i5(void* ptr, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniform4i(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_0_Core_GlUniform4iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniform4iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlUniform4ui5(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniform4ui(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_0_Core_GlUniform4uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniform4uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlUniformBlockBinding5(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int uniformBlockBinding)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}
void QOpenGLFunctions_4_0_Core_GlUniformMatrix2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniformMatrix2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlUniformMatrix2x3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniformMatrix2x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlUniformMatrix2x4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniformMatrix2x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlUniformMatrix3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniformMatrix3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlUniformMatrix3x2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniformMatrix3x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlUniformMatrix3x4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniformMatrix3x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlUniformMatrix4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniformMatrix4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlUniformMatrix4x2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniformMatrix4x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlUniformMatrix4x3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniformMatrix4x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlUniformSubroutinesuiv5(void* ptr, unsigned int shadertype, int count, unsigned int indices)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUniformSubroutinesuiv(shadertype, count, const_cast<const GLuint*>(&indices));
}
void QOpenGLFunctions_4_0_Core_GlUseProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glUseProgram(program);
}
void QOpenGLFunctions_4_0_Core_GlValidateProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glValidateProgram(program);
}
void QOpenGLFunctions_4_0_Core_GlVertexAttribDivisor5(void* ptr, unsigned int index, unsigned int divisor)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glVertexAttribDivisor(index, divisor);
}
void QOpenGLFunctions_4_0_Core_GlVertexAttribIPointer5(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glVertexAttribIPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_4_0_Core_GlVertexAttribP1ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glVertexAttribP1ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_0_Core_GlVertexAttribP1uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glVertexAttribP1uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlVertexAttribP2ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glVertexAttribP2ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_0_Core_GlVertexAttribP2uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glVertexAttribP2uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlVertexAttribP3ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glVertexAttribP3ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_0_Core_GlVertexAttribP3uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glVertexAttribP3uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlVertexAttribP4ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glVertexAttribP4ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_0_Core_GlVertexAttribP4uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glVertexAttribP4uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlVertexAttribPointer5(void* ptr, unsigned int index, int size, unsigned int ty, char normalized, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glVertexAttribPointer(index, size, ty, normalized != 0, stride, pointer);
}
void QOpenGLFunctions_4_0_Core_GlVertexP2ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glVertexP2ui(ty, value);
}
void QOpenGLFunctions_4_0_Core_GlVertexP2uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glVertexP2uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlVertexP3ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glVertexP3ui(ty, value);
}
void QOpenGLFunctions_4_0_Core_GlVertexP3uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glVertexP3uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlVertexP4ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glVertexP4ui(ty, value);
}
void QOpenGLFunctions_4_0_Core_GlVertexP4uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glVertexP4uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_0_Core_GlViewport5(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_4_0_Core_DestroyQOpenGLFunctions_4_0_Core5(void* ptr)
{
static_cast<QOpenGLFunctions_4_0_Core*>(ptr)->~QOpenGLFunctions_4_0_Core();
}
void QOpenGLFunctions_4_0_Core_DestroyQOpenGLFunctions_4_0_Core5Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_4_1_Compatibility: public QOpenGLFunctions_4_1_Compatibility
{
public:
MyQOpenGLFunctions_4_1_Compatibility() : QOpenGLFunctions_4_1_Compatibility() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_4_1_Compatibility_InitializeOpenGLFunctions5(this) != 0; };
~MyQOpenGLFunctions_4_1_Compatibility() { callbackQOpenGLFunctions_4_1_Compatibility_DestroyQOpenGLFunctions_4_1_Compatibility5(this); };
};
char QOpenGLFunctions_4_1_Compatibility_GlAreTexturesResident5(void* ptr, int n, unsigned int textures, char residences)
{
Q_UNUSED(residences);
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glAreTexturesResident(n, const_cast<const GLuint*>(&textures), NULL);
}
char QOpenGLFunctions_4_1_Compatibility_GlIsBuffer5(void* ptr, unsigned int buffer)
{
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glIsBuffer(buffer);
}
char QOpenGLFunctions_4_1_Compatibility_GlIsEnabled5(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_4_1_Compatibility_GlIsEnabledi5(void* ptr, unsigned int target, unsigned int index)
{
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glIsEnabledi(target, index);
}
char QOpenGLFunctions_4_1_Compatibility_GlIsFramebuffer5(void* ptr, unsigned int framebuffer)
{
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glIsFramebuffer(framebuffer);
}
char QOpenGLFunctions_4_1_Compatibility_GlIsList5(void* ptr, unsigned int list)
{
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glIsList(list);
}
char QOpenGLFunctions_4_1_Compatibility_GlIsProgram5(void* ptr, unsigned int program)
{
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glIsProgram(program);
}
char QOpenGLFunctions_4_1_Compatibility_GlIsProgramPipeline5(void* ptr, unsigned int pipeline)
{
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glIsProgramPipeline(pipeline);
}
char QOpenGLFunctions_4_1_Compatibility_GlIsQuery5(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glIsQuery(id);
}
char QOpenGLFunctions_4_1_Compatibility_GlIsRenderbuffer5(void* ptr, unsigned int renderbuffer)
{
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glIsRenderbuffer(renderbuffer);
}
char QOpenGLFunctions_4_1_Compatibility_GlIsSampler5(void* ptr, unsigned int sampler)
{
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glIsSampler(sampler);
}
char QOpenGLFunctions_4_1_Compatibility_GlIsShader5(void* ptr, unsigned int shader)
{
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glIsShader(shader);
}
char QOpenGLFunctions_4_1_Compatibility_GlIsTexture5(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glIsTexture(texture);
}
char QOpenGLFunctions_4_1_Compatibility_GlIsTransformFeedback5(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glIsTransformFeedback(id);
}
char QOpenGLFunctions_4_1_Compatibility_GlIsVertexArray5(void* ptr, unsigned int array)
{
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glIsVertexArray(array);
}
char QOpenGLFunctions_4_1_Compatibility_GlUnmapBuffer5(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUnmapBuffer(target);
}
unsigned int QOpenGLFunctions_4_1_Compatibility_GlCheckFramebufferStatus5(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glCheckFramebufferStatus(target);
}
unsigned int QOpenGLFunctions_4_1_Compatibility_GlGetError5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetError();
}
int QOpenGLFunctions_4_1_Compatibility_GlRenderMode5(void* ptr, unsigned int mode)
{
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRenderMode(mode);
}
unsigned int QOpenGLFunctions_4_1_Compatibility_GlCreateProgram5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glCreateProgram();
}
unsigned int QOpenGLFunctions_4_1_Compatibility_GlCreateShader5(void* ptr, unsigned int ty)
{
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glCreateShader(ty);
}
unsigned int QOpenGLFunctions_4_1_Compatibility_GlGenLists5(void* ptr, int ran)
{
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGenLists(ran);
}
void* QOpenGLFunctions_4_1_Compatibility_GlMapBuffer5(void* ptr, unsigned int target, unsigned int access)
{
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMapBuffer(target, access);
}
void* QOpenGLFunctions_4_1_Compatibility_NewQOpenGLFunctions_4_1_Compatibility5()
{
return new MyQOpenGLFunctions_4_1_Compatibility();
}
char QOpenGLFunctions_4_1_Compatibility_InitializeOpenGLFunctions5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_4_1_Compatibility_InitializeOpenGLFunctions5Default(void* ptr)
{
return static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->QOpenGLFunctions_4_1_Compatibility::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_4_1_Compatibility_GlGetString5(void* ptr, unsigned int name)
{
return ({ char* ta4d623 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetString(name)))); QtGui_PackedString { ta4d623, -1 }; });
}
struct QtGui_PackedString QOpenGLFunctions_4_1_Compatibility_GlGetStringi5(void* ptr, unsigned int name, unsigned int index)
{
return ({ char* te135c4 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetStringi(name, index)))); QtGui_PackedString { te135c4, -1 }; });
}
void QOpenGLFunctions_4_1_Compatibility_GlAccum5(void* ptr, unsigned int op, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glAccum(op, value);
}
void QOpenGLFunctions_4_1_Compatibility_GlActiveShaderProgram5(void* ptr, unsigned int pipeline, unsigned int program)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glActiveShaderProgram(pipeline, program);
}
void QOpenGLFunctions_4_1_Compatibility_GlActiveTexture5(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glActiveTexture(texture);
}
void QOpenGLFunctions_4_1_Compatibility_GlAlphaFunc5(void* ptr, unsigned int fu, float ref)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glAlphaFunc(fu, ref);
}
void QOpenGLFunctions_4_1_Compatibility_GlArrayElement5(void* ptr, int i)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glArrayElement(i);
}
void QOpenGLFunctions_4_1_Compatibility_GlAttachShader5(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glAttachShader(program, shader);
}
void QOpenGLFunctions_4_1_Compatibility_GlBegin5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBegin(mode);
}
void QOpenGLFunctions_4_1_Compatibility_GlBeginConditionalRender5(void* ptr, unsigned int id, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBeginConditionalRender(id, mode);
}
void QOpenGLFunctions_4_1_Compatibility_GlBeginQuery5(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBeginQuery(target, id);
}
void QOpenGLFunctions_4_1_Compatibility_GlBeginQueryIndexed5(void* ptr, unsigned int target, unsigned int index, unsigned int id)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBeginQueryIndexed(target, index, id);
}
void QOpenGLFunctions_4_1_Compatibility_GlBeginTransformFeedback5(void* ptr, unsigned int primitiveMode)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBeginTransformFeedback(primitiveMode);
}
void QOpenGLFunctions_4_1_Compatibility_GlBindBuffer5(void* ptr, unsigned int target, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBindBuffer(target, buffer);
}
void QOpenGLFunctions_4_1_Compatibility_GlBindBufferBase5(void* ptr, unsigned int target, unsigned int index, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBindBufferBase(target, index, buffer);
}
void QOpenGLFunctions_4_1_Compatibility_GlBindFramebuffer5(void* ptr, unsigned int target, unsigned int framebuffer)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBindFramebuffer(target, framebuffer);
}
void QOpenGLFunctions_4_1_Compatibility_GlBindProgramPipeline5(void* ptr, unsigned int pipeline)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBindProgramPipeline(pipeline);
}
void QOpenGLFunctions_4_1_Compatibility_GlBindRenderbuffer5(void* ptr, unsigned int target, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBindRenderbuffer(target, renderbuffer);
}
void QOpenGLFunctions_4_1_Compatibility_GlBindSampler5(void* ptr, unsigned int unit, unsigned int sampler)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBindSampler(unit, sampler);
}
void QOpenGLFunctions_4_1_Compatibility_GlBindTexture5(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_4_1_Compatibility_GlBindTransformFeedback5(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBindTransformFeedback(target, id);
}
void QOpenGLFunctions_4_1_Compatibility_GlBindVertexArray5(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBindVertexArray(array);
}
void QOpenGLFunctions_4_1_Compatibility_GlBitmap5(void* ptr, int width, int height, float xorig, float yorig, float xmove, float ymove, char* bitmap)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBitmap(width, height, xorig, yorig, xmove, ymove, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(bitmap))));
}
void QOpenGLFunctions_4_1_Compatibility_GlBlendColor5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_4_1_Compatibility_GlBlendEquation5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_4_1_Compatibility_GlBlendEquationSeparate5(void* ptr, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBlendEquationSeparate(modeRGB, modeAlpha);
}
void QOpenGLFunctions_4_1_Compatibility_GlBlendEquationSeparatei5(void* ptr, unsigned int buf, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBlendEquationSeparatei(buf, modeRGB, modeAlpha);
}
void QOpenGLFunctions_4_1_Compatibility_GlBlendEquationi5(void* ptr, unsigned int buf, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBlendEquationi(buf, mode);
}
void QOpenGLFunctions_4_1_Compatibility_GlBlendFunc5(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_4_1_Compatibility_GlBlendFuncSeparate5(void* ptr, unsigned int sfactorRGB, unsigned int dfactorRGB, unsigned int sfactorAlpha, unsigned int dfactorAlpha)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void QOpenGLFunctions_4_1_Compatibility_GlBlendFuncSeparatei5(void* ptr, unsigned int buf, unsigned int srcRGB, unsigned int dstRGB, unsigned int srcAlpha, unsigned int dstAlpha)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
void QOpenGLFunctions_4_1_Compatibility_GlBlendFunci5(void* ptr, unsigned int buf, unsigned int src, unsigned int dst)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBlendFunci(buf, src, dst);
}
void QOpenGLFunctions_4_1_Compatibility_GlBlitFramebuffer5(void* ptr, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, unsigned int mask, unsigned int filter)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
void QOpenGLFunctions_4_1_Compatibility_GlCallList5(void* ptr, unsigned int list)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glCallList(list);
}
void QOpenGLFunctions_4_1_Compatibility_GlCallLists5(void* ptr, int n, unsigned int ty, void* lists)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glCallLists(n, ty, lists);
}
void QOpenGLFunctions_4_1_Compatibility_GlClampColor5(void* ptr, unsigned int target, unsigned int clamp)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glClampColor(target, clamp);
}
void QOpenGLFunctions_4_1_Compatibility_GlClear5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_4_1_Compatibility_GlClearAccum5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glClearAccum(red, green, blue, alpha);
}
void QOpenGLFunctions_4_1_Compatibility_GlClearBufferfi5(void* ptr, unsigned int buffer, int drawbuffer, float depth, int stencil)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glClearBufferfi(buffer, drawbuffer, depth, stencil);
}
void QOpenGLFunctions_4_1_Compatibility_GlClearBufferfv5(void* ptr, unsigned int buffer, int drawbuffer, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glClearBufferfv(buffer, drawbuffer, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlClearBufferiv5(void* ptr, unsigned int buffer, int drawbuffer, int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glClearBufferiv(buffer, drawbuffer, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlClearBufferuiv5(void* ptr, unsigned int buffer, int drawbuffer, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glClearBufferuiv(buffer, drawbuffer, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlClearColor5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_4_1_Compatibility_GlClearDepthf5(void* ptr, float dd)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glClearDepthf(dd);
}
void QOpenGLFunctions_4_1_Compatibility_GlClearIndex5(void* ptr, float c)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glClearIndex(c);
}
void QOpenGLFunctions_4_1_Compatibility_GlClearStencil5(void* ptr, int s)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_4_1_Compatibility_GlClientActiveTexture5(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glClientActiveTexture(texture);
}
void QOpenGLFunctions_4_1_Compatibility_GlColor3f5(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColor3f(red, green, blue);
}
void QOpenGLFunctions_4_1_Compatibility_GlColor3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlColor3i5(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColor3i(red, green, blue);
}
void QOpenGLFunctions_4_1_Compatibility_GlColor3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlColor3s5(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColor3s(red, green, blue);
}
void QOpenGLFunctions_4_1_Compatibility_GlColor3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlColor3ub5(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_4_1_Compatibility_GlColor3ubv5(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_1_Compatibility_GlColor3ui5(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColor3ui(red, green, blue);
}
void QOpenGLFunctions_4_1_Compatibility_GlColor3uiv5(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlColor3us5(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColor3us(red, green, blue);
}
void QOpenGLFunctions_4_1_Compatibility_GlColor3usv5(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlColor4f5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColor4f(red, green, blue, alpha);
}
void QOpenGLFunctions_4_1_Compatibility_GlColor4fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColor4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlColor4i5(void* ptr, int red, int green, int blue, int alpha)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColor4i(red, green, blue, alpha);
}
void QOpenGLFunctions_4_1_Compatibility_GlColor4iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColor4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlColor4s5(void* ptr, short red, short green, short blue, short alpha)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColor4s(red, green, blue, alpha);
}
void QOpenGLFunctions_4_1_Compatibility_GlColor4sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColor4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlColor4ub5(void* ptr, char* red, char* green, char* blue, char* alpha)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColor4ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)), *static_cast<GLubyte*>(static_cast<void*>(alpha)));
}
void QOpenGLFunctions_4_1_Compatibility_GlColor4ubv5(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColor4ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_1_Compatibility_GlColor4ui5(void* ptr, unsigned int red, unsigned int green, unsigned int blue, unsigned int alpha)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColor4ui(red, green, blue, alpha);
}
void QOpenGLFunctions_4_1_Compatibility_GlColor4uiv5(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColor4uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlColor4us5(void* ptr, unsigned short red, unsigned short green, unsigned short blue, unsigned short alpha)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColor4us(red, green, blue, alpha);
}
void QOpenGLFunctions_4_1_Compatibility_GlColor4usv5(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColor4usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlColorMask5(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_4_1_Compatibility_GlColorMaski5(void* ptr, unsigned int index, char r, char g, char b, char a)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColorMaski(index, r != 0, g != 0, b != 0, a != 0);
}
void QOpenGLFunctions_4_1_Compatibility_GlColorMaterial5(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColorMaterial(face, mode);
}
void QOpenGLFunctions_4_1_Compatibility_GlColorP3ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColorP3ui(ty, color);
}
void QOpenGLFunctions_4_1_Compatibility_GlColorP3uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColorP3uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_1_Compatibility_GlColorP4ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColorP4ui(ty, color);
}
void QOpenGLFunctions_4_1_Compatibility_GlColorP4uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColorP4uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_1_Compatibility_GlColorPointer5(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_4_1_Compatibility_GlColorSubTable5(void* ptr, unsigned int target, int start, int count, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColorSubTable(target, start, count, format, ty, data);
}
void QOpenGLFunctions_4_1_Compatibility_GlColorTable5(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColorTable(target, internalformat, width, format, ty, table);
}
void QOpenGLFunctions_4_1_Compatibility_GlColorTableParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColorTableParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_1_Compatibility_GlColorTableParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glColorTableParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_1_Compatibility_GlCompileShader5(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glCompileShader(shader);
}
void QOpenGLFunctions_4_1_Compatibility_GlCompressedTexImage1D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
void QOpenGLFunctions_4_1_Compatibility_GlCompressedTexImage2D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void QOpenGLFunctions_4_1_Compatibility_GlCompressedTexImage3D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int depth, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void QOpenGLFunctions_4_1_Compatibility_GlCompressedTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_4_1_Compatibility_GlCompressedTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_4_1_Compatibility_GlCompressedTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_4_1_Compatibility_GlConvolutionFilter1D5(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glConvolutionFilter1D(target, internalformat, width, format, ty, image);
}
void QOpenGLFunctions_4_1_Compatibility_GlConvolutionFilter2D5(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glConvolutionFilter2D(target, internalformat, width, height, format, ty, image);
}
void QOpenGLFunctions_4_1_Compatibility_GlConvolutionParameterf5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glConvolutionParameterf(target, pname, params);
}
void QOpenGLFunctions_4_1_Compatibility_GlConvolutionParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glConvolutionParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_1_Compatibility_GlConvolutionParameteri5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glConvolutionParameteri(target, pname, params);
}
void QOpenGLFunctions_4_1_Compatibility_GlConvolutionParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glConvolutionParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_1_Compatibility_GlCopyColorSubTable5(void* ptr, unsigned int target, int start, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glCopyColorSubTable(target, start, x, y, width);
}
void QOpenGLFunctions_4_1_Compatibility_GlCopyColorTable5(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glCopyColorTable(target, internalformat, x, y, width);
}
void QOpenGLFunctions_4_1_Compatibility_GlCopyConvolutionFilter1D5(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glCopyConvolutionFilter1D(target, internalformat, x, y, width);
}
void QOpenGLFunctions_4_1_Compatibility_GlCopyConvolutionFilter2D5(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);
}
void QOpenGLFunctions_4_1_Compatibility_GlCopyPixels5(void* ptr, int x, int y, int width, int height, unsigned int ty)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glCopyPixels(x, y, width, height, ty);
}
void QOpenGLFunctions_4_1_Compatibility_GlCopyTexImage1D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_4_1_Compatibility_GlCopyTexImage2D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_4_1_Compatibility_GlCopyTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_4_1_Compatibility_GlCopyTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_4_1_Compatibility_GlCopyTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_4_1_Compatibility_GlCullFace5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_4_1_Compatibility_GlDeleteBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDeleteBuffers(n, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_4_1_Compatibility_GlDeleteFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDeleteFramebuffers(n, const_cast<const GLuint*>(&framebuffers));
}
void QOpenGLFunctions_4_1_Compatibility_GlDeleteLists5(void* ptr, unsigned int list, int ran)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDeleteLists(list, ran);
}
void QOpenGLFunctions_4_1_Compatibility_GlDeleteProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDeleteProgram(program);
}
void QOpenGLFunctions_4_1_Compatibility_GlDeleteProgramPipelines5(void* ptr, int n, unsigned int pipelines)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDeleteProgramPipelines(n, const_cast<const GLuint*>(&pipelines));
}
void QOpenGLFunctions_4_1_Compatibility_GlDeleteQueries5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDeleteQueries(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_4_1_Compatibility_GlDeleteRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDeleteRenderbuffers(n, const_cast<const GLuint*>(&renderbuffers));
}
void QOpenGLFunctions_4_1_Compatibility_GlDeleteSamplers5(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDeleteSamplers(count, const_cast<const GLuint*>(&samplers));
}
void QOpenGLFunctions_4_1_Compatibility_GlDeleteShader5(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDeleteShader(shader);
}
void QOpenGLFunctions_4_1_Compatibility_GlDeleteTextures5(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_4_1_Compatibility_GlDeleteTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDeleteTransformFeedbacks(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_4_1_Compatibility_GlDeleteVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDeleteVertexArrays(n, const_cast<const GLuint*>(&arrays));
}
void QOpenGLFunctions_4_1_Compatibility_GlDepthFunc5(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_4_1_Compatibility_GlDepthMask5(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_4_1_Compatibility_GlDepthRangef5(void* ptr, float n, float fo)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDepthRangef(n, fo);
}
void QOpenGLFunctions_4_1_Compatibility_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDetachShader(program, shader);
}
void QOpenGLFunctions_4_1_Compatibility_GlDisable5(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_4_1_Compatibility_GlDisableClientState5(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDisableClientState(array);
}
void QOpenGLFunctions_4_1_Compatibility_GlDisableVertexAttribArray5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDisableVertexAttribArray(index);
}
void QOpenGLFunctions_4_1_Compatibility_GlDisablei5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDisablei(target, index);
}
void QOpenGLFunctions_4_1_Compatibility_GlDrawArrays5(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_4_1_Compatibility_GlDrawArraysIndirect5(void* ptr, unsigned int mode, void* indirect)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDrawArraysIndirect(mode, indirect);
}
void QOpenGLFunctions_4_1_Compatibility_GlDrawArraysInstanced5(void* ptr, unsigned int mode, int first, int count, int instancecount)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDrawArraysInstanced(mode, first, count, instancecount);
}
void QOpenGLFunctions_4_1_Compatibility_GlDrawBuffer5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDrawBuffer(mode);
}
void QOpenGLFunctions_4_1_Compatibility_GlDrawBuffers5(void* ptr, int n, unsigned int bufs)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDrawBuffers(n, const_cast<const GLenum*>(&bufs));
}
void QOpenGLFunctions_4_1_Compatibility_GlDrawElements5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_4_1_Compatibility_GlDrawElementsBaseVertex5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDrawElementsBaseVertex(mode, count, ty, indices, basevertex);
}
void QOpenGLFunctions_4_1_Compatibility_GlDrawElementsIndirect5(void* ptr, unsigned int mode, unsigned int ty, void* indirect)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDrawElementsIndirect(mode, ty, indirect);
}
void QOpenGLFunctions_4_1_Compatibility_GlDrawElementsInstanced5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDrawElementsInstanced(mode, count, ty, indices, instancecount);
}
void QOpenGLFunctions_4_1_Compatibility_GlDrawElementsInstancedBaseVertex5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDrawElementsInstancedBaseVertex(mode, count, ty, indices, instancecount, basevertex);
}
void QOpenGLFunctions_4_1_Compatibility_GlDrawPixels5(void* ptr, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDrawPixels(width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_1_Compatibility_GlDrawRangeElements5(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLFunctions_4_1_Compatibility_GlDrawRangeElementsBaseVertex5(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDrawRangeElementsBaseVertex(mode, start, end, count, ty, indices, basevertex);
}
void QOpenGLFunctions_4_1_Compatibility_GlDrawTransformFeedback5(void* ptr, unsigned int mode, unsigned int id)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDrawTransformFeedback(mode, id);
}
void QOpenGLFunctions_4_1_Compatibility_GlDrawTransformFeedbackStream5(void* ptr, unsigned int mode, unsigned int id, unsigned int stream)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDrawTransformFeedbackStream(mode, id, stream);
}
void QOpenGLFunctions_4_1_Compatibility_GlEdgeFlag5(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glEdgeFlag(flag != 0);
}
void QOpenGLFunctions_4_1_Compatibility_GlEdgeFlagPointer5(void* ptr, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glEdgeFlagPointer(stride, pointer);
}
void QOpenGLFunctions_4_1_Compatibility_GlEdgeFlagv5(void* ptr, char flag)
{
Q_UNUSED(flag);
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glEdgeFlagv(NULL);
}
void QOpenGLFunctions_4_1_Compatibility_GlEnable5(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_4_1_Compatibility_GlEnableClientState5(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glEnableClientState(array);
}
void QOpenGLFunctions_4_1_Compatibility_GlEnableVertexAttribArray5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glEnableVertexAttribArray(index);
}
void QOpenGLFunctions_4_1_Compatibility_GlEnablei5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glEnablei(target, index);
}
void QOpenGLFunctions_4_1_Compatibility_GlEnd5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glEnd();
}
void QOpenGLFunctions_4_1_Compatibility_GlEndConditionalRender5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glEndConditionalRender();
}
void QOpenGLFunctions_4_1_Compatibility_GlEndList5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glEndList();
}
void QOpenGLFunctions_4_1_Compatibility_GlEndQuery5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glEndQuery(target);
}
void QOpenGLFunctions_4_1_Compatibility_GlEndQueryIndexed5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glEndQueryIndexed(target, index);
}
void QOpenGLFunctions_4_1_Compatibility_GlEndTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glEndTransformFeedback();
}
void QOpenGLFunctions_4_1_Compatibility_GlEvalCoord1f5(void* ptr, float u)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glEvalCoord1f(u);
}
void QOpenGLFunctions_4_1_Compatibility_GlEvalCoord1fv5(void* ptr, float u)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glEvalCoord1fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_4_1_Compatibility_GlEvalCoord2f5(void* ptr, float u, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glEvalCoord2f(u, v);
}
void QOpenGLFunctions_4_1_Compatibility_GlEvalCoord2fv5(void* ptr, float u)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glEvalCoord2fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_4_1_Compatibility_GlEvalMesh15(void* ptr, unsigned int mode, int i1, int i2)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glEvalMesh1(mode, i1, i2);
}
void QOpenGLFunctions_4_1_Compatibility_GlEvalMesh25(void* ptr, unsigned int mode, int i1, int i2, int j1, int j2)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glEvalMesh2(mode, i1, i2, j1, j2);
}
void QOpenGLFunctions_4_1_Compatibility_GlEvalPoint15(void* ptr, int i)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glEvalPoint1(i);
}
void QOpenGLFunctions_4_1_Compatibility_GlEvalPoint25(void* ptr, int i, int j)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glEvalPoint2(i, j);
}
void QOpenGLFunctions_4_1_Compatibility_GlFeedbackBuffer5(void* ptr, int size, unsigned int ty, float buffer)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glFeedbackBuffer(size, ty, &buffer);
}
void QOpenGLFunctions_4_1_Compatibility_GlFinish5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glFinish();
}
void QOpenGLFunctions_4_1_Compatibility_GlFlush5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glFlush();
}
void QOpenGLFunctions_4_1_Compatibility_GlFogCoordPointer5(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glFogCoordPointer(ty, stride, pointer);
}
void QOpenGLFunctions_4_1_Compatibility_GlFogCoordf5(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glFogCoordf(coord);
}
void QOpenGLFunctions_4_1_Compatibility_GlFogCoordfv5(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glFogCoordfv(const_cast<const GLfloat*>(&coord));
}
void QOpenGLFunctions_4_1_Compatibility_GlFogf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glFogf(pname, param);
}
void QOpenGLFunctions_4_1_Compatibility_GlFogfv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glFogfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_1_Compatibility_GlFogi5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glFogi(pname, param);
}
void QOpenGLFunctions_4_1_Compatibility_GlFogiv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glFogiv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_1_Compatibility_GlFramebufferRenderbuffer5(void* ptr, unsigned int target, unsigned int attachment, unsigned int renderbuffertarget, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
void QOpenGLFunctions_4_1_Compatibility_GlFramebufferTexture5(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glFramebufferTexture(target, attachment, texture, level);
}
void QOpenGLFunctions_4_1_Compatibility_GlFramebufferTexture1D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glFramebufferTexture1D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_4_1_Compatibility_GlFramebufferTexture2D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_4_1_Compatibility_GlFramebufferTexture3D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level, int zoffset)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}
void QOpenGLFunctions_4_1_Compatibility_GlFramebufferTextureLayer5(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level, int layer)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glFramebufferTextureLayer(target, attachment, texture, level, layer);
}
void QOpenGLFunctions_4_1_Compatibility_GlFrontFace5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_4_1_Compatibility_GlGenBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGenBuffers(n, &buffers);
}
void QOpenGLFunctions_4_1_Compatibility_GlGenFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGenFramebuffers(n, &framebuffers);
}
void QOpenGLFunctions_4_1_Compatibility_GlGenProgramPipelines5(void* ptr, int n, unsigned int pipelines)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGenProgramPipelines(n, &pipelines);
}
void QOpenGLFunctions_4_1_Compatibility_GlGenQueries5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGenQueries(n, &ids);
}
void QOpenGLFunctions_4_1_Compatibility_GlGenRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGenRenderbuffers(n, &renderbuffers);
}
void QOpenGLFunctions_4_1_Compatibility_GlGenSamplers5(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGenSamplers(count, &samplers);
}
void QOpenGLFunctions_4_1_Compatibility_GlGenTextures5(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_4_1_Compatibility_GlGenTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGenTransformFeedbacks(n, &ids);
}
void QOpenGLFunctions_4_1_Compatibility_GlGenVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGenVertexArrays(n, &arrays);
}
void QOpenGLFunctions_4_1_Compatibility_GlGenerateMipmap5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGenerateMipmap(target);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetActiveSubroutineUniformiv5(void* ptr, unsigned int program, unsigned int shadertype, unsigned int index, unsigned int pname, int values)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetActiveSubroutineUniformiv(program, shadertype, index, pname, &values);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetActiveUniformBlockiv5(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetActiveUniformsiv5(void* ptr, unsigned int program, int uniformCount, unsigned int uniformIndices, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetActiveUniformsiv(program, uniformCount, const_cast<const GLuint*>(&uniformIndices), pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetAttachedShaders5(void* ptr, unsigned int program, int maxCount, int count, unsigned int obj)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetAttachedShaders(program, maxCount, &count, &obj);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetBooleani_v5(void* ptr, unsigned int target, unsigned int index, char data)
{
Q_UNUSED(data);
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetBooleani_v(target, index, NULL);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetBooleanv5(void* ptr, unsigned int pname, char params)
{
Q_UNUSED(params);
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetBufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetBufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetBufferPointerv5(void* ptr, unsigned int target, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetBufferPointerv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetColorTable5(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetColorTable(target, format, ty, table);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetColorTableParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetColorTableParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetColorTableParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetColorTableParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetCompressedTexImage5(void* ptr, unsigned int target, int level, void* img)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetCompressedTexImage(target, level, img);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetConvolutionFilter5(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetConvolutionFilter(target, format, ty, image);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetConvolutionParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetConvolutionParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetConvolutionParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetConvolutionParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetFloati_v5(void* ptr, unsigned int target, unsigned int index, float data)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetFloati_v(target, index, &data);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetFloatv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetFloatv(pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetFramebufferAttachmentParameteriv5(void* ptr, unsigned int target, unsigned int attachment, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetFramebufferAttachmentParameteriv(target, attachment, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetHistogram5(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetHistogram(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetHistogramParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetHistogramParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetHistogramParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetHistogramParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetIntegeri_v5(void* ptr, unsigned int target, unsigned int index, int data)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetIntegeri_v(target, index, &data);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetIntegerv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetIntegerv(pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetLightfv5(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetLightfv(light, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetLightiv5(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetLightiv(light, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetMapfv5(void* ptr, unsigned int target, unsigned int query, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetMapfv(target, query, &v);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetMapiv5(void* ptr, unsigned int target, unsigned int query, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetMapiv(target, query, &v);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetMaterialfv5(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetMaterialfv(face, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetMaterialiv5(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetMaterialiv(face, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetMinmax5(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetMinmax(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetMinmaxParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetMinmaxParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetMinmaxParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetMinmaxParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetMultisamplefv5(void* ptr, unsigned int pname, unsigned int index, float val)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetMultisamplefv(pname, index, &val);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetPixelMapfv5(void* ptr, unsigned int m, float values)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetPixelMapfv(m, &values);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetPixelMapuiv5(void* ptr, unsigned int m, unsigned int values)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetPixelMapuiv(m, &values);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetPixelMapusv5(void* ptr, unsigned int m, unsigned short values)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetPixelMapusv(m, &values);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetPointerv5(void* ptr, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetPointerv(pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetPolygonStipple5(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetPolygonStipple(static_cast<GLubyte*>(static_cast<void*>(mask)));
}
void QOpenGLFunctions_4_1_Compatibility_GlGetProgramBinary5(void* ptr, unsigned int program, int bufSize, int length, unsigned int binaryFormat, void* binary)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetProgramBinary(program, bufSize, &length, &binaryFormat, binary);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetProgramPipelineiv5(void* ptr, unsigned int pipeline, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetProgramPipelineiv(pipeline, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetProgramStageiv5(void* ptr, unsigned int program, unsigned int shadertype, unsigned int pname, int values)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetProgramStageiv(program, shadertype, pname, &values);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetProgramiv5(void* ptr, unsigned int program, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetProgramiv(program, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetQueryIndexediv5(void* ptr, unsigned int target, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetQueryIndexediv(target, index, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetQueryObjectiv5(void* ptr, unsigned int id, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetQueryObjectiv(id, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetQueryObjectuiv5(void* ptr, unsigned int id, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetQueryObjectuiv(id, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetQueryiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetQueryiv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetRenderbufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetRenderbufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetSamplerParameterIiv5(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetSamplerParameterIiv(sampler, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetSamplerParameterIuiv5(void* ptr, unsigned int sampler, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetSamplerParameterIuiv(sampler, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetSamplerParameterfv5(void* ptr, unsigned int sampler, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetSamplerParameterfv(sampler, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetSamplerParameteriv5(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetSamplerParameteriv(sampler, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetSeparableFilter5(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* row, void* column, void* span)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetSeparableFilter(target, format, ty, row, column, span);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetShaderPrecisionFormat5(void* ptr, unsigned int shadertype, unsigned int precisiontype, int ran, int precision)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetShaderPrecisionFormat(shadertype, precisiontype, &ran, &precision);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetShaderiv5(void* ptr, unsigned int shader, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetShaderiv(shader, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetTexEnvfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetTexEnvfv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetTexEnviv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetTexEnviv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetTexGenfv5(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetTexGenfv(coord, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetTexGeniv5(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetTexGeniv(coord, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetTexImage5(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetTexLevelParameterfv5(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetTexLevelParameteriv5(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetTexParameterIiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetTexParameterIiv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetTexParameterIuiv5(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetTexParameterIuiv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetTexParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetTexParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetUniformSubroutineuiv5(void* ptr, unsigned int shadertype, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetUniformSubroutineuiv(shadertype, location, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetUniformfv5(void* ptr, unsigned int program, int location, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetUniformfv(program, location, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetUniformiv5(void* ptr, unsigned int program, int location, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetUniformiv(program, location, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetUniformuiv5(void* ptr, unsigned int program, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetUniformuiv(program, location, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetVertexAttribIiv5(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetVertexAttribIiv(index, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetVertexAttribIuiv5(void* ptr, unsigned int index, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetVertexAttribIuiv(index, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetVertexAttribPointerv5(void* ptr, unsigned int index, unsigned int pname, void* pointer)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetVertexAttribPointerv(index, pname, &pointer);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetVertexAttribfv5(void* ptr, unsigned int index, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetVertexAttribfv(index, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlGetVertexAttribiv5(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glGetVertexAttribiv(index, pname, &params);
}
void QOpenGLFunctions_4_1_Compatibility_GlHint5(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_4_1_Compatibility_GlHistogram5(void* ptr, unsigned int target, int width, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glHistogram(target, width, internalformat, sink != 0);
}
void QOpenGLFunctions_4_1_Compatibility_GlIndexMask5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glIndexMask(mask);
}
void QOpenGLFunctions_4_1_Compatibility_GlIndexPointer5(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glIndexPointer(ty, stride, pointer);
}
void QOpenGLFunctions_4_1_Compatibility_GlIndexf5(void* ptr, float c)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glIndexf(c);
}
void QOpenGLFunctions_4_1_Compatibility_GlIndexfv5(void* ptr, float c)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glIndexfv(const_cast<const GLfloat*>(&c));
}
void QOpenGLFunctions_4_1_Compatibility_GlIndexi5(void* ptr, int c)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glIndexi(c);
}
void QOpenGLFunctions_4_1_Compatibility_GlIndexiv5(void* ptr, int c)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glIndexiv(const_cast<const GLint*>(&c));
}
void QOpenGLFunctions_4_1_Compatibility_GlIndexs5(void* ptr, short c)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glIndexs(c);
}
void QOpenGLFunctions_4_1_Compatibility_GlIndexsv5(void* ptr, short c)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glIndexsv(const_cast<const GLshort*>(&c));
}
void QOpenGLFunctions_4_1_Compatibility_GlIndexub5(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glIndexub(*static_cast<GLubyte*>(static_cast<void*>(c)));
}
void QOpenGLFunctions_4_1_Compatibility_GlIndexubv5(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glIndexubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(c))));
}
void QOpenGLFunctions_4_1_Compatibility_GlInitNames5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glInitNames();
}
void QOpenGLFunctions_4_1_Compatibility_GlInterleavedArrays5(void* ptr, unsigned int format, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glInterleavedArrays(format, stride, pointer);
}
void QOpenGLFunctions_4_1_Compatibility_GlLightModelf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glLightModelf(pname, param);
}
void QOpenGLFunctions_4_1_Compatibility_GlLightModelfv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glLightModelfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_1_Compatibility_GlLightModeli5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glLightModeli(pname, param);
}
void QOpenGLFunctions_4_1_Compatibility_GlLightModeliv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glLightModeliv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_1_Compatibility_GlLightf5(void* ptr, unsigned int light, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glLightf(light, pname, param);
}
void QOpenGLFunctions_4_1_Compatibility_GlLightfv5(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glLightfv(light, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_1_Compatibility_GlLighti5(void* ptr, unsigned int light, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glLighti(light, pname, param);
}
void QOpenGLFunctions_4_1_Compatibility_GlLightiv5(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glLightiv(light, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_1_Compatibility_GlLineStipple5(void* ptr, int factor, unsigned short pattern)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glLineStipple(factor, pattern);
}
void QOpenGLFunctions_4_1_Compatibility_GlLineWidth5(void* ptr, float width)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_4_1_Compatibility_GlLinkProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glLinkProgram(program);
}
void QOpenGLFunctions_4_1_Compatibility_GlListBase5(void* ptr, unsigned int base)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glListBase(base);
}
void QOpenGLFunctions_4_1_Compatibility_GlLoadIdentity5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glLoadIdentity();
}
void QOpenGLFunctions_4_1_Compatibility_GlLoadMatrixf5(void* ptr, float m)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glLoadMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_4_1_Compatibility_GlLoadName5(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glLoadName(name);
}
void QOpenGLFunctions_4_1_Compatibility_GlLoadTransposeMatrixf5(void* ptr, float m)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glLoadTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_4_1_Compatibility_GlLogicOp5(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_4_1_Compatibility_GlMap1f5(void* ptr, unsigned int target, float u1, float u2, int stride, int order, float points)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMap1f(target, u1, u2, stride, order, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_4_1_Compatibility_GlMap2f5(void* ptr, unsigned int target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float points)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_4_1_Compatibility_GlMapGrid1f5(void* ptr, int un, float u1, float u2)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMapGrid1f(un, u1, u2);
}
void QOpenGLFunctions_4_1_Compatibility_GlMapGrid2f5(void* ptr, int un, float u1, float u2, int vn, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMapGrid2f(un, u1, u2, vn, v1, v2);
}
void QOpenGLFunctions_4_1_Compatibility_GlMaterialf5(void* ptr, unsigned int face, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMaterialf(face, pname, param);
}
void QOpenGLFunctions_4_1_Compatibility_GlMaterialfv5(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMaterialfv(face, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_1_Compatibility_GlMateriali5(void* ptr, unsigned int face, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMateriali(face, pname, param);
}
void QOpenGLFunctions_4_1_Compatibility_GlMaterialiv5(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMaterialiv(face, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_1_Compatibility_GlMatrixMode5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMatrixMode(mode);
}
void QOpenGLFunctions_4_1_Compatibility_GlMinSampleShading5(void* ptr, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMinSampleShading(value);
}
void QOpenGLFunctions_4_1_Compatibility_GlMinmax5(void* ptr, unsigned int target, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMinmax(target, internalformat, sink != 0);
}
void QOpenGLFunctions_4_1_Compatibility_GlMultMatrixf5(void* ptr, float m)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_4_1_Compatibility_GlMultTransposeMatrixf5(void* ptr, float m)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiDrawArrays5(void* ptr, unsigned int mode, int first, int count, int drawcount)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiDrawArrays(mode, const_cast<const GLint*>(&first), const_cast<const GLsizei*>(&count), drawcount);
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoord1f5(void* ptr, unsigned int target, float s)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoord1f(target, s);
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoord1fv5(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoord1fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoord1i5(void* ptr, unsigned int target, int s)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoord1i(target, s);
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoord1iv5(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoord1iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoord1s5(void* ptr, unsigned int target, short s)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoord1s(target, s);
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoord1sv5(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoord1sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoord2f5(void* ptr, unsigned int target, float s, float t)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoord2f(target, s, t);
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoord2fv5(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoord2fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoord2i5(void* ptr, unsigned int target, int s, int t)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoord2i(target, s, t);
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoord2iv5(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoord2iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoord2s5(void* ptr, unsigned int target, short s, short t)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoord2s(target, s, t);
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoord2sv5(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoord2sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoord3f5(void* ptr, unsigned int target, float s, float t, float r)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoord3f(target, s, t, r);
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoord3fv5(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoord3fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoord3i5(void* ptr, unsigned int target, int s, int t, int r)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoord3i(target, s, t, r);
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoord3iv5(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoord3iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoord3s5(void* ptr, unsigned int target, short s, short t, short r)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoord3s(target, s, t, r);
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoord3sv5(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoord3sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoord4f5(void* ptr, unsigned int target, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoord4f(target, s, t, r, q);
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoord4fv5(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoord4fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoord4i5(void* ptr, unsigned int target, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoord4i(target, s, t, r, q);
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoord4iv5(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoord4iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoord4s5(void* ptr, unsigned int target, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoord4s(target, s, t, r, q);
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoord4sv5(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoord4sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoordP1ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoordP1ui(texture, ty, coords);
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoordP1uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoordP1uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoordP2ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoordP2ui(texture, ty, coords);
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoordP2uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoordP2uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoordP3ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoordP3ui(texture, ty, coords);
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoordP3uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoordP3uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoordP4ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoordP4ui(texture, ty, coords);
}
void QOpenGLFunctions_4_1_Compatibility_GlMultiTexCoordP4uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glMultiTexCoordP4uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_1_Compatibility_GlNewList5(void* ptr, unsigned int list, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glNewList(list, mode);
}
void QOpenGLFunctions_4_1_Compatibility_GlNormal3f5(void* ptr, float nx, float ny, float nz)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glNormal3f(nx, ny, nz);
}
void QOpenGLFunctions_4_1_Compatibility_GlNormal3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glNormal3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlNormal3i5(void* ptr, int nx, int ny, int nz)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glNormal3i(nx, ny, nz);
}
void QOpenGLFunctions_4_1_Compatibility_GlNormal3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glNormal3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlNormal3s5(void* ptr, short nx, short ny, short nz)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glNormal3s(nx, ny, nz);
}
void QOpenGLFunctions_4_1_Compatibility_GlNormal3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glNormal3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlNormalP3ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glNormalP3ui(ty, coords);
}
void QOpenGLFunctions_4_1_Compatibility_GlNormalP3uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glNormalP3uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_1_Compatibility_GlNormalPointer5(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glNormalPointer(ty, stride, pointer);
}
void QOpenGLFunctions_4_1_Compatibility_GlPassThrough5(void* ptr, float token)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPassThrough(token);
}
void QOpenGLFunctions_4_1_Compatibility_GlPatchParameterfv5(void* ptr, unsigned int pname, float values)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPatchParameterfv(pname, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_4_1_Compatibility_GlPatchParameteri5(void* ptr, unsigned int pname, int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPatchParameteri(pname, value);
}
void QOpenGLFunctions_4_1_Compatibility_GlPauseTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPauseTransformFeedback();
}
void QOpenGLFunctions_4_1_Compatibility_GlPixelMapfv5(void* ptr, unsigned int m, int mapsize, float values)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPixelMapfv(m, mapsize, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_4_1_Compatibility_GlPixelMapuiv5(void* ptr, unsigned int m, int mapsize, unsigned int values)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPixelMapuiv(m, mapsize, const_cast<const GLuint*>(&values));
}
void QOpenGLFunctions_4_1_Compatibility_GlPixelMapusv5(void* ptr, unsigned int m, int mapsize, unsigned short values)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPixelMapusv(m, mapsize, const_cast<const GLushort*>(&values));
}
void QOpenGLFunctions_4_1_Compatibility_GlPixelStoref5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_4_1_Compatibility_GlPixelStorei5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_4_1_Compatibility_GlPixelTransferf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPixelTransferf(pname, param);
}
void QOpenGLFunctions_4_1_Compatibility_GlPixelTransferi5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPixelTransferi(pname, param);
}
void QOpenGLFunctions_4_1_Compatibility_GlPixelZoom5(void* ptr, float xfactor, float yfactor)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPixelZoom(xfactor, yfactor);
}
void QOpenGLFunctions_4_1_Compatibility_GlPointParameterf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPointParameterf(pname, param);
}
void QOpenGLFunctions_4_1_Compatibility_GlPointParameterfv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPointParameterfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_1_Compatibility_GlPointParameteri5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPointParameteri(pname, param);
}
void QOpenGLFunctions_4_1_Compatibility_GlPointParameteriv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPointParameteriv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_1_Compatibility_GlPointSize5(void* ptr, float size)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_4_1_Compatibility_GlPolygonMode5(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_4_1_Compatibility_GlPolygonOffset5(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_4_1_Compatibility_GlPolygonStipple5(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPolygonStipple(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(mask))));
}
void QOpenGLFunctions_4_1_Compatibility_GlPopAttrib5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPopAttrib();
}
void QOpenGLFunctions_4_1_Compatibility_GlPopClientAttrib5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPopClientAttrib();
}
void QOpenGLFunctions_4_1_Compatibility_GlPopMatrix5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPopMatrix();
}
void QOpenGLFunctions_4_1_Compatibility_GlPopName5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPopName();
}
void QOpenGLFunctions_4_1_Compatibility_GlPrimitiveRestartIndex5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPrimitiveRestartIndex(index);
}
void QOpenGLFunctions_4_1_Compatibility_GlPrioritizeTextures5(void* ptr, int n, unsigned int textures, float priorities)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPrioritizeTextures(n, const_cast<const GLuint*>(&textures), const_cast<const GLfloat*>(&priorities));
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramBinary5(void* ptr, unsigned int program, unsigned int binaryFormat, void* binary, int length)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramBinary(program, binaryFormat, binary, length);
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramParameteri5(void* ptr, unsigned int program, unsigned int pname, int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramParameteri(program, pname, value);
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniform1f5(void* ptr, unsigned int program, int location, float v0)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniform1f(program, location, v0);
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniform1fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniform1fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniform1i5(void* ptr, unsigned int program, int location, int v0)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniform1i(program, location, v0);
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniform1iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniform1iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniform1ui5(void* ptr, unsigned int program, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniform1ui(program, location, v0);
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniform1uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniform1uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniform2f5(void* ptr, unsigned int program, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniform2f(program, location, v0, v1);
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniform2fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniform2fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniform2i5(void* ptr, unsigned int program, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniform2i(program, location, v0, v1);
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniform2iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniform2iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniform2ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniform2ui(program, location, v0, v1);
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniform2uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniform2uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniform3f5(void* ptr, unsigned int program, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniform3f(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniform3fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniform3fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniform3i5(void* ptr, unsigned int program, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniform3i(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniform3iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniform3iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniform3ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniform3ui(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniform3uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniform3uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniform4f5(void* ptr, unsigned int program, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniform4f(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniform4fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniform4fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniform4i5(void* ptr, unsigned int program, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniform4i(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniform4iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniform4iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniform4ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniform4ui(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniform4uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniform4uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniformMatrix2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniformMatrix2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniformMatrix2x3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniformMatrix2x3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniformMatrix2x4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniformMatrix2x4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniformMatrix3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniformMatrix3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniformMatrix3x2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniformMatrix3x2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniformMatrix3x4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniformMatrix3x4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniformMatrix4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniformMatrix4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniformMatrix4x2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniformMatrix4x2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlProgramUniformMatrix4x3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProgramUniformMatrix4x3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlProvokingVertex5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glProvokingVertex(mode);
}
void QOpenGLFunctions_4_1_Compatibility_GlPushAttrib5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPushAttrib(mask);
}
void QOpenGLFunctions_4_1_Compatibility_GlPushClientAttrib5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPushClientAttrib(mask);
}
void QOpenGLFunctions_4_1_Compatibility_GlPushMatrix5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPushMatrix();
}
void QOpenGLFunctions_4_1_Compatibility_GlPushName5(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glPushName(name);
}
void QOpenGLFunctions_4_1_Compatibility_GlQueryCounter5(void* ptr, unsigned int id, unsigned int target)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glQueryCounter(id, target);
}
void QOpenGLFunctions_4_1_Compatibility_GlRasterPos2f5(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRasterPos2f(x, y);
}
void QOpenGLFunctions_4_1_Compatibility_GlRasterPos2fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRasterPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlRasterPos2i5(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRasterPos2i(x, y);
}
void QOpenGLFunctions_4_1_Compatibility_GlRasterPos2iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRasterPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlRasterPos2s5(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRasterPos2s(x, y);
}
void QOpenGLFunctions_4_1_Compatibility_GlRasterPos2sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRasterPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlRasterPos3f5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRasterPos3f(x, y, z);
}
void QOpenGLFunctions_4_1_Compatibility_GlRasterPos3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRasterPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlRasterPos3i5(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRasterPos3i(x, y, z);
}
void QOpenGLFunctions_4_1_Compatibility_GlRasterPos3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRasterPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlRasterPos3s5(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRasterPos3s(x, y, z);
}
void QOpenGLFunctions_4_1_Compatibility_GlRasterPos3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRasterPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlRasterPos4f5(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRasterPos4f(x, y, z, w);
}
void QOpenGLFunctions_4_1_Compatibility_GlRasterPos4fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRasterPos4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlRasterPos4i5(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRasterPos4i(x, y, z, w);
}
void QOpenGLFunctions_4_1_Compatibility_GlRasterPos4iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRasterPos4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlRasterPos4s5(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRasterPos4s(x, y, z, w);
}
void QOpenGLFunctions_4_1_Compatibility_GlRasterPos4sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRasterPos4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlReadBuffer5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glReadBuffer(mode);
}
void QOpenGLFunctions_4_1_Compatibility_GlReadPixels5(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_1_Compatibility_GlRectf5(void* ptr, float x1, float y1, float x2, float y2)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRectf(x1, y1, x2, y2);
}
void QOpenGLFunctions_4_1_Compatibility_GlRectfv5(void* ptr, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRectfv(const_cast<const GLfloat*>(&v1), const_cast<const GLfloat*>(&v2));
}
void QOpenGLFunctions_4_1_Compatibility_GlRecti5(void* ptr, int x1, int y1, int x2, int y2)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRecti(x1, y1, x2, y2);
}
void QOpenGLFunctions_4_1_Compatibility_GlRectiv5(void* ptr, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRectiv(const_cast<const GLint*>(&v1), const_cast<const GLint*>(&v2));
}
void QOpenGLFunctions_4_1_Compatibility_GlRects5(void* ptr, short x1, short y1, short x2, short y2)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRects(x1, y1, x2, y2);
}
void QOpenGLFunctions_4_1_Compatibility_GlRectsv5(void* ptr, short v1, short v2)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRectsv(const_cast<const GLshort*>(&v1), const_cast<const GLshort*>(&v2));
}
void QOpenGLFunctions_4_1_Compatibility_GlReleaseShaderCompiler5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glReleaseShaderCompiler();
}
void QOpenGLFunctions_4_1_Compatibility_GlRenderbufferStorage5(void* ptr, unsigned int target, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRenderbufferStorage(target, internalformat, width, height);
}
void QOpenGLFunctions_4_1_Compatibility_GlRenderbufferStorageMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
}
void QOpenGLFunctions_4_1_Compatibility_GlResetHistogram5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glResetHistogram(target);
}
void QOpenGLFunctions_4_1_Compatibility_GlResetMinmax5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glResetMinmax(target);
}
void QOpenGLFunctions_4_1_Compatibility_GlResumeTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glResumeTransformFeedback();
}
void QOpenGLFunctions_4_1_Compatibility_GlRotatef5(void* ptr, float angle, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glRotatef(angle, x, y, z);
}
void QOpenGLFunctions_4_1_Compatibility_GlSampleCoverage5(void* ptr, float value, char invert)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSampleCoverage(value, invert != 0);
}
void QOpenGLFunctions_4_1_Compatibility_GlSampleMaski5(void* ptr, unsigned int index, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSampleMaski(index, mask);
}
void QOpenGLFunctions_4_1_Compatibility_GlSamplerParameterIiv5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSamplerParameterIiv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_1_Compatibility_GlSamplerParameterIuiv5(void* ptr, unsigned int sampler, unsigned int pname, unsigned int param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSamplerParameterIuiv(sampler, pname, const_cast<const GLuint*>(&param));
}
void QOpenGLFunctions_4_1_Compatibility_GlSamplerParameterf5(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSamplerParameterf(sampler, pname, param);
}
void QOpenGLFunctions_4_1_Compatibility_GlSamplerParameterfv5(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSamplerParameterfv(sampler, pname, const_cast<const GLfloat*>(&param));
}
void QOpenGLFunctions_4_1_Compatibility_GlSamplerParameteri5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSamplerParameteri(sampler, pname, param);
}
void QOpenGLFunctions_4_1_Compatibility_GlSamplerParameteriv5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSamplerParameteriv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_1_Compatibility_GlScalef5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glScalef(x, y, z);
}
void QOpenGLFunctions_4_1_Compatibility_GlScissor5(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_4_1_Compatibility_GlScissorArrayv5(void* ptr, unsigned int first, int count, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glScissorArrayv(first, count, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlScissorIndexed5(void* ptr, unsigned int index, int left, int bottom, int width, int height)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glScissorIndexed(index, left, bottom, width, height);
}
void QOpenGLFunctions_4_1_Compatibility_GlScissorIndexedv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glScissorIndexedv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlSecondaryColor3f5(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSecondaryColor3f(red, green, blue);
}
void QOpenGLFunctions_4_1_Compatibility_GlSecondaryColor3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSecondaryColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlSecondaryColor3i5(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSecondaryColor3i(red, green, blue);
}
void QOpenGLFunctions_4_1_Compatibility_GlSecondaryColor3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSecondaryColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlSecondaryColor3s5(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSecondaryColor3s(red, green, blue);
}
void QOpenGLFunctions_4_1_Compatibility_GlSecondaryColor3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSecondaryColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlSecondaryColor3ub5(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSecondaryColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_4_1_Compatibility_GlSecondaryColor3ubv5(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSecondaryColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_1_Compatibility_GlSecondaryColor3ui5(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSecondaryColor3ui(red, green, blue);
}
void QOpenGLFunctions_4_1_Compatibility_GlSecondaryColor3uiv5(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSecondaryColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlSecondaryColor3us5(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSecondaryColor3us(red, green, blue);
}
void QOpenGLFunctions_4_1_Compatibility_GlSecondaryColor3usv5(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSecondaryColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlSecondaryColorP3ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSecondaryColorP3ui(ty, color);
}
void QOpenGLFunctions_4_1_Compatibility_GlSecondaryColorP3uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSecondaryColorP3uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_1_Compatibility_GlSecondaryColorPointer5(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSecondaryColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_4_1_Compatibility_GlSelectBuffer5(void* ptr, int size, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSelectBuffer(size, &buffer);
}
void QOpenGLFunctions_4_1_Compatibility_GlSeparableFilter2D5(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* row, void* column)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glSeparableFilter2D(target, internalformat, width, height, format, ty, row, column);
}
void QOpenGLFunctions_4_1_Compatibility_GlShadeModel5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glShadeModel(mode);
}
void QOpenGLFunctions_4_1_Compatibility_GlShaderBinary5(void* ptr, int count, unsigned int shaders, unsigned int binaryformat, void* binary, int length)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glShaderBinary(count, const_cast<const GLuint*>(&shaders), binaryformat, binary, length);
}
void QOpenGLFunctions_4_1_Compatibility_GlStencilFunc5(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_4_1_Compatibility_GlStencilFuncSeparate5(void* ptr, unsigned int face, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glStencilFuncSeparate(face, fu, ref, mask);
}
void QOpenGLFunctions_4_1_Compatibility_GlStencilMask5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_4_1_Compatibility_GlStencilMaskSeparate5(void* ptr, unsigned int face, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glStencilMaskSeparate(face, mask);
}
void QOpenGLFunctions_4_1_Compatibility_GlStencilOp5(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_4_1_Compatibility_GlStencilOpSeparate5(void* ptr, unsigned int face, unsigned int sfail, unsigned int dpfail, unsigned int dppass)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glStencilOpSeparate(face, sfail, dpfail, dppass);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexBuffer5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexBuffer(target, internalformat, buffer);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoord1f5(void* ptr, float s)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoord1f(s);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoord1fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoord1fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoord1i5(void* ptr, int s)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoord1i(s);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoord1iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoord1iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoord1s5(void* ptr, short s)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoord1s(s);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoord1sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoord1sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoord2f5(void* ptr, float s, float t)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoord2f(s, t);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoord2fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoord2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoord2i5(void* ptr, int s, int t)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoord2i(s, t);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoord2iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoord2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoord2s5(void* ptr, short s, short t)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoord2s(s, t);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoord2sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoord2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoord3f5(void* ptr, float s, float t, float r)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoord3f(s, t, r);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoord3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoord3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoord3i5(void* ptr, int s, int t, int r)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoord3i(s, t, r);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoord3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoord3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoord3s5(void* ptr, short s, short t, short r)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoord3s(s, t, r);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoord3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoord3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoord4f5(void* ptr, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoord4f(s, t, r, q);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoord4fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoord4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoord4i5(void* ptr, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoord4i(s, t, r, q);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoord4iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoord4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoord4s5(void* ptr, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoord4s(s, t, r, q);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoord4sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoord4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoordP1ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoordP1ui(ty, coords);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoordP1uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoordP1uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoordP2ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoordP2ui(ty, coords);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoordP2uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoordP2uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoordP3ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoordP3ui(ty, coords);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoordP3uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoordP3uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoordP4ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoordP4ui(ty, coords);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoordP4uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoordP4uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_1_Compatibility_GlTexCoordPointer5(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexCoordPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexEnvf5(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexEnvf(target, pname, param);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexEnvfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexEnvfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_1_Compatibility_GlTexEnvi5(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexEnvi(target, pname, param);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexEnviv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexEnviv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_1_Compatibility_GlTexGenf5(void* ptr, unsigned int coord, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexGenf(coord, pname, param);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexGenfv5(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexGenfv(coord, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_1_Compatibility_GlTexGeni5(void* ptr, unsigned int coord, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexGeni(coord, pname, param);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexGeniv5(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexGeniv(coord, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_1_Compatibility_GlTexImage1D5(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexImage2D5(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexImage2DMultisample5(void* ptr, unsigned int target, int samples, int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexImage3D5(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexImage3DMultisample5(void* ptr, unsigned int target, int samples, int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexParameterIiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexParameterIiv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_1_Compatibility_GlTexParameterIuiv5(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexParameterIuiv(target, pname, const_cast<const GLuint*>(&params));
}
void QOpenGLFunctions_4_1_Compatibility_GlTexParameterf5(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_1_Compatibility_GlTexParameteri5(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_1_Compatibility_GlTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_1_Compatibility_GlTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_4_1_Compatibility_GlTranslatef5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glTranslatef(x, y, z);
}
void QOpenGLFunctions_4_1_Compatibility_GlUniform1f5(void* ptr, int location, float v0)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniform1f(location, v0);
}
void QOpenGLFunctions_4_1_Compatibility_GlUniform1fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniform1fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlUniform1i5(void* ptr, int location, int v0)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniform1i(location, v0);
}
void QOpenGLFunctions_4_1_Compatibility_GlUniform1iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniform1iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlUniform1ui5(void* ptr, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniform1ui(location, v0);
}
void QOpenGLFunctions_4_1_Compatibility_GlUniform1uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniform1uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlUniform2f5(void* ptr, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniform2f(location, v0, v1);
}
void QOpenGLFunctions_4_1_Compatibility_GlUniform2fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniform2fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlUniform2i5(void* ptr, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniform2i(location, v0, v1);
}
void QOpenGLFunctions_4_1_Compatibility_GlUniform2iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniform2iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlUniform2ui5(void* ptr, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniform2ui(location, v0, v1);
}
void QOpenGLFunctions_4_1_Compatibility_GlUniform2uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniform2uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlUniform3f5(void* ptr, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniform3f(location, v0, v1, v2);
}
void QOpenGLFunctions_4_1_Compatibility_GlUniform3fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniform3fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlUniform3i5(void* ptr, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniform3i(location, v0, v1, v2);
}
void QOpenGLFunctions_4_1_Compatibility_GlUniform3iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniform3iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlUniform3ui5(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniform3ui(location, v0, v1, v2);
}
void QOpenGLFunctions_4_1_Compatibility_GlUniform3uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniform3uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlUniform4f5(void* ptr, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniform4f(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_1_Compatibility_GlUniform4fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniform4fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlUniform4i5(void* ptr, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniform4i(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_1_Compatibility_GlUniform4iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniform4iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlUniform4ui5(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniform4ui(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_1_Compatibility_GlUniform4uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniform4uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlUniformBlockBinding5(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int uniformBlockBinding)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}
void QOpenGLFunctions_4_1_Compatibility_GlUniformMatrix2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniformMatrix2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlUniformMatrix2x3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniformMatrix2x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlUniformMatrix2x4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniformMatrix2x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlUniformMatrix3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniformMatrix3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlUniformMatrix3x2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniformMatrix3x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlUniformMatrix3x4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniformMatrix3x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlUniformMatrix4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniformMatrix4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlUniformMatrix4x2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniformMatrix4x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlUniformMatrix4x3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniformMatrix4x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlUniformSubroutinesuiv5(void* ptr, unsigned int shadertype, int count, unsigned int indices)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUniformSubroutinesuiv(shadertype, count, const_cast<const GLuint*>(&indices));
}
void QOpenGLFunctions_4_1_Compatibility_GlUseProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUseProgram(program);
}
void QOpenGLFunctions_4_1_Compatibility_GlUseProgramStages5(void* ptr, unsigned int pipeline, unsigned int stages, unsigned int program)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glUseProgramStages(pipeline, stages, program);
}
void QOpenGLFunctions_4_1_Compatibility_GlValidateProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glValidateProgram(program);
}
void QOpenGLFunctions_4_1_Compatibility_GlValidateProgramPipeline5(void* ptr, unsigned int pipeline)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glValidateProgramPipeline(pipeline);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertex2f5(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertex2f(x, y);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertex2fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertex2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertex2i5(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertex2i(x, y);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertex2iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertex2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertex2s5(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertex2s(x, y);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertex2sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertex2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertex3f5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertex3f(x, y, z);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertex3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertex3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertex3i5(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertex3i(x, y, z);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertex3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertex3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertex3s5(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertex3s(x, y, z);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertex3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertex3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertex4f5(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertex4f(x, y, z, w);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertex4fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertex4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertex4i5(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertex4i(x, y, z, w);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertex4iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertex4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertex4s5(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertex4s(x, y, z, w);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertex4sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertex4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib1f5(void* ptr, unsigned int index, float x)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib1f(index, x);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib1fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib1fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib1s5(void* ptr, unsigned int index, short x)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib1s(index, x);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib1sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib1sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib2f5(void* ptr, unsigned int index, float x, float y)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib2f(index, x, y);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib2fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib2fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib2s5(void* ptr, unsigned int index, short x, short y)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib2s(index, x, y);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib2sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib2sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib3f5(void* ptr, unsigned int index, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib3f(index, x, y, z);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib3fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib3fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib3s5(void* ptr, unsigned int index, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib3s(index, x, y, z);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib3sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib3sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib4Niv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib4Niv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib4Nsv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib4Nsv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib4Nub5(void* ptr, unsigned int index, char* x, char* y, char* z, char* w)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib4Nub(index, *static_cast<GLubyte*>(static_cast<void*>(x)), *static_cast<GLubyte*>(static_cast<void*>(y)), *static_cast<GLubyte*>(static_cast<void*>(z)), *static_cast<GLubyte*>(static_cast<void*>(w)));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib4Nubv5(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib4Nubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib4Nuiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib4Nuiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib4Nusv5(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib4Nusv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib4f5(void* ptr, unsigned int index, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib4f(index, x, y, z, w);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib4fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib4fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib4iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib4s5(void* ptr, unsigned int index, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib4s(index, x, y, z, w);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib4sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib4sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib4ubv5(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib4ubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib4uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttrib4usv5(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttrib4usv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribDivisor5(void* ptr, unsigned int index, unsigned int divisor)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribDivisor(index, divisor);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribI1i5(void* ptr, unsigned int index, int x)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribI1i(index, x);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribI1iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribI1iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribI1ui5(void* ptr, unsigned int index, unsigned int x)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribI1ui(index, x);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribI1uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribI1uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribI2i5(void* ptr, unsigned int index, int x, int y)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribI2i(index, x, y);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribI2iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribI2iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribI2ui5(void* ptr, unsigned int index, unsigned int x, unsigned int y)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribI2ui(index, x, y);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribI2uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribI2uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribI3i5(void* ptr, unsigned int index, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribI3i(index, x, y, z);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribI3iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribI3iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribI3ui5(void* ptr, unsigned int index, unsigned int x, unsigned int y, unsigned int z)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribI3ui(index, x, y, z);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribI3uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribI3uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribI4i5(void* ptr, unsigned int index, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribI4i(index, x, y, z, w);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribI4iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribI4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribI4sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribI4sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribI4ubv5(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribI4ubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribI4ui5(void* ptr, unsigned int index, unsigned int x, unsigned int y, unsigned int z, unsigned int w)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribI4ui(index, x, y, z, w);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribI4uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribI4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribI4usv5(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribI4usv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribIPointer5(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribIPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribLPointer5(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribLPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribP1ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribP1ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribP1uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribP1uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribP2ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribP2ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribP2uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribP2uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribP3ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribP3ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribP3uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribP3uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribP4ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribP4ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribP4uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribP4uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexAttribPointer5(void* ptr, unsigned int index, int size, unsigned int ty, char normalized, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexAttribPointer(index, size, ty, normalized != 0, stride, pointer);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexP2ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexP2ui(ty, value);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexP2uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexP2uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexP3ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexP3ui(ty, value);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexP3uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexP3uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexP4ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexP4ui(ty, value);
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexP4uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexP4uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Compatibility_GlVertexPointer5(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glVertexPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_4_1_Compatibility_GlViewport5(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_4_1_Compatibility_GlViewportArrayv5(void* ptr, unsigned int first, int count, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glViewportArrayv(first, count, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlViewportIndexedf5(void* ptr, unsigned int index, float x, float y, float w, float h)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glViewportIndexedf(index, x, y, w, h);
}
void QOpenGLFunctions_4_1_Compatibility_GlViewportIndexedfv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glViewportIndexedfv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlWindowPos2f5(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glWindowPos2f(x, y);
}
void QOpenGLFunctions_4_1_Compatibility_GlWindowPos2fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glWindowPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlWindowPos2i5(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glWindowPos2i(x, y);
}
void QOpenGLFunctions_4_1_Compatibility_GlWindowPos2iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glWindowPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlWindowPos2s5(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glWindowPos2s(x, y);
}
void QOpenGLFunctions_4_1_Compatibility_GlWindowPos2sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glWindowPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlWindowPos3f5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glWindowPos3f(x, y, z);
}
void QOpenGLFunctions_4_1_Compatibility_GlWindowPos3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glWindowPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlWindowPos3i5(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glWindowPos3i(x, y, z);
}
void QOpenGLFunctions_4_1_Compatibility_GlWindowPos3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glWindowPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_GlWindowPos3s5(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glWindowPos3s(x, y, z);
}
void QOpenGLFunctions_4_1_Compatibility_GlWindowPos3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glWindowPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_1_Compatibility_DestroyQOpenGLFunctions_4_1_Compatibility5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->~QOpenGLFunctions_4_1_Compatibility();
}
void QOpenGLFunctions_4_1_Compatibility_DestroyQOpenGLFunctions_4_1_Compatibility5Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_4_1_Core: public QOpenGLFunctions_4_1_Core
{
public:
MyQOpenGLFunctions_4_1_Core() : QOpenGLFunctions_4_1_Core() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_4_1_Core_InitializeOpenGLFunctions5(this) != 0; };
~MyQOpenGLFunctions_4_1_Core() { callbackQOpenGLFunctions_4_1_Core_DestroyQOpenGLFunctions_4_1_Core5(this); };
};
char QOpenGLFunctions_4_1_Core_GlIsBuffer5(void* ptr, unsigned int buffer)
{
return static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glIsBuffer(buffer);
}
char QOpenGLFunctions_4_1_Core_GlIsEnabled5(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_4_1_Core_GlIsEnabledi5(void* ptr, unsigned int target, unsigned int index)
{
return static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glIsEnabledi(target, index);
}
char QOpenGLFunctions_4_1_Core_GlIsFramebuffer5(void* ptr, unsigned int framebuffer)
{
return static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glIsFramebuffer(framebuffer);
}
char QOpenGLFunctions_4_1_Core_GlIsProgram5(void* ptr, unsigned int program)
{
return static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glIsProgram(program);
}
char QOpenGLFunctions_4_1_Core_GlIsProgramPipeline5(void* ptr, unsigned int pipeline)
{
return static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glIsProgramPipeline(pipeline);
}
char QOpenGLFunctions_4_1_Core_GlIsQuery5(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glIsQuery(id);
}
char QOpenGLFunctions_4_1_Core_GlIsRenderbuffer5(void* ptr, unsigned int renderbuffer)
{
return static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glIsRenderbuffer(renderbuffer);
}
char QOpenGLFunctions_4_1_Core_GlIsSampler5(void* ptr, unsigned int sampler)
{
return static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glIsSampler(sampler);
}
char QOpenGLFunctions_4_1_Core_GlIsShader5(void* ptr, unsigned int shader)
{
return static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glIsShader(shader);
}
char QOpenGLFunctions_4_1_Core_GlIsTexture5(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glIsTexture(texture);
}
char QOpenGLFunctions_4_1_Core_GlIsTransformFeedback5(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glIsTransformFeedback(id);
}
char QOpenGLFunctions_4_1_Core_GlIsVertexArray5(void* ptr, unsigned int array)
{
return static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glIsVertexArray(array);
}
char QOpenGLFunctions_4_1_Core_GlUnmapBuffer5(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUnmapBuffer(target);
}
unsigned int QOpenGLFunctions_4_1_Core_GlCheckFramebufferStatus5(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glCheckFramebufferStatus(target);
}
unsigned int QOpenGLFunctions_4_1_Core_GlGetError5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetError();
}
unsigned int QOpenGLFunctions_4_1_Core_GlCreateProgram5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glCreateProgram();
}
unsigned int QOpenGLFunctions_4_1_Core_GlCreateShader5(void* ptr, unsigned int ty)
{
return static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glCreateShader(ty);
}
void* QOpenGLFunctions_4_1_Core_GlMapBuffer5(void* ptr, unsigned int target, unsigned int access)
{
return static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glMapBuffer(target, access);
}
void* QOpenGLFunctions_4_1_Core_NewQOpenGLFunctions_4_1_Core5()
{
return new MyQOpenGLFunctions_4_1_Core();
}
char QOpenGLFunctions_4_1_Core_InitializeOpenGLFunctions5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_4_1_Core_InitializeOpenGLFunctions5Default(void* ptr)
{
return static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->QOpenGLFunctions_4_1_Core::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_4_1_Core_GlGetString5(void* ptr, unsigned int name)
{
return ({ char* tb7b499 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetString(name)))); QtGui_PackedString { tb7b499, -1 }; });
}
struct QtGui_PackedString QOpenGLFunctions_4_1_Core_GlGetStringi5(void* ptr, unsigned int name, unsigned int index)
{
return ({ char* t6aec1e = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetStringi(name, index)))); QtGui_PackedString { t6aec1e, -1 }; });
}
void QOpenGLFunctions_4_1_Core_GlActiveShaderProgram5(void* ptr, unsigned int pipeline, unsigned int program)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glActiveShaderProgram(pipeline, program);
}
void QOpenGLFunctions_4_1_Core_GlActiveTexture5(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glActiveTexture(texture);
}
void QOpenGLFunctions_4_1_Core_GlAttachShader5(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glAttachShader(program, shader);
}
void QOpenGLFunctions_4_1_Core_GlBeginConditionalRender5(void* ptr, unsigned int id, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glBeginConditionalRender(id, mode);
}
void QOpenGLFunctions_4_1_Core_GlBeginQuery5(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glBeginQuery(target, id);
}
void QOpenGLFunctions_4_1_Core_GlBeginQueryIndexed5(void* ptr, unsigned int target, unsigned int index, unsigned int id)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glBeginQueryIndexed(target, index, id);
}
void QOpenGLFunctions_4_1_Core_GlBeginTransformFeedback5(void* ptr, unsigned int primitiveMode)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glBeginTransformFeedback(primitiveMode);
}
void QOpenGLFunctions_4_1_Core_GlBindBuffer5(void* ptr, unsigned int target, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glBindBuffer(target, buffer);
}
void QOpenGLFunctions_4_1_Core_GlBindBufferBase5(void* ptr, unsigned int target, unsigned int index, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glBindBufferBase(target, index, buffer);
}
void QOpenGLFunctions_4_1_Core_GlBindFramebuffer5(void* ptr, unsigned int target, unsigned int framebuffer)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glBindFramebuffer(target, framebuffer);
}
void QOpenGLFunctions_4_1_Core_GlBindProgramPipeline5(void* ptr, unsigned int pipeline)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glBindProgramPipeline(pipeline);
}
void QOpenGLFunctions_4_1_Core_GlBindRenderbuffer5(void* ptr, unsigned int target, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glBindRenderbuffer(target, renderbuffer);
}
void QOpenGLFunctions_4_1_Core_GlBindSampler5(void* ptr, unsigned int unit, unsigned int sampler)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glBindSampler(unit, sampler);
}
void QOpenGLFunctions_4_1_Core_GlBindTexture5(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_4_1_Core_GlBindTransformFeedback5(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glBindTransformFeedback(target, id);
}
void QOpenGLFunctions_4_1_Core_GlBindVertexArray5(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glBindVertexArray(array);
}
void QOpenGLFunctions_4_1_Core_GlBlendColor5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_4_1_Core_GlBlendEquation5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_4_1_Core_GlBlendEquationSeparate5(void* ptr, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glBlendEquationSeparate(modeRGB, modeAlpha);
}
void QOpenGLFunctions_4_1_Core_GlBlendEquationSeparatei5(void* ptr, unsigned int buf, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glBlendEquationSeparatei(buf, modeRGB, modeAlpha);
}
void QOpenGLFunctions_4_1_Core_GlBlendEquationi5(void* ptr, unsigned int buf, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glBlendEquationi(buf, mode);
}
void QOpenGLFunctions_4_1_Core_GlBlendFunc5(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_4_1_Core_GlBlendFuncSeparate5(void* ptr, unsigned int sfactorRGB, unsigned int dfactorRGB, unsigned int sfactorAlpha, unsigned int dfactorAlpha)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void QOpenGLFunctions_4_1_Core_GlBlendFuncSeparatei5(void* ptr, unsigned int buf, unsigned int srcRGB, unsigned int dstRGB, unsigned int srcAlpha, unsigned int dstAlpha)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
void QOpenGLFunctions_4_1_Core_GlBlendFunci5(void* ptr, unsigned int buf, unsigned int src, unsigned int dst)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glBlendFunci(buf, src, dst);
}
void QOpenGLFunctions_4_1_Core_GlBlitFramebuffer5(void* ptr, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, unsigned int mask, unsigned int filter)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
void QOpenGLFunctions_4_1_Core_GlClampColor5(void* ptr, unsigned int target, unsigned int clamp)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glClampColor(target, clamp);
}
void QOpenGLFunctions_4_1_Core_GlClear5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_4_1_Core_GlClearBufferfi5(void* ptr, unsigned int buffer, int drawbuffer, float depth, int stencil)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glClearBufferfi(buffer, drawbuffer, depth, stencil);
}
void QOpenGLFunctions_4_1_Core_GlClearBufferfv5(void* ptr, unsigned int buffer, int drawbuffer, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glClearBufferfv(buffer, drawbuffer, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlClearBufferiv5(void* ptr, unsigned int buffer, int drawbuffer, int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glClearBufferiv(buffer, drawbuffer, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlClearBufferuiv5(void* ptr, unsigned int buffer, int drawbuffer, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glClearBufferuiv(buffer, drawbuffer, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlClearColor5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_4_1_Core_GlClearDepthf5(void* ptr, float dd)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glClearDepthf(dd);
}
void QOpenGLFunctions_4_1_Core_GlClearStencil5(void* ptr, int s)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_4_1_Core_GlColorMask5(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_4_1_Core_GlColorMaski5(void* ptr, unsigned int index, char r, char g, char b, char a)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glColorMaski(index, r != 0, g != 0, b != 0, a != 0);
}
void QOpenGLFunctions_4_1_Core_GlColorP3ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glColorP3ui(ty, color);
}
void QOpenGLFunctions_4_1_Core_GlColorP3uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glColorP3uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_1_Core_GlColorP4ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glColorP4ui(ty, color);
}
void QOpenGLFunctions_4_1_Core_GlColorP4uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glColorP4uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_1_Core_GlCompileShader5(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glCompileShader(shader);
}
void QOpenGLFunctions_4_1_Core_GlCompressedTexImage1D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
void QOpenGLFunctions_4_1_Core_GlCompressedTexImage2D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void QOpenGLFunctions_4_1_Core_GlCompressedTexImage3D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int depth, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void QOpenGLFunctions_4_1_Core_GlCompressedTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_4_1_Core_GlCompressedTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_4_1_Core_GlCompressedTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_4_1_Core_GlCopyTexImage1D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_4_1_Core_GlCopyTexImage2D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_4_1_Core_GlCopyTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_4_1_Core_GlCopyTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_4_1_Core_GlCopyTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_4_1_Core_GlCullFace5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_4_1_Core_GlDeleteBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDeleteBuffers(n, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_4_1_Core_GlDeleteFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDeleteFramebuffers(n, const_cast<const GLuint*>(&framebuffers));
}
void QOpenGLFunctions_4_1_Core_GlDeleteProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDeleteProgram(program);
}
void QOpenGLFunctions_4_1_Core_GlDeleteProgramPipelines5(void* ptr, int n, unsigned int pipelines)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDeleteProgramPipelines(n, const_cast<const GLuint*>(&pipelines));
}
void QOpenGLFunctions_4_1_Core_GlDeleteQueries5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDeleteQueries(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_4_1_Core_GlDeleteRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDeleteRenderbuffers(n, const_cast<const GLuint*>(&renderbuffers));
}
void QOpenGLFunctions_4_1_Core_GlDeleteSamplers5(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDeleteSamplers(count, const_cast<const GLuint*>(&samplers));
}
void QOpenGLFunctions_4_1_Core_GlDeleteShader5(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDeleteShader(shader);
}
void QOpenGLFunctions_4_1_Core_GlDeleteTextures5(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_4_1_Core_GlDeleteTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDeleteTransformFeedbacks(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_4_1_Core_GlDeleteVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDeleteVertexArrays(n, const_cast<const GLuint*>(&arrays));
}
void QOpenGLFunctions_4_1_Core_GlDepthFunc5(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_4_1_Core_GlDepthMask5(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_4_1_Core_GlDepthRangef5(void* ptr, float n, float fo)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDepthRangef(n, fo);
}
void QOpenGLFunctions_4_1_Core_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDetachShader(program, shader);
}
void QOpenGLFunctions_4_1_Core_GlDisable5(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_4_1_Core_GlDisableVertexAttribArray5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDisableVertexAttribArray(index);
}
void QOpenGLFunctions_4_1_Core_GlDisablei5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDisablei(target, index);
}
void QOpenGLFunctions_4_1_Core_GlDrawArrays5(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_4_1_Core_GlDrawArraysIndirect5(void* ptr, unsigned int mode, void* indirect)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDrawArraysIndirect(mode, indirect);
}
void QOpenGLFunctions_4_1_Core_GlDrawArraysInstanced5(void* ptr, unsigned int mode, int first, int count, int instancecount)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDrawArraysInstanced(mode, first, count, instancecount);
}
void QOpenGLFunctions_4_1_Core_GlDrawBuffer5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDrawBuffer(mode);
}
void QOpenGLFunctions_4_1_Core_GlDrawBuffers5(void* ptr, int n, unsigned int bufs)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDrawBuffers(n, const_cast<const GLenum*>(&bufs));
}
void QOpenGLFunctions_4_1_Core_GlDrawElements5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_4_1_Core_GlDrawElementsBaseVertex5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDrawElementsBaseVertex(mode, count, ty, indices, basevertex);
}
void QOpenGLFunctions_4_1_Core_GlDrawElementsIndirect5(void* ptr, unsigned int mode, unsigned int ty, void* indirect)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDrawElementsIndirect(mode, ty, indirect);
}
void QOpenGLFunctions_4_1_Core_GlDrawElementsInstanced5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDrawElementsInstanced(mode, count, ty, indices, instancecount);
}
void QOpenGLFunctions_4_1_Core_GlDrawElementsInstancedBaseVertex5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDrawElementsInstancedBaseVertex(mode, count, ty, indices, instancecount, basevertex);
}
void QOpenGLFunctions_4_1_Core_GlDrawRangeElements5(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLFunctions_4_1_Core_GlDrawRangeElementsBaseVertex5(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDrawRangeElementsBaseVertex(mode, start, end, count, ty, indices, basevertex);
}
void QOpenGLFunctions_4_1_Core_GlDrawTransformFeedback5(void* ptr, unsigned int mode, unsigned int id)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDrawTransformFeedback(mode, id);
}
void QOpenGLFunctions_4_1_Core_GlDrawTransformFeedbackStream5(void* ptr, unsigned int mode, unsigned int id, unsigned int stream)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDrawTransformFeedbackStream(mode, id, stream);
}
void QOpenGLFunctions_4_1_Core_GlEnable5(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_4_1_Core_GlEnableVertexAttribArray5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glEnableVertexAttribArray(index);
}
void QOpenGLFunctions_4_1_Core_GlEnablei5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glEnablei(target, index);
}
void QOpenGLFunctions_4_1_Core_GlEndConditionalRender5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glEndConditionalRender();
}
void QOpenGLFunctions_4_1_Core_GlEndQuery5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glEndQuery(target);
}
void QOpenGLFunctions_4_1_Core_GlEndQueryIndexed5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glEndQueryIndexed(target, index);
}
void QOpenGLFunctions_4_1_Core_GlEndTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glEndTransformFeedback();
}
void QOpenGLFunctions_4_1_Core_GlFinish5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glFinish();
}
void QOpenGLFunctions_4_1_Core_GlFlush5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glFlush();
}
void QOpenGLFunctions_4_1_Core_GlFramebufferRenderbuffer5(void* ptr, unsigned int target, unsigned int attachment, unsigned int renderbuffertarget, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
void QOpenGLFunctions_4_1_Core_GlFramebufferTexture5(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glFramebufferTexture(target, attachment, texture, level);
}
void QOpenGLFunctions_4_1_Core_GlFramebufferTexture1D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glFramebufferTexture1D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_4_1_Core_GlFramebufferTexture2D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_4_1_Core_GlFramebufferTexture3D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level, int zoffset)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}
void QOpenGLFunctions_4_1_Core_GlFramebufferTextureLayer5(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level, int layer)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glFramebufferTextureLayer(target, attachment, texture, level, layer);
}
void QOpenGLFunctions_4_1_Core_GlFrontFace5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_4_1_Core_GlGenBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGenBuffers(n, &buffers);
}
void QOpenGLFunctions_4_1_Core_GlGenFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGenFramebuffers(n, &framebuffers);
}
void QOpenGLFunctions_4_1_Core_GlGenProgramPipelines5(void* ptr, int n, unsigned int pipelines)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGenProgramPipelines(n, &pipelines);
}
void QOpenGLFunctions_4_1_Core_GlGenQueries5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGenQueries(n, &ids);
}
void QOpenGLFunctions_4_1_Core_GlGenRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGenRenderbuffers(n, &renderbuffers);
}
void QOpenGLFunctions_4_1_Core_GlGenSamplers5(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGenSamplers(count, &samplers);
}
void QOpenGLFunctions_4_1_Core_GlGenTextures5(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_4_1_Core_GlGenTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGenTransformFeedbacks(n, &ids);
}
void QOpenGLFunctions_4_1_Core_GlGenVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGenVertexArrays(n, &arrays);
}
void QOpenGLFunctions_4_1_Core_GlGenerateMipmap5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGenerateMipmap(target);
}
void QOpenGLFunctions_4_1_Core_GlGetActiveSubroutineUniformiv5(void* ptr, unsigned int program, unsigned int shadertype, unsigned int index, unsigned int pname, int values)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetActiveSubroutineUniformiv(program, shadertype, index, pname, &values);
}
void QOpenGLFunctions_4_1_Core_GlGetActiveUniformBlockiv5(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetActiveUniformsiv5(void* ptr, unsigned int program, int uniformCount, unsigned int uniformIndices, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetActiveUniformsiv(program, uniformCount, const_cast<const GLuint*>(&uniformIndices), pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetAttachedShaders5(void* ptr, unsigned int program, int maxCount, int count, unsigned int obj)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetAttachedShaders(program, maxCount, &count, &obj);
}
void QOpenGLFunctions_4_1_Core_GlGetBooleani_v5(void* ptr, unsigned int target, unsigned int index, char data)
{
Q_UNUSED(data);
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetBooleani_v(target, index, NULL);
}
void QOpenGLFunctions_4_1_Core_GlGetBooleanv5(void* ptr, unsigned int pname, char params)
{
Q_UNUSED(params);
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_4_1_Core_GlGetBufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetBufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetBufferPointerv5(void* ptr, unsigned int target, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetBufferPointerv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetCompressedTexImage5(void* ptr, unsigned int target, int level, void* img)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetCompressedTexImage(target, level, img);
}
void QOpenGLFunctions_4_1_Core_GlGetFloati_v5(void* ptr, unsigned int target, unsigned int index, float data)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetFloati_v(target, index, &data);
}
void QOpenGLFunctions_4_1_Core_GlGetFloatv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetFloatv(pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetFramebufferAttachmentParameteriv5(void* ptr, unsigned int target, unsigned int attachment, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetFramebufferAttachmentParameteriv(target, attachment, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetIntegeri_v5(void* ptr, unsigned int target, unsigned int index, int data)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetIntegeri_v(target, index, &data);
}
void QOpenGLFunctions_4_1_Core_GlGetIntegerv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetIntegerv(pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetMultisamplefv5(void* ptr, unsigned int pname, unsigned int index, float val)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetMultisamplefv(pname, index, &val);
}
void QOpenGLFunctions_4_1_Core_GlGetPointerv5(void* ptr, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetPointerv(pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetProgramBinary5(void* ptr, unsigned int program, int bufSize, int length, unsigned int binaryFormat, void* binary)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetProgramBinary(program, bufSize, &length, &binaryFormat, binary);
}
void QOpenGLFunctions_4_1_Core_GlGetProgramPipelineiv5(void* ptr, unsigned int pipeline, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetProgramPipelineiv(pipeline, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetProgramStageiv5(void* ptr, unsigned int program, unsigned int shadertype, unsigned int pname, int values)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetProgramStageiv(program, shadertype, pname, &values);
}
void QOpenGLFunctions_4_1_Core_GlGetProgramiv5(void* ptr, unsigned int program, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetProgramiv(program, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetQueryIndexediv5(void* ptr, unsigned int target, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetQueryIndexediv(target, index, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetQueryObjectiv5(void* ptr, unsigned int id, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetQueryObjectiv(id, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetQueryObjectuiv5(void* ptr, unsigned int id, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetQueryObjectuiv(id, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetQueryiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetQueryiv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetRenderbufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetRenderbufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetSamplerParameterIiv5(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetSamplerParameterIiv(sampler, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetSamplerParameterIuiv5(void* ptr, unsigned int sampler, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetSamplerParameterIuiv(sampler, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetSamplerParameterfv5(void* ptr, unsigned int sampler, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetSamplerParameterfv(sampler, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetSamplerParameteriv5(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetSamplerParameteriv(sampler, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetShaderPrecisionFormat5(void* ptr, unsigned int shadertype, unsigned int precisiontype, int ran, int precision)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetShaderPrecisionFormat(shadertype, precisiontype, &ran, &precision);
}
void QOpenGLFunctions_4_1_Core_GlGetShaderiv5(void* ptr, unsigned int shader, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetShaderiv(shader, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetTexImage5(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_4_1_Core_GlGetTexLevelParameterfv5(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetTexLevelParameteriv5(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetTexParameterIiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetTexParameterIiv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetTexParameterIuiv5(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetTexParameterIuiv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetTexParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetTexParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetUniformSubroutineuiv5(void* ptr, unsigned int shadertype, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetUniformSubroutineuiv(shadertype, location, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetUniformfv5(void* ptr, unsigned int program, int location, float params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetUniformfv(program, location, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetUniformiv5(void* ptr, unsigned int program, int location, int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetUniformiv(program, location, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetUniformuiv5(void* ptr, unsigned int program, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetUniformuiv(program, location, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetVertexAttribIiv5(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetVertexAttribIiv(index, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetVertexAttribIuiv5(void* ptr, unsigned int index, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetVertexAttribIuiv(index, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetVertexAttribPointerv5(void* ptr, unsigned int index, unsigned int pname, void* pointer)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetVertexAttribPointerv(index, pname, &pointer);
}
void QOpenGLFunctions_4_1_Core_GlGetVertexAttribfv5(void* ptr, unsigned int index, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetVertexAttribfv(index, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlGetVertexAttribiv5(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glGetVertexAttribiv(index, pname, &params);
}
void QOpenGLFunctions_4_1_Core_GlHint5(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_4_1_Core_GlIndexub5(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glIndexub(*static_cast<GLubyte*>(static_cast<void*>(c)));
}
void QOpenGLFunctions_4_1_Core_GlIndexubv5(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glIndexubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(c))));
}
void QOpenGLFunctions_4_1_Core_GlLineWidth5(void* ptr, float width)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_4_1_Core_GlLinkProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glLinkProgram(program);
}
void QOpenGLFunctions_4_1_Core_GlLogicOp5(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_4_1_Core_GlMinSampleShading5(void* ptr, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glMinSampleShading(value);
}
void QOpenGLFunctions_4_1_Core_GlMultiDrawArrays5(void* ptr, unsigned int mode, int first, int count, int drawcount)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glMultiDrawArrays(mode, const_cast<const GLint*>(&first), const_cast<const GLsizei*>(&count), drawcount);
}
void QOpenGLFunctions_4_1_Core_GlMultiTexCoordP1ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glMultiTexCoordP1ui(texture, ty, coords);
}
void QOpenGLFunctions_4_1_Core_GlMultiTexCoordP1uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glMultiTexCoordP1uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_1_Core_GlMultiTexCoordP2ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glMultiTexCoordP2ui(texture, ty, coords);
}
void QOpenGLFunctions_4_1_Core_GlMultiTexCoordP2uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glMultiTexCoordP2uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_1_Core_GlMultiTexCoordP3ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glMultiTexCoordP3ui(texture, ty, coords);
}
void QOpenGLFunctions_4_1_Core_GlMultiTexCoordP3uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glMultiTexCoordP3uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_1_Core_GlMultiTexCoordP4ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glMultiTexCoordP4ui(texture, ty, coords);
}
void QOpenGLFunctions_4_1_Core_GlMultiTexCoordP4uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glMultiTexCoordP4uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_1_Core_GlNormalP3ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glNormalP3ui(ty, coords);
}
void QOpenGLFunctions_4_1_Core_GlNormalP3uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glNormalP3uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_1_Core_GlPatchParameterfv5(void* ptr, unsigned int pname, float values)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glPatchParameterfv(pname, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_4_1_Core_GlPatchParameteri5(void* ptr, unsigned int pname, int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glPatchParameteri(pname, value);
}
void QOpenGLFunctions_4_1_Core_GlPauseTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glPauseTransformFeedback();
}
void QOpenGLFunctions_4_1_Core_GlPixelStoref5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_4_1_Core_GlPixelStorei5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_4_1_Core_GlPointParameterf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glPointParameterf(pname, param);
}
void QOpenGLFunctions_4_1_Core_GlPointParameterfv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glPointParameterfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_1_Core_GlPointParameteri5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glPointParameteri(pname, param);
}
void QOpenGLFunctions_4_1_Core_GlPointParameteriv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glPointParameteriv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_1_Core_GlPointSize5(void* ptr, float size)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_4_1_Core_GlPolygonMode5(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_4_1_Core_GlPolygonOffset5(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_4_1_Core_GlPrimitiveRestartIndex5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glPrimitiveRestartIndex(index);
}
void QOpenGLFunctions_4_1_Core_GlProgramBinary5(void* ptr, unsigned int program, unsigned int binaryFormat, void* binary, int length)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramBinary(program, binaryFormat, binary, length);
}
void QOpenGLFunctions_4_1_Core_GlProgramParameteri5(void* ptr, unsigned int program, unsigned int pname, int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramParameteri(program, pname, value);
}
void QOpenGLFunctions_4_1_Core_GlProgramUniform1f5(void* ptr, unsigned int program, int location, float v0)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniform1f(program, location, v0);
}
void QOpenGLFunctions_4_1_Core_GlProgramUniform1fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniform1fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlProgramUniform1i5(void* ptr, unsigned int program, int location, int v0)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniform1i(program, location, v0);
}
void QOpenGLFunctions_4_1_Core_GlProgramUniform1iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniform1iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlProgramUniform1ui5(void* ptr, unsigned int program, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniform1ui(program, location, v0);
}
void QOpenGLFunctions_4_1_Core_GlProgramUniform1uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniform1uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlProgramUniform2f5(void* ptr, unsigned int program, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniform2f(program, location, v0, v1);
}
void QOpenGLFunctions_4_1_Core_GlProgramUniform2fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniform2fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlProgramUniform2i5(void* ptr, unsigned int program, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniform2i(program, location, v0, v1);
}
void QOpenGLFunctions_4_1_Core_GlProgramUniform2iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniform2iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlProgramUniform2ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniform2ui(program, location, v0, v1);
}
void QOpenGLFunctions_4_1_Core_GlProgramUniform2uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniform2uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlProgramUniform3f5(void* ptr, unsigned int program, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniform3f(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_1_Core_GlProgramUniform3fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniform3fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlProgramUniform3i5(void* ptr, unsigned int program, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniform3i(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_1_Core_GlProgramUniform3iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniform3iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlProgramUniform3ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniform3ui(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_1_Core_GlProgramUniform3uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniform3uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlProgramUniform4f5(void* ptr, unsigned int program, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniform4f(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_1_Core_GlProgramUniform4fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniform4fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlProgramUniform4i5(void* ptr, unsigned int program, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniform4i(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_1_Core_GlProgramUniform4iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniform4iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlProgramUniform4ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniform4ui(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_1_Core_GlProgramUniform4uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniform4uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlProgramUniformMatrix2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniformMatrix2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlProgramUniformMatrix2x3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniformMatrix2x3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlProgramUniformMatrix2x4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniformMatrix2x4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlProgramUniformMatrix3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniformMatrix3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlProgramUniformMatrix3x2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniformMatrix3x2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlProgramUniformMatrix3x4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniformMatrix3x4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlProgramUniformMatrix4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniformMatrix4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlProgramUniformMatrix4x2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniformMatrix4x2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlProgramUniformMatrix4x3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProgramUniformMatrix4x3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlProvokingVertex5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glProvokingVertex(mode);
}
void QOpenGLFunctions_4_1_Core_GlQueryCounter5(void* ptr, unsigned int id, unsigned int target)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glQueryCounter(id, target);
}
void QOpenGLFunctions_4_1_Core_GlReadBuffer5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glReadBuffer(mode);
}
void QOpenGLFunctions_4_1_Core_GlReadPixels5(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_1_Core_GlReleaseShaderCompiler5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glReleaseShaderCompiler();
}
void QOpenGLFunctions_4_1_Core_GlRenderbufferStorage5(void* ptr, unsigned int target, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glRenderbufferStorage(target, internalformat, width, height);
}
void QOpenGLFunctions_4_1_Core_GlRenderbufferStorageMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
}
void QOpenGLFunctions_4_1_Core_GlResumeTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glResumeTransformFeedback();
}
void QOpenGLFunctions_4_1_Core_GlSampleCoverage5(void* ptr, float value, char invert)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glSampleCoverage(value, invert != 0);
}
void QOpenGLFunctions_4_1_Core_GlSampleMaski5(void* ptr, unsigned int index, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glSampleMaski(index, mask);
}
void QOpenGLFunctions_4_1_Core_GlSamplerParameterIiv5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glSamplerParameterIiv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_1_Core_GlSamplerParameterIuiv5(void* ptr, unsigned int sampler, unsigned int pname, unsigned int param)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glSamplerParameterIuiv(sampler, pname, const_cast<const GLuint*>(&param));
}
void QOpenGLFunctions_4_1_Core_GlSamplerParameterf5(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glSamplerParameterf(sampler, pname, param);
}
void QOpenGLFunctions_4_1_Core_GlSamplerParameterfv5(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glSamplerParameterfv(sampler, pname, const_cast<const GLfloat*>(&param));
}
void QOpenGLFunctions_4_1_Core_GlSamplerParameteri5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glSamplerParameteri(sampler, pname, param);
}
void QOpenGLFunctions_4_1_Core_GlSamplerParameteriv5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glSamplerParameteriv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_1_Core_GlScissor5(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_4_1_Core_GlScissorArrayv5(void* ptr, unsigned int first, int count, int v)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glScissorArrayv(first, count, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Core_GlScissorIndexed5(void* ptr, unsigned int index, int left, int bottom, int width, int height)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glScissorIndexed(index, left, bottom, width, height);
}
void QOpenGLFunctions_4_1_Core_GlScissorIndexedv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glScissorIndexedv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_1_Core_GlSecondaryColorP3ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glSecondaryColorP3ui(ty, color);
}
void QOpenGLFunctions_4_1_Core_GlSecondaryColorP3uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glSecondaryColorP3uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_1_Core_GlShaderBinary5(void* ptr, int count, unsigned int shaders, unsigned int binaryformat, void* binary, int length)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glShaderBinary(count, const_cast<const GLuint*>(&shaders), binaryformat, binary, length);
}
void QOpenGLFunctions_4_1_Core_GlStencilFunc5(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_4_1_Core_GlStencilFuncSeparate5(void* ptr, unsigned int face, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glStencilFuncSeparate(face, fu, ref, mask);
}
void QOpenGLFunctions_4_1_Core_GlStencilMask5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_4_1_Core_GlStencilMaskSeparate5(void* ptr, unsigned int face, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glStencilMaskSeparate(face, mask);
}
void QOpenGLFunctions_4_1_Core_GlStencilOp5(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_4_1_Core_GlStencilOpSeparate5(void* ptr, unsigned int face, unsigned int sfail, unsigned int dpfail, unsigned int dppass)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glStencilOpSeparate(face, sfail, dpfail, dppass);
}
void QOpenGLFunctions_4_1_Core_GlTexBuffer5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glTexBuffer(target, internalformat, buffer);
}
void QOpenGLFunctions_4_1_Core_GlTexCoordP1ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glTexCoordP1ui(ty, coords);
}
void QOpenGLFunctions_4_1_Core_GlTexCoordP1uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glTexCoordP1uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_1_Core_GlTexCoordP2ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glTexCoordP2ui(ty, coords);
}
void QOpenGLFunctions_4_1_Core_GlTexCoordP2uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glTexCoordP2uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_1_Core_GlTexCoordP3ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glTexCoordP3ui(ty, coords);
}
void QOpenGLFunctions_4_1_Core_GlTexCoordP3uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glTexCoordP3uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_1_Core_GlTexCoordP4ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glTexCoordP4ui(ty, coords);
}
void QOpenGLFunctions_4_1_Core_GlTexCoordP4uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glTexCoordP4uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_1_Core_GlTexImage1D5(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_4_1_Core_GlTexImage2D5(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_4_1_Core_GlTexImage2DMultisample5(void* ptr, unsigned int target, int samples, int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_1_Core_GlTexImage3D5(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLFunctions_4_1_Core_GlTexImage3DMultisample5(void* ptr, unsigned int target, int samples, int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_1_Core_GlTexParameterIiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glTexParameterIiv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_1_Core_GlTexParameterIuiv5(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glTexParameterIuiv(target, pname, const_cast<const GLuint*>(&params));
}
void QOpenGLFunctions_4_1_Core_GlTexParameterf5(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_4_1_Core_GlTexParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_1_Core_GlTexParameteri5(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_4_1_Core_GlTexParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_1_Core_GlTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_4_1_Core_GlTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_1_Core_GlTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_4_1_Core_GlUniform1f5(void* ptr, int location, float v0)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniform1f(location, v0);
}
void QOpenGLFunctions_4_1_Core_GlUniform1fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniform1fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlUniform1i5(void* ptr, int location, int v0)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniform1i(location, v0);
}
void QOpenGLFunctions_4_1_Core_GlUniform1iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniform1iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlUniform1ui5(void* ptr, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniform1ui(location, v0);
}
void QOpenGLFunctions_4_1_Core_GlUniform1uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniform1uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlUniform2f5(void* ptr, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniform2f(location, v0, v1);
}
void QOpenGLFunctions_4_1_Core_GlUniform2fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniform2fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlUniform2i5(void* ptr, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniform2i(location, v0, v1);
}
void QOpenGLFunctions_4_1_Core_GlUniform2iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniform2iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlUniform2ui5(void* ptr, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniform2ui(location, v0, v1);
}
void QOpenGLFunctions_4_1_Core_GlUniform2uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniform2uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlUniform3f5(void* ptr, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniform3f(location, v0, v1, v2);
}
void QOpenGLFunctions_4_1_Core_GlUniform3fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniform3fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlUniform3i5(void* ptr, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniform3i(location, v0, v1, v2);
}
void QOpenGLFunctions_4_1_Core_GlUniform3iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniform3iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlUniform3ui5(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniform3ui(location, v0, v1, v2);
}
void QOpenGLFunctions_4_1_Core_GlUniform3uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniform3uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlUniform4f5(void* ptr, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniform4f(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_1_Core_GlUniform4fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniform4fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlUniform4i5(void* ptr, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniform4i(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_1_Core_GlUniform4iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniform4iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlUniform4ui5(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniform4ui(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_1_Core_GlUniform4uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniform4uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlUniformBlockBinding5(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int uniformBlockBinding)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}
void QOpenGLFunctions_4_1_Core_GlUniformMatrix2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniformMatrix2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlUniformMatrix2x3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniformMatrix2x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlUniformMatrix2x4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniformMatrix2x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlUniformMatrix3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniformMatrix3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlUniformMatrix3x2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniformMatrix3x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlUniformMatrix3x4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniformMatrix3x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlUniformMatrix4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniformMatrix4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlUniformMatrix4x2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniformMatrix4x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlUniformMatrix4x3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniformMatrix4x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlUniformSubroutinesuiv5(void* ptr, unsigned int shadertype, int count, unsigned int indices)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUniformSubroutinesuiv(shadertype, count, const_cast<const GLuint*>(&indices));
}
void QOpenGLFunctions_4_1_Core_GlUseProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUseProgram(program);
}
void QOpenGLFunctions_4_1_Core_GlUseProgramStages5(void* ptr, unsigned int pipeline, unsigned int stages, unsigned int program)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glUseProgramStages(pipeline, stages, program);
}
void QOpenGLFunctions_4_1_Core_GlValidateProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glValidateProgram(program);
}
void QOpenGLFunctions_4_1_Core_GlValidateProgramPipeline5(void* ptr, unsigned int pipeline)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glValidateProgramPipeline(pipeline);
}
void QOpenGLFunctions_4_1_Core_GlVertexAttribDivisor5(void* ptr, unsigned int index, unsigned int divisor)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glVertexAttribDivisor(index, divisor);
}
void QOpenGLFunctions_4_1_Core_GlVertexAttribIPointer5(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glVertexAttribIPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_4_1_Core_GlVertexAttribLPointer5(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glVertexAttribLPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_4_1_Core_GlVertexAttribP1ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glVertexAttribP1ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_1_Core_GlVertexAttribP1uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glVertexAttribP1uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlVertexAttribP2ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glVertexAttribP2ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_1_Core_GlVertexAttribP2uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glVertexAttribP2uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlVertexAttribP3ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glVertexAttribP3ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_1_Core_GlVertexAttribP3uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glVertexAttribP3uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlVertexAttribP4ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glVertexAttribP4ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_1_Core_GlVertexAttribP4uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glVertexAttribP4uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlVertexAttribPointer5(void* ptr, unsigned int index, int size, unsigned int ty, char normalized, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glVertexAttribPointer(index, size, ty, normalized != 0, stride, pointer);
}
void QOpenGLFunctions_4_1_Core_GlVertexP2ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glVertexP2ui(ty, value);
}
void QOpenGLFunctions_4_1_Core_GlVertexP2uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glVertexP2uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlVertexP3ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glVertexP3ui(ty, value);
}
void QOpenGLFunctions_4_1_Core_GlVertexP3uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glVertexP3uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlVertexP4ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glVertexP4ui(ty, value);
}
void QOpenGLFunctions_4_1_Core_GlVertexP4uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glVertexP4uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_1_Core_GlViewport5(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_4_1_Core_GlViewportArrayv5(void* ptr, unsigned int first, int count, float v)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glViewportArrayv(first, count, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Core_GlViewportIndexedf5(void* ptr, unsigned int index, float x, float y, float w, float h)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glViewportIndexedf(index, x, y, w, h);
}
void QOpenGLFunctions_4_1_Core_GlViewportIndexedfv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glViewportIndexedfv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_1_Core_DestroyQOpenGLFunctions_4_1_Core5(void* ptr)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->~QOpenGLFunctions_4_1_Core();
}
void QOpenGLFunctions_4_1_Core_DestroyQOpenGLFunctions_4_1_Core5Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_4_2_Compatibility: public QOpenGLFunctions_4_2_Compatibility
{
public:
MyQOpenGLFunctions_4_2_Compatibility() : QOpenGLFunctions_4_2_Compatibility() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_4_2_Compatibility_InitializeOpenGLFunctions5(this) != 0; };
~MyQOpenGLFunctions_4_2_Compatibility() { callbackQOpenGLFunctions_4_2_Compatibility_DestroyQOpenGLFunctions_4_2_Compatibility5(this); };
};
char QOpenGLFunctions_4_2_Compatibility_GlAreTexturesResident5(void* ptr, int n, unsigned int textures, char residences)
{
Q_UNUSED(residences);
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glAreTexturesResident(n, const_cast<const GLuint*>(&textures), NULL);
}
char QOpenGLFunctions_4_2_Compatibility_GlIsBuffer5(void* ptr, unsigned int buffer)
{
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glIsBuffer(buffer);
}
char QOpenGLFunctions_4_2_Compatibility_GlIsEnabled5(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_4_2_Compatibility_GlIsEnabledi5(void* ptr, unsigned int target, unsigned int index)
{
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glIsEnabledi(target, index);
}
char QOpenGLFunctions_4_2_Compatibility_GlIsFramebuffer5(void* ptr, unsigned int framebuffer)
{
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glIsFramebuffer(framebuffer);
}
char QOpenGLFunctions_4_2_Compatibility_GlIsList5(void* ptr, unsigned int list)
{
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glIsList(list);
}
char QOpenGLFunctions_4_2_Compatibility_GlIsProgram5(void* ptr, unsigned int program)
{
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glIsProgram(program);
}
char QOpenGLFunctions_4_2_Compatibility_GlIsProgramPipeline5(void* ptr, unsigned int pipeline)
{
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glIsProgramPipeline(pipeline);
}
char QOpenGLFunctions_4_2_Compatibility_GlIsQuery5(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glIsQuery(id);
}
char QOpenGLFunctions_4_2_Compatibility_GlIsRenderbuffer5(void* ptr, unsigned int renderbuffer)
{
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glIsRenderbuffer(renderbuffer);
}
char QOpenGLFunctions_4_2_Compatibility_GlIsSampler5(void* ptr, unsigned int sampler)
{
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glIsSampler(sampler);
}
char QOpenGLFunctions_4_2_Compatibility_GlIsShader5(void* ptr, unsigned int shader)
{
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glIsShader(shader);
}
char QOpenGLFunctions_4_2_Compatibility_GlIsTexture5(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glIsTexture(texture);
}
char QOpenGLFunctions_4_2_Compatibility_GlIsTransformFeedback5(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glIsTransformFeedback(id);
}
char QOpenGLFunctions_4_2_Compatibility_GlIsVertexArray5(void* ptr, unsigned int array)
{
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glIsVertexArray(array);
}
char QOpenGLFunctions_4_2_Compatibility_GlUnmapBuffer5(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUnmapBuffer(target);
}
unsigned int QOpenGLFunctions_4_2_Compatibility_GlCheckFramebufferStatus5(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glCheckFramebufferStatus(target);
}
unsigned int QOpenGLFunctions_4_2_Compatibility_GlGetError5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetError();
}
int QOpenGLFunctions_4_2_Compatibility_GlRenderMode5(void* ptr, unsigned int mode)
{
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRenderMode(mode);
}
unsigned int QOpenGLFunctions_4_2_Compatibility_GlCreateProgram5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glCreateProgram();
}
unsigned int QOpenGLFunctions_4_2_Compatibility_GlCreateShader5(void* ptr, unsigned int ty)
{
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glCreateShader(ty);
}
unsigned int QOpenGLFunctions_4_2_Compatibility_GlGenLists5(void* ptr, int ran)
{
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGenLists(ran);
}
void* QOpenGLFunctions_4_2_Compatibility_GlMapBuffer5(void* ptr, unsigned int target, unsigned int access)
{
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMapBuffer(target, access);
}
void* QOpenGLFunctions_4_2_Compatibility_NewQOpenGLFunctions_4_2_Compatibility5()
{
return new MyQOpenGLFunctions_4_2_Compatibility();
}
char QOpenGLFunctions_4_2_Compatibility_InitializeOpenGLFunctions5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_4_2_Compatibility_InitializeOpenGLFunctions5Default(void* ptr)
{
return static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->QOpenGLFunctions_4_2_Compatibility::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_4_2_Compatibility_GlGetString5(void* ptr, unsigned int name)
{
return ({ char* t734eb9 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetString(name)))); QtGui_PackedString { t734eb9, -1 }; });
}
struct QtGui_PackedString QOpenGLFunctions_4_2_Compatibility_GlGetStringi5(void* ptr, unsigned int name, unsigned int index)
{
return ({ char* tc900e0 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetStringi(name, index)))); QtGui_PackedString { tc900e0, -1 }; });
}
void QOpenGLFunctions_4_2_Compatibility_GlAccum5(void* ptr, unsigned int op, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glAccum(op, value);
}
void QOpenGLFunctions_4_2_Compatibility_GlActiveShaderProgram5(void* ptr, unsigned int pipeline, unsigned int program)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glActiveShaderProgram(pipeline, program);
}
void QOpenGLFunctions_4_2_Compatibility_GlActiveTexture5(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glActiveTexture(texture);
}
void QOpenGLFunctions_4_2_Compatibility_GlAlphaFunc5(void* ptr, unsigned int fu, float ref)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glAlphaFunc(fu, ref);
}
void QOpenGLFunctions_4_2_Compatibility_GlArrayElement5(void* ptr, int i)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glArrayElement(i);
}
void QOpenGLFunctions_4_2_Compatibility_GlAttachShader5(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glAttachShader(program, shader);
}
void QOpenGLFunctions_4_2_Compatibility_GlBegin5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBegin(mode);
}
void QOpenGLFunctions_4_2_Compatibility_GlBeginConditionalRender5(void* ptr, unsigned int id, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBeginConditionalRender(id, mode);
}
void QOpenGLFunctions_4_2_Compatibility_GlBeginQuery5(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBeginQuery(target, id);
}
void QOpenGLFunctions_4_2_Compatibility_GlBeginQueryIndexed5(void* ptr, unsigned int target, unsigned int index, unsigned int id)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBeginQueryIndexed(target, index, id);
}
void QOpenGLFunctions_4_2_Compatibility_GlBeginTransformFeedback5(void* ptr, unsigned int primitiveMode)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBeginTransformFeedback(primitiveMode);
}
void QOpenGLFunctions_4_2_Compatibility_GlBindBuffer5(void* ptr, unsigned int target, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBindBuffer(target, buffer);
}
void QOpenGLFunctions_4_2_Compatibility_GlBindBufferBase5(void* ptr, unsigned int target, unsigned int index, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBindBufferBase(target, index, buffer);
}
void QOpenGLFunctions_4_2_Compatibility_GlBindFramebuffer5(void* ptr, unsigned int target, unsigned int framebuffer)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBindFramebuffer(target, framebuffer);
}
void QOpenGLFunctions_4_2_Compatibility_GlBindImageTexture5(void* ptr, unsigned int unit, unsigned int texture, int level, char layered, int layer, unsigned int access, unsigned int format)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBindImageTexture(unit, texture, level, layered != 0, layer, access, format);
}
void QOpenGLFunctions_4_2_Compatibility_GlBindProgramPipeline5(void* ptr, unsigned int pipeline)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBindProgramPipeline(pipeline);
}
void QOpenGLFunctions_4_2_Compatibility_GlBindRenderbuffer5(void* ptr, unsigned int target, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBindRenderbuffer(target, renderbuffer);
}
void QOpenGLFunctions_4_2_Compatibility_GlBindSampler5(void* ptr, unsigned int unit, unsigned int sampler)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBindSampler(unit, sampler);
}
void QOpenGLFunctions_4_2_Compatibility_GlBindTexture5(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_4_2_Compatibility_GlBindTransformFeedback5(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBindTransformFeedback(target, id);
}
void QOpenGLFunctions_4_2_Compatibility_GlBindVertexArray5(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBindVertexArray(array);
}
void QOpenGLFunctions_4_2_Compatibility_GlBitmap5(void* ptr, int width, int height, float xorig, float yorig, float xmove, float ymove, char* bitmap)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBitmap(width, height, xorig, yorig, xmove, ymove, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(bitmap))));
}
void QOpenGLFunctions_4_2_Compatibility_GlBlendColor5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_4_2_Compatibility_GlBlendEquation5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_4_2_Compatibility_GlBlendEquationSeparate5(void* ptr, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBlendEquationSeparate(modeRGB, modeAlpha);
}
void QOpenGLFunctions_4_2_Compatibility_GlBlendEquationSeparatei5(void* ptr, unsigned int buf, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBlendEquationSeparatei(buf, modeRGB, modeAlpha);
}
void QOpenGLFunctions_4_2_Compatibility_GlBlendEquationi5(void* ptr, unsigned int buf, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBlendEquationi(buf, mode);
}
void QOpenGLFunctions_4_2_Compatibility_GlBlendFunc5(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_4_2_Compatibility_GlBlendFuncSeparate5(void* ptr, unsigned int sfactorRGB, unsigned int dfactorRGB, unsigned int sfactorAlpha, unsigned int dfactorAlpha)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void QOpenGLFunctions_4_2_Compatibility_GlBlendFuncSeparatei5(void* ptr, unsigned int buf, unsigned int srcRGB, unsigned int dstRGB, unsigned int srcAlpha, unsigned int dstAlpha)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
void QOpenGLFunctions_4_2_Compatibility_GlBlendFunci5(void* ptr, unsigned int buf, unsigned int src, unsigned int dst)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBlendFunci(buf, src, dst);
}
void QOpenGLFunctions_4_2_Compatibility_GlBlitFramebuffer5(void* ptr, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, unsigned int mask, unsigned int filter)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
void QOpenGLFunctions_4_2_Compatibility_GlCallList5(void* ptr, unsigned int list)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glCallList(list);
}
void QOpenGLFunctions_4_2_Compatibility_GlCallLists5(void* ptr, int n, unsigned int ty, void* lists)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glCallLists(n, ty, lists);
}
void QOpenGLFunctions_4_2_Compatibility_GlClampColor5(void* ptr, unsigned int target, unsigned int clamp)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glClampColor(target, clamp);
}
void QOpenGLFunctions_4_2_Compatibility_GlClear5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_4_2_Compatibility_GlClearAccum5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glClearAccum(red, green, blue, alpha);
}
void QOpenGLFunctions_4_2_Compatibility_GlClearBufferfi5(void* ptr, unsigned int buffer, int drawbuffer, float depth, int stencil)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glClearBufferfi(buffer, drawbuffer, depth, stencil);
}
void QOpenGLFunctions_4_2_Compatibility_GlClearBufferfv5(void* ptr, unsigned int buffer, int drawbuffer, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glClearBufferfv(buffer, drawbuffer, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlClearBufferiv5(void* ptr, unsigned int buffer, int drawbuffer, int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glClearBufferiv(buffer, drawbuffer, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlClearBufferuiv5(void* ptr, unsigned int buffer, int drawbuffer, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glClearBufferuiv(buffer, drawbuffer, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlClearColor5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_4_2_Compatibility_GlClearDepthf5(void* ptr, float dd)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glClearDepthf(dd);
}
void QOpenGLFunctions_4_2_Compatibility_GlClearIndex5(void* ptr, float c)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glClearIndex(c);
}
void QOpenGLFunctions_4_2_Compatibility_GlClearStencil5(void* ptr, int s)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_4_2_Compatibility_GlClientActiveTexture5(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glClientActiveTexture(texture);
}
void QOpenGLFunctions_4_2_Compatibility_GlColor3f5(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColor3f(red, green, blue);
}
void QOpenGLFunctions_4_2_Compatibility_GlColor3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlColor3i5(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColor3i(red, green, blue);
}
void QOpenGLFunctions_4_2_Compatibility_GlColor3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlColor3s5(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColor3s(red, green, blue);
}
void QOpenGLFunctions_4_2_Compatibility_GlColor3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlColor3ub5(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_4_2_Compatibility_GlColor3ubv5(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_2_Compatibility_GlColor3ui5(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColor3ui(red, green, blue);
}
void QOpenGLFunctions_4_2_Compatibility_GlColor3uiv5(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlColor3us5(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColor3us(red, green, blue);
}
void QOpenGLFunctions_4_2_Compatibility_GlColor3usv5(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlColor4f5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColor4f(red, green, blue, alpha);
}
void QOpenGLFunctions_4_2_Compatibility_GlColor4fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColor4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlColor4i5(void* ptr, int red, int green, int blue, int alpha)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColor4i(red, green, blue, alpha);
}
void QOpenGLFunctions_4_2_Compatibility_GlColor4iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColor4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlColor4s5(void* ptr, short red, short green, short blue, short alpha)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColor4s(red, green, blue, alpha);
}
void QOpenGLFunctions_4_2_Compatibility_GlColor4sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColor4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlColor4ub5(void* ptr, char* red, char* green, char* blue, char* alpha)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColor4ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)), *static_cast<GLubyte*>(static_cast<void*>(alpha)));
}
void QOpenGLFunctions_4_2_Compatibility_GlColor4ubv5(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColor4ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_2_Compatibility_GlColor4ui5(void* ptr, unsigned int red, unsigned int green, unsigned int blue, unsigned int alpha)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColor4ui(red, green, blue, alpha);
}
void QOpenGLFunctions_4_2_Compatibility_GlColor4uiv5(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColor4uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlColor4us5(void* ptr, unsigned short red, unsigned short green, unsigned short blue, unsigned short alpha)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColor4us(red, green, blue, alpha);
}
void QOpenGLFunctions_4_2_Compatibility_GlColor4usv5(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColor4usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlColorMask5(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_4_2_Compatibility_GlColorMaski5(void* ptr, unsigned int index, char r, char g, char b, char a)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColorMaski(index, r != 0, g != 0, b != 0, a != 0);
}
void QOpenGLFunctions_4_2_Compatibility_GlColorMaterial5(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColorMaterial(face, mode);
}
void QOpenGLFunctions_4_2_Compatibility_GlColorP3ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColorP3ui(ty, color);
}
void QOpenGLFunctions_4_2_Compatibility_GlColorP3uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColorP3uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_2_Compatibility_GlColorP4ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColorP4ui(ty, color);
}
void QOpenGLFunctions_4_2_Compatibility_GlColorP4uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColorP4uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_2_Compatibility_GlColorPointer5(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_4_2_Compatibility_GlColorSubTable5(void* ptr, unsigned int target, int start, int count, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColorSubTable(target, start, count, format, ty, data);
}
void QOpenGLFunctions_4_2_Compatibility_GlColorTable5(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColorTable(target, internalformat, width, format, ty, table);
}
void QOpenGLFunctions_4_2_Compatibility_GlColorTableParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColorTableParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_2_Compatibility_GlColorTableParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glColorTableParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_2_Compatibility_GlCompileShader5(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glCompileShader(shader);
}
void QOpenGLFunctions_4_2_Compatibility_GlCompressedTexImage1D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
void QOpenGLFunctions_4_2_Compatibility_GlCompressedTexImage2D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void QOpenGLFunctions_4_2_Compatibility_GlCompressedTexImage3D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int depth, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void QOpenGLFunctions_4_2_Compatibility_GlCompressedTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_4_2_Compatibility_GlCompressedTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_4_2_Compatibility_GlCompressedTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_4_2_Compatibility_GlConvolutionFilter1D5(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glConvolutionFilter1D(target, internalformat, width, format, ty, image);
}
void QOpenGLFunctions_4_2_Compatibility_GlConvolutionFilter2D5(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glConvolutionFilter2D(target, internalformat, width, height, format, ty, image);
}
void QOpenGLFunctions_4_2_Compatibility_GlConvolutionParameterf5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glConvolutionParameterf(target, pname, params);
}
void QOpenGLFunctions_4_2_Compatibility_GlConvolutionParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glConvolutionParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_2_Compatibility_GlConvolutionParameteri5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glConvolutionParameteri(target, pname, params);
}
void QOpenGLFunctions_4_2_Compatibility_GlConvolutionParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glConvolutionParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_2_Compatibility_GlCopyColorSubTable5(void* ptr, unsigned int target, int start, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glCopyColorSubTable(target, start, x, y, width);
}
void QOpenGLFunctions_4_2_Compatibility_GlCopyColorTable5(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glCopyColorTable(target, internalformat, x, y, width);
}
void QOpenGLFunctions_4_2_Compatibility_GlCopyConvolutionFilter1D5(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glCopyConvolutionFilter1D(target, internalformat, x, y, width);
}
void QOpenGLFunctions_4_2_Compatibility_GlCopyConvolutionFilter2D5(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);
}
void QOpenGLFunctions_4_2_Compatibility_GlCopyPixels5(void* ptr, int x, int y, int width, int height, unsigned int ty)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glCopyPixels(x, y, width, height, ty);
}
void QOpenGLFunctions_4_2_Compatibility_GlCopyTexImage1D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_4_2_Compatibility_GlCopyTexImage2D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_4_2_Compatibility_GlCopyTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_4_2_Compatibility_GlCopyTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_4_2_Compatibility_GlCopyTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_4_2_Compatibility_GlCullFace5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_4_2_Compatibility_GlDeleteBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDeleteBuffers(n, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_4_2_Compatibility_GlDeleteFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDeleteFramebuffers(n, const_cast<const GLuint*>(&framebuffers));
}
void QOpenGLFunctions_4_2_Compatibility_GlDeleteLists5(void* ptr, unsigned int list, int ran)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDeleteLists(list, ran);
}
void QOpenGLFunctions_4_2_Compatibility_GlDeleteProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDeleteProgram(program);
}
void QOpenGLFunctions_4_2_Compatibility_GlDeleteProgramPipelines5(void* ptr, int n, unsigned int pipelines)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDeleteProgramPipelines(n, const_cast<const GLuint*>(&pipelines));
}
void QOpenGLFunctions_4_2_Compatibility_GlDeleteQueries5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDeleteQueries(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_4_2_Compatibility_GlDeleteRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDeleteRenderbuffers(n, const_cast<const GLuint*>(&renderbuffers));
}
void QOpenGLFunctions_4_2_Compatibility_GlDeleteSamplers5(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDeleteSamplers(count, const_cast<const GLuint*>(&samplers));
}
void QOpenGLFunctions_4_2_Compatibility_GlDeleteShader5(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDeleteShader(shader);
}
void QOpenGLFunctions_4_2_Compatibility_GlDeleteTextures5(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_4_2_Compatibility_GlDeleteTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDeleteTransformFeedbacks(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_4_2_Compatibility_GlDeleteVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDeleteVertexArrays(n, const_cast<const GLuint*>(&arrays));
}
void QOpenGLFunctions_4_2_Compatibility_GlDepthFunc5(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_4_2_Compatibility_GlDepthMask5(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_4_2_Compatibility_GlDepthRangef5(void* ptr, float n, float fo)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDepthRangef(n, fo);
}
void QOpenGLFunctions_4_2_Compatibility_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDetachShader(program, shader);
}
void QOpenGLFunctions_4_2_Compatibility_GlDisable5(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_4_2_Compatibility_GlDisableClientState5(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDisableClientState(array);
}
void QOpenGLFunctions_4_2_Compatibility_GlDisableVertexAttribArray5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDisableVertexAttribArray(index);
}
void QOpenGLFunctions_4_2_Compatibility_GlDisablei5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDisablei(target, index);
}
void QOpenGLFunctions_4_2_Compatibility_GlDrawArrays5(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_4_2_Compatibility_GlDrawArraysIndirect5(void* ptr, unsigned int mode, void* indirect)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDrawArraysIndirect(mode, indirect);
}
void QOpenGLFunctions_4_2_Compatibility_GlDrawArraysInstanced5(void* ptr, unsigned int mode, int first, int count, int instancecount)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDrawArraysInstanced(mode, first, count, instancecount);
}
void QOpenGLFunctions_4_2_Compatibility_GlDrawArraysInstancedBaseInstance5(void* ptr, unsigned int mode, int first, int count, int instancecount, unsigned int baseinstance)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
}
void QOpenGLFunctions_4_2_Compatibility_GlDrawBuffer5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDrawBuffer(mode);
}
void QOpenGLFunctions_4_2_Compatibility_GlDrawBuffers5(void* ptr, int n, unsigned int bufs)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDrawBuffers(n, const_cast<const GLenum*>(&bufs));
}
void QOpenGLFunctions_4_2_Compatibility_GlDrawElements5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_4_2_Compatibility_GlDrawElementsBaseVertex5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDrawElementsBaseVertex(mode, count, ty, indices, basevertex);
}
void QOpenGLFunctions_4_2_Compatibility_GlDrawElementsIndirect5(void* ptr, unsigned int mode, unsigned int ty, void* indirect)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDrawElementsIndirect(mode, ty, indirect);
}
void QOpenGLFunctions_4_2_Compatibility_GlDrawElementsInstanced5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDrawElementsInstanced(mode, count, ty, indices, instancecount);
}
void QOpenGLFunctions_4_2_Compatibility_GlDrawElementsInstancedBaseInstance5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, unsigned int baseinstance)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDrawElementsInstancedBaseInstance(mode, count, ty, indices, instancecount, baseinstance);
}
void QOpenGLFunctions_4_2_Compatibility_GlDrawElementsInstancedBaseVertex5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDrawElementsInstancedBaseVertex(mode, count, ty, indices, instancecount, basevertex);
}
void QOpenGLFunctions_4_2_Compatibility_GlDrawElementsInstancedBaseVertexBaseInstance5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex, unsigned int baseinstance)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDrawElementsInstancedBaseVertexBaseInstance(mode, count, ty, indices, instancecount, basevertex, baseinstance);
}
void QOpenGLFunctions_4_2_Compatibility_GlDrawPixels5(void* ptr, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDrawPixels(width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_2_Compatibility_GlDrawRangeElements5(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLFunctions_4_2_Compatibility_GlDrawRangeElementsBaseVertex5(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDrawRangeElementsBaseVertex(mode, start, end, count, ty, indices, basevertex);
}
void QOpenGLFunctions_4_2_Compatibility_GlDrawTransformFeedback5(void* ptr, unsigned int mode, unsigned int id)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDrawTransformFeedback(mode, id);
}
void QOpenGLFunctions_4_2_Compatibility_GlDrawTransformFeedbackInstanced5(void* ptr, unsigned int mode, unsigned int id, int instancecount)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDrawTransformFeedbackInstanced(mode, id, instancecount);
}
void QOpenGLFunctions_4_2_Compatibility_GlDrawTransformFeedbackStream5(void* ptr, unsigned int mode, unsigned int id, unsigned int stream)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDrawTransformFeedbackStream(mode, id, stream);
}
void QOpenGLFunctions_4_2_Compatibility_GlDrawTransformFeedbackStreamInstanced5(void* ptr, unsigned int mode, unsigned int id, unsigned int stream, int instancecount)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
}
void QOpenGLFunctions_4_2_Compatibility_GlEdgeFlag5(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glEdgeFlag(flag != 0);
}
void QOpenGLFunctions_4_2_Compatibility_GlEdgeFlagPointer5(void* ptr, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glEdgeFlagPointer(stride, pointer);
}
void QOpenGLFunctions_4_2_Compatibility_GlEdgeFlagv5(void* ptr, char flag)
{
Q_UNUSED(flag);
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glEdgeFlagv(NULL);
}
void QOpenGLFunctions_4_2_Compatibility_GlEnable5(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_4_2_Compatibility_GlEnableClientState5(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glEnableClientState(array);
}
void QOpenGLFunctions_4_2_Compatibility_GlEnableVertexAttribArray5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glEnableVertexAttribArray(index);
}
void QOpenGLFunctions_4_2_Compatibility_GlEnablei5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glEnablei(target, index);
}
void QOpenGLFunctions_4_2_Compatibility_GlEnd5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glEnd();
}
void QOpenGLFunctions_4_2_Compatibility_GlEndConditionalRender5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glEndConditionalRender();
}
void QOpenGLFunctions_4_2_Compatibility_GlEndList5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glEndList();
}
void QOpenGLFunctions_4_2_Compatibility_GlEndQuery5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glEndQuery(target);
}
void QOpenGLFunctions_4_2_Compatibility_GlEndQueryIndexed5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glEndQueryIndexed(target, index);
}
void QOpenGLFunctions_4_2_Compatibility_GlEndTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glEndTransformFeedback();
}
void QOpenGLFunctions_4_2_Compatibility_GlEvalCoord1f5(void* ptr, float u)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glEvalCoord1f(u);
}
void QOpenGLFunctions_4_2_Compatibility_GlEvalCoord1fv5(void* ptr, float u)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glEvalCoord1fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_4_2_Compatibility_GlEvalCoord2f5(void* ptr, float u, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glEvalCoord2f(u, v);
}
void QOpenGLFunctions_4_2_Compatibility_GlEvalCoord2fv5(void* ptr, float u)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glEvalCoord2fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_4_2_Compatibility_GlEvalMesh15(void* ptr, unsigned int mode, int i1, int i2)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glEvalMesh1(mode, i1, i2);
}
void QOpenGLFunctions_4_2_Compatibility_GlEvalMesh25(void* ptr, unsigned int mode, int i1, int i2, int j1, int j2)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glEvalMesh2(mode, i1, i2, j1, j2);
}
void QOpenGLFunctions_4_2_Compatibility_GlEvalPoint15(void* ptr, int i)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glEvalPoint1(i);
}
void QOpenGLFunctions_4_2_Compatibility_GlEvalPoint25(void* ptr, int i, int j)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glEvalPoint2(i, j);
}
void QOpenGLFunctions_4_2_Compatibility_GlFeedbackBuffer5(void* ptr, int size, unsigned int ty, float buffer)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glFeedbackBuffer(size, ty, &buffer);
}
void QOpenGLFunctions_4_2_Compatibility_GlFinish5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glFinish();
}
void QOpenGLFunctions_4_2_Compatibility_GlFlush5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glFlush();
}
void QOpenGLFunctions_4_2_Compatibility_GlFogCoordPointer5(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glFogCoordPointer(ty, stride, pointer);
}
void QOpenGLFunctions_4_2_Compatibility_GlFogCoordf5(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glFogCoordf(coord);
}
void QOpenGLFunctions_4_2_Compatibility_GlFogCoordfv5(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glFogCoordfv(const_cast<const GLfloat*>(&coord));
}
void QOpenGLFunctions_4_2_Compatibility_GlFogf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glFogf(pname, param);
}
void QOpenGLFunctions_4_2_Compatibility_GlFogfv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glFogfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_2_Compatibility_GlFogi5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glFogi(pname, param);
}
void QOpenGLFunctions_4_2_Compatibility_GlFogiv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glFogiv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_2_Compatibility_GlFramebufferRenderbuffer5(void* ptr, unsigned int target, unsigned int attachment, unsigned int renderbuffertarget, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
void QOpenGLFunctions_4_2_Compatibility_GlFramebufferTexture5(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glFramebufferTexture(target, attachment, texture, level);
}
void QOpenGLFunctions_4_2_Compatibility_GlFramebufferTexture1D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glFramebufferTexture1D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_4_2_Compatibility_GlFramebufferTexture2D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_4_2_Compatibility_GlFramebufferTexture3D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level, int zoffset)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}
void QOpenGLFunctions_4_2_Compatibility_GlFramebufferTextureLayer5(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level, int layer)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glFramebufferTextureLayer(target, attachment, texture, level, layer);
}
void QOpenGLFunctions_4_2_Compatibility_GlFrontFace5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_4_2_Compatibility_GlGenBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGenBuffers(n, &buffers);
}
void QOpenGLFunctions_4_2_Compatibility_GlGenFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGenFramebuffers(n, &framebuffers);
}
void QOpenGLFunctions_4_2_Compatibility_GlGenProgramPipelines5(void* ptr, int n, unsigned int pipelines)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGenProgramPipelines(n, &pipelines);
}
void QOpenGLFunctions_4_2_Compatibility_GlGenQueries5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGenQueries(n, &ids);
}
void QOpenGLFunctions_4_2_Compatibility_GlGenRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGenRenderbuffers(n, &renderbuffers);
}
void QOpenGLFunctions_4_2_Compatibility_GlGenSamplers5(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGenSamplers(count, &samplers);
}
void QOpenGLFunctions_4_2_Compatibility_GlGenTextures5(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_4_2_Compatibility_GlGenTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGenTransformFeedbacks(n, &ids);
}
void QOpenGLFunctions_4_2_Compatibility_GlGenVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGenVertexArrays(n, &arrays);
}
void QOpenGLFunctions_4_2_Compatibility_GlGenerateMipmap5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGenerateMipmap(target);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetActiveAtomicCounterBufferiv5(void* ptr, unsigned int program, unsigned int bufferIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetActiveAtomicCounterBufferiv(program, bufferIndex, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetActiveSubroutineUniformiv5(void* ptr, unsigned int program, unsigned int shadertype, unsigned int index, unsigned int pname, int values)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetActiveSubroutineUniformiv(program, shadertype, index, pname, &values);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetActiveUniformBlockiv5(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetActiveUniformsiv5(void* ptr, unsigned int program, int uniformCount, unsigned int uniformIndices, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetActiveUniformsiv(program, uniformCount, const_cast<const GLuint*>(&uniformIndices), pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetAttachedShaders5(void* ptr, unsigned int program, int maxCount, int count, unsigned int obj)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetAttachedShaders(program, maxCount, &count, &obj);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetBooleani_v5(void* ptr, unsigned int target, unsigned int index, char data)
{
Q_UNUSED(data);
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetBooleani_v(target, index, NULL);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetBooleanv5(void* ptr, unsigned int pname, char params)
{
Q_UNUSED(params);
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetBufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetBufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetBufferPointerv5(void* ptr, unsigned int target, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetBufferPointerv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetColorTable5(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetColorTable(target, format, ty, table);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetColorTableParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetColorTableParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetColorTableParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetColorTableParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetCompressedTexImage5(void* ptr, unsigned int target, int level, void* img)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetCompressedTexImage(target, level, img);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetConvolutionFilter5(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetConvolutionFilter(target, format, ty, image);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetConvolutionParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetConvolutionParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetConvolutionParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetConvolutionParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetFloati_v5(void* ptr, unsigned int target, unsigned int index, float data)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetFloati_v(target, index, &data);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetFloatv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetFloatv(pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetFramebufferAttachmentParameteriv5(void* ptr, unsigned int target, unsigned int attachment, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetFramebufferAttachmentParameteriv(target, attachment, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetHistogram5(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetHistogram(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetHistogramParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetHistogramParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetHistogramParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetHistogramParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetIntegeri_v5(void* ptr, unsigned int target, unsigned int index, int data)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetIntegeri_v(target, index, &data);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetIntegerv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetIntegerv(pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetInternalformativ5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int pname, int bufSize, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetInternalformativ(target, internalformat, pname, bufSize, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetLightfv5(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetLightfv(light, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetLightiv5(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetLightiv(light, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetMapfv5(void* ptr, unsigned int target, unsigned int query, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetMapfv(target, query, &v);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetMapiv5(void* ptr, unsigned int target, unsigned int query, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetMapiv(target, query, &v);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetMaterialfv5(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetMaterialfv(face, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetMaterialiv5(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetMaterialiv(face, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetMinmax5(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetMinmax(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetMinmaxParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetMinmaxParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetMinmaxParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetMinmaxParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetMultisamplefv5(void* ptr, unsigned int pname, unsigned int index, float val)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetMultisamplefv(pname, index, &val);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetPixelMapfv5(void* ptr, unsigned int m, float values)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetPixelMapfv(m, &values);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetPixelMapuiv5(void* ptr, unsigned int m, unsigned int values)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetPixelMapuiv(m, &values);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetPixelMapusv5(void* ptr, unsigned int m, unsigned short values)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetPixelMapusv(m, &values);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetPointerv5(void* ptr, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetPointerv(pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetPolygonStipple5(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetPolygonStipple(static_cast<GLubyte*>(static_cast<void*>(mask)));
}
void QOpenGLFunctions_4_2_Compatibility_GlGetProgramBinary5(void* ptr, unsigned int program, int bufSize, int length, unsigned int binaryFormat, void* binary)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetProgramBinary(program, bufSize, &length, &binaryFormat, binary);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetProgramPipelineiv5(void* ptr, unsigned int pipeline, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetProgramPipelineiv(pipeline, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetProgramStageiv5(void* ptr, unsigned int program, unsigned int shadertype, unsigned int pname, int values)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetProgramStageiv(program, shadertype, pname, &values);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetProgramiv5(void* ptr, unsigned int program, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetProgramiv(program, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetQueryIndexediv5(void* ptr, unsigned int target, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetQueryIndexediv(target, index, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetQueryObjectiv5(void* ptr, unsigned int id, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetQueryObjectiv(id, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetQueryObjectuiv5(void* ptr, unsigned int id, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetQueryObjectuiv(id, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetQueryiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetQueryiv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetRenderbufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetRenderbufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetSamplerParameterIiv5(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetSamplerParameterIiv(sampler, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetSamplerParameterIuiv5(void* ptr, unsigned int sampler, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetSamplerParameterIuiv(sampler, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetSamplerParameterfv5(void* ptr, unsigned int sampler, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetSamplerParameterfv(sampler, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetSamplerParameteriv5(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetSamplerParameteriv(sampler, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetSeparableFilter5(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* row, void* column, void* span)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetSeparableFilter(target, format, ty, row, column, span);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetShaderPrecisionFormat5(void* ptr, unsigned int shadertype, unsigned int precisiontype, int ran, int precision)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetShaderPrecisionFormat(shadertype, precisiontype, &ran, &precision);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetShaderiv5(void* ptr, unsigned int shader, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetShaderiv(shader, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetTexEnvfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetTexEnvfv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetTexEnviv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetTexEnviv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetTexGenfv5(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetTexGenfv(coord, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetTexGeniv5(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetTexGeniv(coord, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetTexImage5(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetTexLevelParameterfv5(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetTexLevelParameteriv5(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetTexParameterIiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetTexParameterIiv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetTexParameterIuiv5(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetTexParameterIuiv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetTexParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetTexParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetUniformSubroutineuiv5(void* ptr, unsigned int shadertype, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetUniformSubroutineuiv(shadertype, location, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetUniformfv5(void* ptr, unsigned int program, int location, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetUniformfv(program, location, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetUniformiv5(void* ptr, unsigned int program, int location, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetUniformiv(program, location, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetUniformuiv5(void* ptr, unsigned int program, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetUniformuiv(program, location, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetVertexAttribIiv5(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetVertexAttribIiv(index, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetVertexAttribIuiv5(void* ptr, unsigned int index, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetVertexAttribIuiv(index, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetVertexAttribPointerv5(void* ptr, unsigned int index, unsigned int pname, void* pointer)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetVertexAttribPointerv(index, pname, &pointer);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetVertexAttribfv5(void* ptr, unsigned int index, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetVertexAttribfv(index, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlGetVertexAttribiv5(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glGetVertexAttribiv(index, pname, &params);
}
void QOpenGLFunctions_4_2_Compatibility_GlHint5(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_4_2_Compatibility_GlHistogram5(void* ptr, unsigned int target, int width, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glHistogram(target, width, internalformat, sink != 0);
}
void QOpenGLFunctions_4_2_Compatibility_GlIndexMask5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glIndexMask(mask);
}
void QOpenGLFunctions_4_2_Compatibility_GlIndexPointer5(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glIndexPointer(ty, stride, pointer);
}
void QOpenGLFunctions_4_2_Compatibility_GlIndexf5(void* ptr, float c)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glIndexf(c);
}
void QOpenGLFunctions_4_2_Compatibility_GlIndexfv5(void* ptr, float c)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glIndexfv(const_cast<const GLfloat*>(&c));
}
void QOpenGLFunctions_4_2_Compatibility_GlIndexi5(void* ptr, int c)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glIndexi(c);
}
void QOpenGLFunctions_4_2_Compatibility_GlIndexiv5(void* ptr, int c)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glIndexiv(const_cast<const GLint*>(&c));
}
void QOpenGLFunctions_4_2_Compatibility_GlIndexs5(void* ptr, short c)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glIndexs(c);
}
void QOpenGLFunctions_4_2_Compatibility_GlIndexsv5(void* ptr, short c)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glIndexsv(const_cast<const GLshort*>(&c));
}
void QOpenGLFunctions_4_2_Compatibility_GlIndexub5(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glIndexub(*static_cast<GLubyte*>(static_cast<void*>(c)));
}
void QOpenGLFunctions_4_2_Compatibility_GlIndexubv5(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glIndexubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(c))));
}
void QOpenGLFunctions_4_2_Compatibility_GlInitNames5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glInitNames();
}
void QOpenGLFunctions_4_2_Compatibility_GlInterleavedArrays5(void* ptr, unsigned int format, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glInterleavedArrays(format, stride, pointer);
}
void QOpenGLFunctions_4_2_Compatibility_GlLightModelf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glLightModelf(pname, param);
}
void QOpenGLFunctions_4_2_Compatibility_GlLightModelfv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glLightModelfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_2_Compatibility_GlLightModeli5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glLightModeli(pname, param);
}
void QOpenGLFunctions_4_2_Compatibility_GlLightModeliv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glLightModeliv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_2_Compatibility_GlLightf5(void* ptr, unsigned int light, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glLightf(light, pname, param);
}
void QOpenGLFunctions_4_2_Compatibility_GlLightfv5(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glLightfv(light, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_2_Compatibility_GlLighti5(void* ptr, unsigned int light, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glLighti(light, pname, param);
}
void QOpenGLFunctions_4_2_Compatibility_GlLightiv5(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glLightiv(light, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_2_Compatibility_GlLineStipple5(void* ptr, int factor, unsigned short pattern)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glLineStipple(factor, pattern);
}
void QOpenGLFunctions_4_2_Compatibility_GlLineWidth5(void* ptr, float width)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_4_2_Compatibility_GlLinkProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glLinkProgram(program);
}
void QOpenGLFunctions_4_2_Compatibility_GlListBase5(void* ptr, unsigned int base)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glListBase(base);
}
void QOpenGLFunctions_4_2_Compatibility_GlLoadIdentity5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glLoadIdentity();
}
void QOpenGLFunctions_4_2_Compatibility_GlLoadMatrixf5(void* ptr, float m)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glLoadMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_4_2_Compatibility_GlLoadName5(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glLoadName(name);
}
void QOpenGLFunctions_4_2_Compatibility_GlLoadTransposeMatrixf5(void* ptr, float m)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glLoadTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_4_2_Compatibility_GlLogicOp5(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_4_2_Compatibility_GlMap1f5(void* ptr, unsigned int target, float u1, float u2, int stride, int order, float points)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMap1f(target, u1, u2, stride, order, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_4_2_Compatibility_GlMap2f5(void* ptr, unsigned int target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float points)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_4_2_Compatibility_GlMapGrid1f5(void* ptr, int un, float u1, float u2)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMapGrid1f(un, u1, u2);
}
void QOpenGLFunctions_4_2_Compatibility_GlMapGrid2f5(void* ptr, int un, float u1, float u2, int vn, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMapGrid2f(un, u1, u2, vn, v1, v2);
}
void QOpenGLFunctions_4_2_Compatibility_GlMaterialf5(void* ptr, unsigned int face, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMaterialf(face, pname, param);
}
void QOpenGLFunctions_4_2_Compatibility_GlMaterialfv5(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMaterialfv(face, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_2_Compatibility_GlMateriali5(void* ptr, unsigned int face, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMateriali(face, pname, param);
}
void QOpenGLFunctions_4_2_Compatibility_GlMaterialiv5(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMaterialiv(face, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_2_Compatibility_GlMatrixMode5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMatrixMode(mode);
}
void QOpenGLFunctions_4_2_Compatibility_GlMemoryBarrier5(void* ptr, unsigned int barriers)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMemoryBarrier(barriers);
}
void QOpenGLFunctions_4_2_Compatibility_GlMinSampleShading5(void* ptr, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMinSampleShading(value);
}
void QOpenGLFunctions_4_2_Compatibility_GlMinmax5(void* ptr, unsigned int target, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMinmax(target, internalformat, sink != 0);
}
void QOpenGLFunctions_4_2_Compatibility_GlMultMatrixf5(void* ptr, float m)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_4_2_Compatibility_GlMultTransposeMatrixf5(void* ptr, float m)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiDrawArrays5(void* ptr, unsigned int mode, int first, int count, int drawcount)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiDrawArrays(mode, const_cast<const GLint*>(&first), const_cast<const GLsizei*>(&count), drawcount);
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoord1f5(void* ptr, unsigned int target, float s)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoord1f(target, s);
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoord1fv5(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoord1fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoord1i5(void* ptr, unsigned int target, int s)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoord1i(target, s);
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoord1iv5(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoord1iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoord1s5(void* ptr, unsigned int target, short s)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoord1s(target, s);
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoord1sv5(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoord1sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoord2f5(void* ptr, unsigned int target, float s, float t)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoord2f(target, s, t);
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoord2fv5(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoord2fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoord2i5(void* ptr, unsigned int target, int s, int t)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoord2i(target, s, t);
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoord2iv5(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoord2iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoord2s5(void* ptr, unsigned int target, short s, short t)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoord2s(target, s, t);
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoord2sv5(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoord2sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoord3f5(void* ptr, unsigned int target, float s, float t, float r)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoord3f(target, s, t, r);
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoord3fv5(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoord3fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoord3i5(void* ptr, unsigned int target, int s, int t, int r)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoord3i(target, s, t, r);
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoord3iv5(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoord3iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoord3s5(void* ptr, unsigned int target, short s, short t, short r)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoord3s(target, s, t, r);
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoord3sv5(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoord3sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoord4f5(void* ptr, unsigned int target, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoord4f(target, s, t, r, q);
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoord4fv5(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoord4fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoord4i5(void* ptr, unsigned int target, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoord4i(target, s, t, r, q);
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoord4iv5(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoord4iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoord4s5(void* ptr, unsigned int target, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoord4s(target, s, t, r, q);
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoord4sv5(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoord4sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoordP1ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoordP1ui(texture, ty, coords);
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoordP1uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoordP1uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoordP2ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoordP2ui(texture, ty, coords);
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoordP2uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoordP2uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoordP3ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoordP3ui(texture, ty, coords);
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoordP3uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoordP3uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoordP4ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoordP4ui(texture, ty, coords);
}
void QOpenGLFunctions_4_2_Compatibility_GlMultiTexCoordP4uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glMultiTexCoordP4uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_2_Compatibility_GlNewList5(void* ptr, unsigned int list, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glNewList(list, mode);
}
void QOpenGLFunctions_4_2_Compatibility_GlNormal3f5(void* ptr, float nx, float ny, float nz)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glNormal3f(nx, ny, nz);
}
void QOpenGLFunctions_4_2_Compatibility_GlNormal3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glNormal3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlNormal3i5(void* ptr, int nx, int ny, int nz)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glNormal3i(nx, ny, nz);
}
void QOpenGLFunctions_4_2_Compatibility_GlNormal3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glNormal3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlNormal3s5(void* ptr, short nx, short ny, short nz)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glNormal3s(nx, ny, nz);
}
void QOpenGLFunctions_4_2_Compatibility_GlNormal3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glNormal3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlNormalP3ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glNormalP3ui(ty, coords);
}
void QOpenGLFunctions_4_2_Compatibility_GlNormalP3uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glNormalP3uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_2_Compatibility_GlNormalPointer5(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glNormalPointer(ty, stride, pointer);
}
void QOpenGLFunctions_4_2_Compatibility_GlPassThrough5(void* ptr, float token)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPassThrough(token);
}
void QOpenGLFunctions_4_2_Compatibility_GlPatchParameterfv5(void* ptr, unsigned int pname, float values)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPatchParameterfv(pname, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_4_2_Compatibility_GlPatchParameteri5(void* ptr, unsigned int pname, int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPatchParameteri(pname, value);
}
void QOpenGLFunctions_4_2_Compatibility_GlPauseTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPauseTransformFeedback();
}
void QOpenGLFunctions_4_2_Compatibility_GlPixelMapfv5(void* ptr, unsigned int m, int mapsize, float values)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPixelMapfv(m, mapsize, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_4_2_Compatibility_GlPixelMapuiv5(void* ptr, unsigned int m, int mapsize, unsigned int values)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPixelMapuiv(m, mapsize, const_cast<const GLuint*>(&values));
}
void QOpenGLFunctions_4_2_Compatibility_GlPixelMapusv5(void* ptr, unsigned int m, int mapsize, unsigned short values)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPixelMapusv(m, mapsize, const_cast<const GLushort*>(&values));
}
void QOpenGLFunctions_4_2_Compatibility_GlPixelStoref5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_4_2_Compatibility_GlPixelStorei5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_4_2_Compatibility_GlPixelTransferf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPixelTransferf(pname, param);
}
void QOpenGLFunctions_4_2_Compatibility_GlPixelTransferi5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPixelTransferi(pname, param);
}
void QOpenGLFunctions_4_2_Compatibility_GlPixelZoom5(void* ptr, float xfactor, float yfactor)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPixelZoom(xfactor, yfactor);
}
void QOpenGLFunctions_4_2_Compatibility_GlPointParameterf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPointParameterf(pname, param);
}
void QOpenGLFunctions_4_2_Compatibility_GlPointParameterfv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPointParameterfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_2_Compatibility_GlPointParameteri5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPointParameteri(pname, param);
}
void QOpenGLFunctions_4_2_Compatibility_GlPointParameteriv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPointParameteriv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_2_Compatibility_GlPointSize5(void* ptr, float size)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_4_2_Compatibility_GlPolygonMode5(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_4_2_Compatibility_GlPolygonOffset5(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_4_2_Compatibility_GlPolygonStipple5(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPolygonStipple(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(mask))));
}
void QOpenGLFunctions_4_2_Compatibility_GlPopAttrib5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPopAttrib();
}
void QOpenGLFunctions_4_2_Compatibility_GlPopClientAttrib5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPopClientAttrib();
}
void QOpenGLFunctions_4_2_Compatibility_GlPopMatrix5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPopMatrix();
}
void QOpenGLFunctions_4_2_Compatibility_GlPopName5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPopName();
}
void QOpenGLFunctions_4_2_Compatibility_GlPrimitiveRestartIndex5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPrimitiveRestartIndex(index);
}
void QOpenGLFunctions_4_2_Compatibility_GlPrioritizeTextures5(void* ptr, int n, unsigned int textures, float priorities)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPrioritizeTextures(n, const_cast<const GLuint*>(&textures), const_cast<const GLfloat*>(&priorities));
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramBinary5(void* ptr, unsigned int program, unsigned int binaryFormat, void* binary, int length)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramBinary(program, binaryFormat, binary, length);
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramParameteri5(void* ptr, unsigned int program, unsigned int pname, int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramParameteri(program, pname, value);
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniform1f5(void* ptr, unsigned int program, int location, float v0)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniform1f(program, location, v0);
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniform1fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniform1fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniform1i5(void* ptr, unsigned int program, int location, int v0)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniform1i(program, location, v0);
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniform1iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniform1iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniform1ui5(void* ptr, unsigned int program, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniform1ui(program, location, v0);
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniform1uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniform1uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniform2f5(void* ptr, unsigned int program, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniform2f(program, location, v0, v1);
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniform2fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniform2fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniform2i5(void* ptr, unsigned int program, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniform2i(program, location, v0, v1);
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniform2iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniform2iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniform2ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniform2ui(program, location, v0, v1);
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniform2uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniform2uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniform3f5(void* ptr, unsigned int program, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniform3f(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniform3fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniform3fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniform3i5(void* ptr, unsigned int program, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniform3i(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniform3iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniform3iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniform3ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniform3ui(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniform3uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniform3uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniform4f5(void* ptr, unsigned int program, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniform4f(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniform4fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniform4fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniform4i5(void* ptr, unsigned int program, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniform4i(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniform4iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniform4iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniform4ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniform4ui(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniform4uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniform4uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniformMatrix2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniformMatrix2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniformMatrix2x3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniformMatrix2x3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniformMatrix2x4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniformMatrix2x4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniformMatrix3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniformMatrix3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniformMatrix3x2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniformMatrix3x2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniformMatrix3x4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniformMatrix3x4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniformMatrix4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniformMatrix4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniformMatrix4x2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniformMatrix4x2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlProgramUniformMatrix4x3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProgramUniformMatrix4x3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlProvokingVertex5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glProvokingVertex(mode);
}
void QOpenGLFunctions_4_2_Compatibility_GlPushAttrib5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPushAttrib(mask);
}
void QOpenGLFunctions_4_2_Compatibility_GlPushClientAttrib5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPushClientAttrib(mask);
}
void QOpenGLFunctions_4_2_Compatibility_GlPushMatrix5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPushMatrix();
}
void QOpenGLFunctions_4_2_Compatibility_GlPushName5(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glPushName(name);
}
void QOpenGLFunctions_4_2_Compatibility_GlQueryCounter5(void* ptr, unsigned int id, unsigned int target)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glQueryCounter(id, target);
}
void QOpenGLFunctions_4_2_Compatibility_GlRasterPos2f5(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRasterPos2f(x, y);
}
void QOpenGLFunctions_4_2_Compatibility_GlRasterPos2fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRasterPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlRasterPos2i5(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRasterPos2i(x, y);
}
void QOpenGLFunctions_4_2_Compatibility_GlRasterPos2iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRasterPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlRasterPos2s5(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRasterPos2s(x, y);
}
void QOpenGLFunctions_4_2_Compatibility_GlRasterPos2sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRasterPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlRasterPos3f5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRasterPos3f(x, y, z);
}
void QOpenGLFunctions_4_2_Compatibility_GlRasterPos3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRasterPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlRasterPos3i5(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRasterPos3i(x, y, z);
}
void QOpenGLFunctions_4_2_Compatibility_GlRasterPos3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRasterPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlRasterPos3s5(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRasterPos3s(x, y, z);
}
void QOpenGLFunctions_4_2_Compatibility_GlRasterPos3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRasterPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlRasterPos4f5(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRasterPos4f(x, y, z, w);
}
void QOpenGLFunctions_4_2_Compatibility_GlRasterPos4fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRasterPos4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlRasterPos4i5(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRasterPos4i(x, y, z, w);
}
void QOpenGLFunctions_4_2_Compatibility_GlRasterPos4iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRasterPos4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlRasterPos4s5(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRasterPos4s(x, y, z, w);
}
void QOpenGLFunctions_4_2_Compatibility_GlRasterPos4sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRasterPos4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlReadBuffer5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glReadBuffer(mode);
}
void QOpenGLFunctions_4_2_Compatibility_GlReadPixels5(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_2_Compatibility_GlRectf5(void* ptr, float x1, float y1, float x2, float y2)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRectf(x1, y1, x2, y2);
}
void QOpenGLFunctions_4_2_Compatibility_GlRectfv5(void* ptr, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRectfv(const_cast<const GLfloat*>(&v1), const_cast<const GLfloat*>(&v2));
}
void QOpenGLFunctions_4_2_Compatibility_GlRecti5(void* ptr, int x1, int y1, int x2, int y2)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRecti(x1, y1, x2, y2);
}
void QOpenGLFunctions_4_2_Compatibility_GlRectiv5(void* ptr, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRectiv(const_cast<const GLint*>(&v1), const_cast<const GLint*>(&v2));
}
void QOpenGLFunctions_4_2_Compatibility_GlRects5(void* ptr, short x1, short y1, short x2, short y2)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRects(x1, y1, x2, y2);
}
void QOpenGLFunctions_4_2_Compatibility_GlRectsv5(void* ptr, short v1, short v2)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRectsv(const_cast<const GLshort*>(&v1), const_cast<const GLshort*>(&v2));
}
void QOpenGLFunctions_4_2_Compatibility_GlReleaseShaderCompiler5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glReleaseShaderCompiler();
}
void QOpenGLFunctions_4_2_Compatibility_GlRenderbufferStorage5(void* ptr, unsigned int target, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRenderbufferStorage(target, internalformat, width, height);
}
void QOpenGLFunctions_4_2_Compatibility_GlRenderbufferStorageMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
}
void QOpenGLFunctions_4_2_Compatibility_GlResetHistogram5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glResetHistogram(target);
}
void QOpenGLFunctions_4_2_Compatibility_GlResetMinmax5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glResetMinmax(target);
}
void QOpenGLFunctions_4_2_Compatibility_GlResumeTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glResumeTransformFeedback();
}
void QOpenGLFunctions_4_2_Compatibility_GlRotatef5(void* ptr, float angle, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glRotatef(angle, x, y, z);
}
void QOpenGLFunctions_4_2_Compatibility_GlSampleCoverage5(void* ptr, float value, char invert)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSampleCoverage(value, invert != 0);
}
void QOpenGLFunctions_4_2_Compatibility_GlSampleMaski5(void* ptr, unsigned int index, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSampleMaski(index, mask);
}
void QOpenGLFunctions_4_2_Compatibility_GlSamplerParameterIiv5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSamplerParameterIiv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_2_Compatibility_GlSamplerParameterIuiv5(void* ptr, unsigned int sampler, unsigned int pname, unsigned int param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSamplerParameterIuiv(sampler, pname, const_cast<const GLuint*>(&param));
}
void QOpenGLFunctions_4_2_Compatibility_GlSamplerParameterf5(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSamplerParameterf(sampler, pname, param);
}
void QOpenGLFunctions_4_2_Compatibility_GlSamplerParameterfv5(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSamplerParameterfv(sampler, pname, const_cast<const GLfloat*>(&param));
}
void QOpenGLFunctions_4_2_Compatibility_GlSamplerParameteri5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSamplerParameteri(sampler, pname, param);
}
void QOpenGLFunctions_4_2_Compatibility_GlSamplerParameteriv5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSamplerParameteriv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_2_Compatibility_GlScalef5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glScalef(x, y, z);
}
void QOpenGLFunctions_4_2_Compatibility_GlScissor5(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_4_2_Compatibility_GlScissorArrayv5(void* ptr, unsigned int first, int count, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glScissorArrayv(first, count, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlScissorIndexed5(void* ptr, unsigned int index, int left, int bottom, int width, int height)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glScissorIndexed(index, left, bottom, width, height);
}
void QOpenGLFunctions_4_2_Compatibility_GlScissorIndexedv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glScissorIndexedv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlSecondaryColor3f5(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSecondaryColor3f(red, green, blue);
}
void QOpenGLFunctions_4_2_Compatibility_GlSecondaryColor3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSecondaryColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlSecondaryColor3i5(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSecondaryColor3i(red, green, blue);
}
void QOpenGLFunctions_4_2_Compatibility_GlSecondaryColor3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSecondaryColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlSecondaryColor3s5(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSecondaryColor3s(red, green, blue);
}
void QOpenGLFunctions_4_2_Compatibility_GlSecondaryColor3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSecondaryColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlSecondaryColor3ub5(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSecondaryColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_4_2_Compatibility_GlSecondaryColor3ubv5(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSecondaryColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_2_Compatibility_GlSecondaryColor3ui5(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSecondaryColor3ui(red, green, blue);
}
void QOpenGLFunctions_4_2_Compatibility_GlSecondaryColor3uiv5(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSecondaryColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlSecondaryColor3us5(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSecondaryColor3us(red, green, blue);
}
void QOpenGLFunctions_4_2_Compatibility_GlSecondaryColor3usv5(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSecondaryColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlSecondaryColorP3ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSecondaryColorP3ui(ty, color);
}
void QOpenGLFunctions_4_2_Compatibility_GlSecondaryColorP3uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSecondaryColorP3uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_2_Compatibility_GlSecondaryColorPointer5(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSecondaryColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_4_2_Compatibility_GlSelectBuffer5(void* ptr, int size, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSelectBuffer(size, &buffer);
}
void QOpenGLFunctions_4_2_Compatibility_GlSeparableFilter2D5(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* row, void* column)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glSeparableFilter2D(target, internalformat, width, height, format, ty, row, column);
}
void QOpenGLFunctions_4_2_Compatibility_GlShadeModel5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glShadeModel(mode);
}
void QOpenGLFunctions_4_2_Compatibility_GlShaderBinary5(void* ptr, int count, unsigned int shaders, unsigned int binaryformat, void* binary, int length)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glShaderBinary(count, const_cast<const GLuint*>(&shaders), binaryformat, binary, length);
}
void QOpenGLFunctions_4_2_Compatibility_GlStencilFunc5(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_4_2_Compatibility_GlStencilFuncSeparate5(void* ptr, unsigned int face, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glStencilFuncSeparate(face, fu, ref, mask);
}
void QOpenGLFunctions_4_2_Compatibility_GlStencilMask5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_4_2_Compatibility_GlStencilMaskSeparate5(void* ptr, unsigned int face, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glStencilMaskSeparate(face, mask);
}
void QOpenGLFunctions_4_2_Compatibility_GlStencilOp5(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_4_2_Compatibility_GlStencilOpSeparate5(void* ptr, unsigned int face, unsigned int sfail, unsigned int dpfail, unsigned int dppass)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glStencilOpSeparate(face, sfail, dpfail, dppass);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexBuffer5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexBuffer(target, internalformat, buffer);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoord1f5(void* ptr, float s)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoord1f(s);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoord1fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoord1fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoord1i5(void* ptr, int s)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoord1i(s);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoord1iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoord1iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoord1s5(void* ptr, short s)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoord1s(s);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoord1sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoord1sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoord2f5(void* ptr, float s, float t)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoord2f(s, t);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoord2fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoord2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoord2i5(void* ptr, int s, int t)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoord2i(s, t);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoord2iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoord2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoord2s5(void* ptr, short s, short t)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoord2s(s, t);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoord2sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoord2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoord3f5(void* ptr, float s, float t, float r)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoord3f(s, t, r);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoord3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoord3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoord3i5(void* ptr, int s, int t, int r)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoord3i(s, t, r);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoord3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoord3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoord3s5(void* ptr, short s, short t, short r)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoord3s(s, t, r);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoord3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoord3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoord4f5(void* ptr, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoord4f(s, t, r, q);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoord4fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoord4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoord4i5(void* ptr, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoord4i(s, t, r, q);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoord4iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoord4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoord4s5(void* ptr, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoord4s(s, t, r, q);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoord4sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoord4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoordP1ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoordP1ui(ty, coords);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoordP1uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoordP1uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoordP2ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoordP2ui(ty, coords);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoordP2uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoordP2uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoordP3ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoordP3ui(ty, coords);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoordP3uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoordP3uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoordP4ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoordP4ui(ty, coords);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoordP4uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoordP4uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_2_Compatibility_GlTexCoordPointer5(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexCoordPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexEnvf5(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexEnvf(target, pname, param);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexEnvfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexEnvfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_2_Compatibility_GlTexEnvi5(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexEnvi(target, pname, param);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexEnviv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexEnviv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_2_Compatibility_GlTexGenf5(void* ptr, unsigned int coord, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexGenf(coord, pname, param);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexGenfv5(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexGenfv(coord, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_2_Compatibility_GlTexGeni5(void* ptr, unsigned int coord, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexGeni(coord, pname, param);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexGeniv5(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexGeniv(coord, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_2_Compatibility_GlTexImage1D5(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexImage2D5(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexImage2DMultisample5(void* ptr, unsigned int target, int samples, int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexImage3D5(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexImage3DMultisample5(void* ptr, unsigned int target, int samples, int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexParameterIiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexParameterIiv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_2_Compatibility_GlTexParameterIuiv5(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexParameterIuiv(target, pname, const_cast<const GLuint*>(&params));
}
void QOpenGLFunctions_4_2_Compatibility_GlTexParameterf5(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_2_Compatibility_GlTexParameteri5(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_2_Compatibility_GlTexStorage1D5(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexStorage1D(target, levels, internalformat, width);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexStorage2D5(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexStorage2D(target, levels, internalformat, width, height);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexStorage3D5(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width, int height, int depth)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexStorage3D(target, levels, internalformat, width, height, depth);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_2_Compatibility_GlTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_4_2_Compatibility_GlTranslatef5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glTranslatef(x, y, z);
}
void QOpenGLFunctions_4_2_Compatibility_GlUniform1f5(void* ptr, int location, float v0)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniform1f(location, v0);
}
void QOpenGLFunctions_4_2_Compatibility_GlUniform1fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniform1fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlUniform1i5(void* ptr, int location, int v0)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniform1i(location, v0);
}
void QOpenGLFunctions_4_2_Compatibility_GlUniform1iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniform1iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlUniform1ui5(void* ptr, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniform1ui(location, v0);
}
void QOpenGLFunctions_4_2_Compatibility_GlUniform1uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniform1uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlUniform2f5(void* ptr, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniform2f(location, v0, v1);
}
void QOpenGLFunctions_4_2_Compatibility_GlUniform2fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniform2fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlUniform2i5(void* ptr, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniform2i(location, v0, v1);
}
void QOpenGLFunctions_4_2_Compatibility_GlUniform2iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniform2iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlUniform2ui5(void* ptr, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniform2ui(location, v0, v1);
}
void QOpenGLFunctions_4_2_Compatibility_GlUniform2uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniform2uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlUniform3f5(void* ptr, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniform3f(location, v0, v1, v2);
}
void QOpenGLFunctions_4_2_Compatibility_GlUniform3fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniform3fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlUniform3i5(void* ptr, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniform3i(location, v0, v1, v2);
}
void QOpenGLFunctions_4_2_Compatibility_GlUniform3iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniform3iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlUniform3ui5(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniform3ui(location, v0, v1, v2);
}
void QOpenGLFunctions_4_2_Compatibility_GlUniform3uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniform3uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlUniform4f5(void* ptr, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniform4f(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_2_Compatibility_GlUniform4fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniform4fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlUniform4i5(void* ptr, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniform4i(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_2_Compatibility_GlUniform4iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniform4iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlUniform4ui5(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniform4ui(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_2_Compatibility_GlUniform4uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniform4uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlUniformBlockBinding5(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int uniformBlockBinding)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}
void QOpenGLFunctions_4_2_Compatibility_GlUniformMatrix2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniformMatrix2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlUniformMatrix2x3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniformMatrix2x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlUniformMatrix2x4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniformMatrix2x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlUniformMatrix3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniformMatrix3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlUniformMatrix3x2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniformMatrix3x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlUniformMatrix3x4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniformMatrix3x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlUniformMatrix4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniformMatrix4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlUniformMatrix4x2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniformMatrix4x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlUniformMatrix4x3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniformMatrix4x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlUniformSubroutinesuiv5(void* ptr, unsigned int shadertype, int count, unsigned int indices)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUniformSubroutinesuiv(shadertype, count, const_cast<const GLuint*>(&indices));
}
void QOpenGLFunctions_4_2_Compatibility_GlUseProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUseProgram(program);
}
void QOpenGLFunctions_4_2_Compatibility_GlUseProgramStages5(void* ptr, unsigned int pipeline, unsigned int stages, unsigned int program)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glUseProgramStages(pipeline, stages, program);
}
void QOpenGLFunctions_4_2_Compatibility_GlValidateProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glValidateProgram(program);
}
void QOpenGLFunctions_4_2_Compatibility_GlValidateProgramPipeline5(void* ptr, unsigned int pipeline)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glValidateProgramPipeline(pipeline);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertex2f5(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertex2f(x, y);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertex2fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertex2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertex2i5(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertex2i(x, y);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertex2iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertex2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertex2s5(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertex2s(x, y);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertex2sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertex2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertex3f5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertex3f(x, y, z);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertex3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertex3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertex3i5(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertex3i(x, y, z);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertex3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertex3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertex3s5(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertex3s(x, y, z);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertex3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertex3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertex4f5(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertex4f(x, y, z, w);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertex4fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertex4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertex4i5(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertex4i(x, y, z, w);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertex4iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertex4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertex4s5(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertex4s(x, y, z, w);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertex4sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertex4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib1f5(void* ptr, unsigned int index, float x)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib1f(index, x);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib1fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib1fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib1s5(void* ptr, unsigned int index, short x)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib1s(index, x);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib1sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib1sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib2f5(void* ptr, unsigned int index, float x, float y)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib2f(index, x, y);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib2fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib2fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib2s5(void* ptr, unsigned int index, short x, short y)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib2s(index, x, y);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib2sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib2sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib3f5(void* ptr, unsigned int index, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib3f(index, x, y, z);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib3fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib3fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib3s5(void* ptr, unsigned int index, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib3s(index, x, y, z);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib3sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib3sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib4Niv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib4Niv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib4Nsv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib4Nsv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib4Nub5(void* ptr, unsigned int index, char* x, char* y, char* z, char* w)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib4Nub(index, *static_cast<GLubyte*>(static_cast<void*>(x)), *static_cast<GLubyte*>(static_cast<void*>(y)), *static_cast<GLubyte*>(static_cast<void*>(z)), *static_cast<GLubyte*>(static_cast<void*>(w)));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib4Nubv5(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib4Nubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib4Nuiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib4Nuiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib4Nusv5(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib4Nusv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib4f5(void* ptr, unsigned int index, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib4f(index, x, y, z, w);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib4fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib4fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib4iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib4s5(void* ptr, unsigned int index, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib4s(index, x, y, z, w);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib4sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib4sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib4ubv5(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib4ubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib4uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttrib4usv5(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttrib4usv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribDivisor5(void* ptr, unsigned int index, unsigned int divisor)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribDivisor(index, divisor);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribI1i5(void* ptr, unsigned int index, int x)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribI1i(index, x);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribI1iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribI1iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribI1ui5(void* ptr, unsigned int index, unsigned int x)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribI1ui(index, x);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribI1uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribI1uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribI2i5(void* ptr, unsigned int index, int x, int y)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribI2i(index, x, y);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribI2iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribI2iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribI2ui5(void* ptr, unsigned int index, unsigned int x, unsigned int y)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribI2ui(index, x, y);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribI2uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribI2uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribI3i5(void* ptr, unsigned int index, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribI3i(index, x, y, z);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribI3iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribI3iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribI3ui5(void* ptr, unsigned int index, unsigned int x, unsigned int y, unsigned int z)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribI3ui(index, x, y, z);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribI3uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribI3uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribI4i5(void* ptr, unsigned int index, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribI4i(index, x, y, z, w);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribI4iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribI4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribI4sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribI4sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribI4ubv5(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribI4ubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribI4ui5(void* ptr, unsigned int index, unsigned int x, unsigned int y, unsigned int z, unsigned int w)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribI4ui(index, x, y, z, w);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribI4uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribI4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribI4usv5(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribI4usv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribIPointer5(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribIPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribLPointer5(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribLPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribP1ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribP1ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribP1uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribP1uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribP2ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribP2ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribP2uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribP2uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribP3ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribP3ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribP3uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribP3uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribP4ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribP4ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribP4uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribP4uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexAttribPointer5(void* ptr, unsigned int index, int size, unsigned int ty, char normalized, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexAttribPointer(index, size, ty, normalized != 0, stride, pointer);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexP2ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexP2ui(ty, value);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexP2uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexP2uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexP3ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexP3ui(ty, value);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexP3uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexP3uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexP4ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexP4ui(ty, value);
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexP4uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexP4uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Compatibility_GlVertexPointer5(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glVertexPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_4_2_Compatibility_GlViewport5(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_4_2_Compatibility_GlViewportArrayv5(void* ptr, unsigned int first, int count, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glViewportArrayv(first, count, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlViewportIndexedf5(void* ptr, unsigned int index, float x, float y, float w, float h)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glViewportIndexedf(index, x, y, w, h);
}
void QOpenGLFunctions_4_2_Compatibility_GlViewportIndexedfv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glViewportIndexedfv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlWindowPos2f5(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glWindowPos2f(x, y);
}
void QOpenGLFunctions_4_2_Compatibility_GlWindowPos2fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glWindowPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlWindowPos2i5(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glWindowPos2i(x, y);
}
void QOpenGLFunctions_4_2_Compatibility_GlWindowPos2iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glWindowPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlWindowPos2s5(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glWindowPos2s(x, y);
}
void QOpenGLFunctions_4_2_Compatibility_GlWindowPos2sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glWindowPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlWindowPos3f5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glWindowPos3f(x, y, z);
}
void QOpenGLFunctions_4_2_Compatibility_GlWindowPos3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glWindowPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlWindowPos3i5(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glWindowPos3i(x, y, z);
}
void QOpenGLFunctions_4_2_Compatibility_GlWindowPos3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glWindowPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_GlWindowPos3s5(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glWindowPos3s(x, y, z);
}
void QOpenGLFunctions_4_2_Compatibility_GlWindowPos3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glWindowPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_2_Compatibility_DestroyQOpenGLFunctions_4_2_Compatibility5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->~QOpenGLFunctions_4_2_Compatibility();
}
void QOpenGLFunctions_4_2_Compatibility_DestroyQOpenGLFunctions_4_2_Compatibility5Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_4_2_Core: public QOpenGLFunctions_4_2_Core
{
public:
MyQOpenGLFunctions_4_2_Core() : QOpenGLFunctions_4_2_Core() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_4_2_Core_InitializeOpenGLFunctions5(this) != 0; };
~MyQOpenGLFunctions_4_2_Core() { callbackQOpenGLFunctions_4_2_Core_DestroyQOpenGLFunctions_4_2_Core5(this); };
};
char QOpenGLFunctions_4_2_Core_GlIsBuffer5(void* ptr, unsigned int buffer)
{
return static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glIsBuffer(buffer);
}
char QOpenGLFunctions_4_2_Core_GlIsEnabled5(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_4_2_Core_GlIsEnabledi5(void* ptr, unsigned int target, unsigned int index)
{
return static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glIsEnabledi(target, index);
}
char QOpenGLFunctions_4_2_Core_GlIsFramebuffer5(void* ptr, unsigned int framebuffer)
{
return static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glIsFramebuffer(framebuffer);
}
char QOpenGLFunctions_4_2_Core_GlIsProgram5(void* ptr, unsigned int program)
{
return static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glIsProgram(program);
}
char QOpenGLFunctions_4_2_Core_GlIsProgramPipeline5(void* ptr, unsigned int pipeline)
{
return static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glIsProgramPipeline(pipeline);
}
char QOpenGLFunctions_4_2_Core_GlIsQuery5(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glIsQuery(id);
}
char QOpenGLFunctions_4_2_Core_GlIsRenderbuffer5(void* ptr, unsigned int renderbuffer)
{
return static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glIsRenderbuffer(renderbuffer);
}
char QOpenGLFunctions_4_2_Core_GlIsSampler5(void* ptr, unsigned int sampler)
{
return static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glIsSampler(sampler);
}
char QOpenGLFunctions_4_2_Core_GlIsShader5(void* ptr, unsigned int shader)
{
return static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glIsShader(shader);
}
char QOpenGLFunctions_4_2_Core_GlIsTexture5(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glIsTexture(texture);
}
char QOpenGLFunctions_4_2_Core_GlIsTransformFeedback5(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glIsTransformFeedback(id);
}
char QOpenGLFunctions_4_2_Core_GlIsVertexArray5(void* ptr, unsigned int array)
{
return static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glIsVertexArray(array);
}
char QOpenGLFunctions_4_2_Core_GlUnmapBuffer5(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUnmapBuffer(target);
}
unsigned int QOpenGLFunctions_4_2_Core_GlCheckFramebufferStatus5(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glCheckFramebufferStatus(target);
}
unsigned int QOpenGLFunctions_4_2_Core_GlGetError5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetError();
}
unsigned int QOpenGLFunctions_4_2_Core_GlCreateProgram5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glCreateProgram();
}
unsigned int QOpenGLFunctions_4_2_Core_GlCreateShader5(void* ptr, unsigned int ty)
{
return static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glCreateShader(ty);
}
void* QOpenGLFunctions_4_2_Core_GlMapBuffer5(void* ptr, unsigned int target, unsigned int access)
{
return static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glMapBuffer(target, access);
}
void* QOpenGLFunctions_4_2_Core_NewQOpenGLFunctions_4_2_Core5()
{
return new MyQOpenGLFunctions_4_2_Core();
}
char QOpenGLFunctions_4_2_Core_InitializeOpenGLFunctions5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_4_2_Core_InitializeOpenGLFunctions5Default(void* ptr)
{
return static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->QOpenGLFunctions_4_2_Core::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_4_2_Core_GlGetString5(void* ptr, unsigned int name)
{
return ({ char* tb8b3a3 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetString(name)))); QtGui_PackedString { tb8b3a3, -1 }; });
}
struct QtGui_PackedString QOpenGLFunctions_4_2_Core_GlGetStringi5(void* ptr, unsigned int name, unsigned int index)
{
return ({ char* t170cde = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetStringi(name, index)))); QtGui_PackedString { t170cde, -1 }; });
}
void QOpenGLFunctions_4_2_Core_GlActiveShaderProgram5(void* ptr, unsigned int pipeline, unsigned int program)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glActiveShaderProgram(pipeline, program);
}
void QOpenGLFunctions_4_2_Core_GlActiveTexture5(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glActiveTexture(texture);
}
void QOpenGLFunctions_4_2_Core_GlAttachShader5(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glAttachShader(program, shader);
}
void QOpenGLFunctions_4_2_Core_GlBeginConditionalRender5(void* ptr, unsigned int id, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glBeginConditionalRender(id, mode);
}
void QOpenGLFunctions_4_2_Core_GlBeginQuery5(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glBeginQuery(target, id);
}
void QOpenGLFunctions_4_2_Core_GlBeginQueryIndexed5(void* ptr, unsigned int target, unsigned int index, unsigned int id)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glBeginQueryIndexed(target, index, id);
}
void QOpenGLFunctions_4_2_Core_GlBeginTransformFeedback5(void* ptr, unsigned int primitiveMode)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glBeginTransformFeedback(primitiveMode);
}
void QOpenGLFunctions_4_2_Core_GlBindBuffer5(void* ptr, unsigned int target, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glBindBuffer(target, buffer);
}
void QOpenGLFunctions_4_2_Core_GlBindBufferBase5(void* ptr, unsigned int target, unsigned int index, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glBindBufferBase(target, index, buffer);
}
void QOpenGLFunctions_4_2_Core_GlBindFramebuffer5(void* ptr, unsigned int target, unsigned int framebuffer)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glBindFramebuffer(target, framebuffer);
}
void QOpenGLFunctions_4_2_Core_GlBindImageTexture5(void* ptr, unsigned int unit, unsigned int texture, int level, char layered, int layer, unsigned int access, unsigned int format)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glBindImageTexture(unit, texture, level, layered != 0, layer, access, format);
}
void QOpenGLFunctions_4_2_Core_GlBindProgramPipeline5(void* ptr, unsigned int pipeline)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glBindProgramPipeline(pipeline);
}
void QOpenGLFunctions_4_2_Core_GlBindRenderbuffer5(void* ptr, unsigned int target, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glBindRenderbuffer(target, renderbuffer);
}
void QOpenGLFunctions_4_2_Core_GlBindSampler5(void* ptr, unsigned int unit, unsigned int sampler)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glBindSampler(unit, sampler);
}
void QOpenGLFunctions_4_2_Core_GlBindTexture5(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_4_2_Core_GlBindTransformFeedback5(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glBindTransformFeedback(target, id);
}
void QOpenGLFunctions_4_2_Core_GlBindVertexArray5(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glBindVertexArray(array);
}
void QOpenGLFunctions_4_2_Core_GlBlendColor5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_4_2_Core_GlBlendEquation5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_4_2_Core_GlBlendEquationSeparate5(void* ptr, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glBlendEquationSeparate(modeRGB, modeAlpha);
}
void QOpenGLFunctions_4_2_Core_GlBlendEquationSeparatei5(void* ptr, unsigned int buf, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glBlendEquationSeparatei(buf, modeRGB, modeAlpha);
}
void QOpenGLFunctions_4_2_Core_GlBlendEquationi5(void* ptr, unsigned int buf, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glBlendEquationi(buf, mode);
}
void QOpenGLFunctions_4_2_Core_GlBlendFunc5(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_4_2_Core_GlBlendFuncSeparate5(void* ptr, unsigned int sfactorRGB, unsigned int dfactorRGB, unsigned int sfactorAlpha, unsigned int dfactorAlpha)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void QOpenGLFunctions_4_2_Core_GlBlendFuncSeparatei5(void* ptr, unsigned int buf, unsigned int srcRGB, unsigned int dstRGB, unsigned int srcAlpha, unsigned int dstAlpha)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
void QOpenGLFunctions_4_2_Core_GlBlendFunci5(void* ptr, unsigned int buf, unsigned int src, unsigned int dst)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glBlendFunci(buf, src, dst);
}
void QOpenGLFunctions_4_2_Core_GlBlitFramebuffer5(void* ptr, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, unsigned int mask, unsigned int filter)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
void QOpenGLFunctions_4_2_Core_GlClampColor5(void* ptr, unsigned int target, unsigned int clamp)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glClampColor(target, clamp);
}
void QOpenGLFunctions_4_2_Core_GlClear5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_4_2_Core_GlClearBufferfi5(void* ptr, unsigned int buffer, int drawbuffer, float depth, int stencil)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glClearBufferfi(buffer, drawbuffer, depth, stencil);
}
void QOpenGLFunctions_4_2_Core_GlClearBufferfv5(void* ptr, unsigned int buffer, int drawbuffer, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glClearBufferfv(buffer, drawbuffer, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlClearBufferiv5(void* ptr, unsigned int buffer, int drawbuffer, int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glClearBufferiv(buffer, drawbuffer, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlClearBufferuiv5(void* ptr, unsigned int buffer, int drawbuffer, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glClearBufferuiv(buffer, drawbuffer, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlClearColor5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_4_2_Core_GlClearDepthf5(void* ptr, float dd)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glClearDepthf(dd);
}
void QOpenGLFunctions_4_2_Core_GlClearStencil5(void* ptr, int s)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_4_2_Core_GlColorMask5(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_4_2_Core_GlColorMaski5(void* ptr, unsigned int index, char r, char g, char b, char a)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glColorMaski(index, r != 0, g != 0, b != 0, a != 0);
}
void QOpenGLFunctions_4_2_Core_GlColorP3ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glColorP3ui(ty, color);
}
void QOpenGLFunctions_4_2_Core_GlColorP3uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glColorP3uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_2_Core_GlColorP4ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glColorP4ui(ty, color);
}
void QOpenGLFunctions_4_2_Core_GlColorP4uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glColorP4uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_2_Core_GlCompileShader5(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glCompileShader(shader);
}
void QOpenGLFunctions_4_2_Core_GlCompressedTexImage1D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
void QOpenGLFunctions_4_2_Core_GlCompressedTexImage2D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void QOpenGLFunctions_4_2_Core_GlCompressedTexImage3D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int depth, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void QOpenGLFunctions_4_2_Core_GlCompressedTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_4_2_Core_GlCompressedTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_4_2_Core_GlCompressedTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_4_2_Core_GlCopyTexImage1D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_4_2_Core_GlCopyTexImage2D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_4_2_Core_GlCopyTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_4_2_Core_GlCopyTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_4_2_Core_GlCopyTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_4_2_Core_GlCullFace5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_4_2_Core_GlDeleteBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDeleteBuffers(n, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_4_2_Core_GlDeleteFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDeleteFramebuffers(n, const_cast<const GLuint*>(&framebuffers));
}
void QOpenGLFunctions_4_2_Core_GlDeleteProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDeleteProgram(program);
}
void QOpenGLFunctions_4_2_Core_GlDeleteProgramPipelines5(void* ptr, int n, unsigned int pipelines)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDeleteProgramPipelines(n, const_cast<const GLuint*>(&pipelines));
}
void QOpenGLFunctions_4_2_Core_GlDeleteQueries5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDeleteQueries(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_4_2_Core_GlDeleteRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDeleteRenderbuffers(n, const_cast<const GLuint*>(&renderbuffers));
}
void QOpenGLFunctions_4_2_Core_GlDeleteSamplers5(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDeleteSamplers(count, const_cast<const GLuint*>(&samplers));
}
void QOpenGLFunctions_4_2_Core_GlDeleteShader5(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDeleteShader(shader);
}
void QOpenGLFunctions_4_2_Core_GlDeleteTextures5(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_4_2_Core_GlDeleteTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDeleteTransformFeedbacks(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_4_2_Core_GlDeleteVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDeleteVertexArrays(n, const_cast<const GLuint*>(&arrays));
}
void QOpenGLFunctions_4_2_Core_GlDepthFunc5(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_4_2_Core_GlDepthMask5(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_4_2_Core_GlDepthRangef5(void* ptr, float n, float fo)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDepthRangef(n, fo);
}
void QOpenGLFunctions_4_2_Core_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDetachShader(program, shader);
}
void QOpenGLFunctions_4_2_Core_GlDisable5(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_4_2_Core_GlDisableVertexAttribArray5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDisableVertexAttribArray(index);
}
void QOpenGLFunctions_4_2_Core_GlDisablei5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDisablei(target, index);
}
void QOpenGLFunctions_4_2_Core_GlDrawArrays5(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_4_2_Core_GlDrawArraysIndirect5(void* ptr, unsigned int mode, void* indirect)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDrawArraysIndirect(mode, indirect);
}
void QOpenGLFunctions_4_2_Core_GlDrawArraysInstanced5(void* ptr, unsigned int mode, int first, int count, int instancecount)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDrawArraysInstanced(mode, first, count, instancecount);
}
void QOpenGLFunctions_4_2_Core_GlDrawArraysInstancedBaseInstance5(void* ptr, unsigned int mode, int first, int count, int instancecount, unsigned int baseinstance)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
}
void QOpenGLFunctions_4_2_Core_GlDrawBuffer5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDrawBuffer(mode);
}
void QOpenGLFunctions_4_2_Core_GlDrawBuffers5(void* ptr, int n, unsigned int bufs)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDrawBuffers(n, const_cast<const GLenum*>(&bufs));
}
void QOpenGLFunctions_4_2_Core_GlDrawElements5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_4_2_Core_GlDrawElementsBaseVertex5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDrawElementsBaseVertex(mode, count, ty, indices, basevertex);
}
void QOpenGLFunctions_4_2_Core_GlDrawElementsIndirect5(void* ptr, unsigned int mode, unsigned int ty, void* indirect)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDrawElementsIndirect(mode, ty, indirect);
}
void QOpenGLFunctions_4_2_Core_GlDrawElementsInstanced5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDrawElementsInstanced(mode, count, ty, indices, instancecount);
}
void QOpenGLFunctions_4_2_Core_GlDrawElementsInstancedBaseInstance5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, unsigned int baseinstance)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDrawElementsInstancedBaseInstance(mode, count, ty, indices, instancecount, baseinstance);
}
void QOpenGLFunctions_4_2_Core_GlDrawElementsInstancedBaseVertex5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDrawElementsInstancedBaseVertex(mode, count, ty, indices, instancecount, basevertex);
}
void QOpenGLFunctions_4_2_Core_GlDrawElementsInstancedBaseVertexBaseInstance5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex, unsigned int baseinstance)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDrawElementsInstancedBaseVertexBaseInstance(mode, count, ty, indices, instancecount, basevertex, baseinstance);
}
void QOpenGLFunctions_4_2_Core_GlDrawRangeElements5(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLFunctions_4_2_Core_GlDrawRangeElementsBaseVertex5(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDrawRangeElementsBaseVertex(mode, start, end, count, ty, indices, basevertex);
}
void QOpenGLFunctions_4_2_Core_GlDrawTransformFeedback5(void* ptr, unsigned int mode, unsigned int id)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDrawTransformFeedback(mode, id);
}
void QOpenGLFunctions_4_2_Core_GlDrawTransformFeedbackInstanced5(void* ptr, unsigned int mode, unsigned int id, int instancecount)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDrawTransformFeedbackInstanced(mode, id, instancecount);
}
void QOpenGLFunctions_4_2_Core_GlDrawTransformFeedbackStream5(void* ptr, unsigned int mode, unsigned int id, unsigned int stream)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDrawTransformFeedbackStream(mode, id, stream);
}
void QOpenGLFunctions_4_2_Core_GlDrawTransformFeedbackStreamInstanced5(void* ptr, unsigned int mode, unsigned int id, unsigned int stream, int instancecount)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
}
void QOpenGLFunctions_4_2_Core_GlEnable5(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_4_2_Core_GlEnableVertexAttribArray5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glEnableVertexAttribArray(index);
}
void QOpenGLFunctions_4_2_Core_GlEnablei5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glEnablei(target, index);
}
void QOpenGLFunctions_4_2_Core_GlEndConditionalRender5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glEndConditionalRender();
}
void QOpenGLFunctions_4_2_Core_GlEndQuery5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glEndQuery(target);
}
void QOpenGLFunctions_4_2_Core_GlEndQueryIndexed5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glEndQueryIndexed(target, index);
}
void QOpenGLFunctions_4_2_Core_GlEndTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glEndTransformFeedback();
}
void QOpenGLFunctions_4_2_Core_GlFinish5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glFinish();
}
void QOpenGLFunctions_4_2_Core_GlFlush5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glFlush();
}
void QOpenGLFunctions_4_2_Core_GlFramebufferRenderbuffer5(void* ptr, unsigned int target, unsigned int attachment, unsigned int renderbuffertarget, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
void QOpenGLFunctions_4_2_Core_GlFramebufferTexture5(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glFramebufferTexture(target, attachment, texture, level);
}
void QOpenGLFunctions_4_2_Core_GlFramebufferTexture1D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glFramebufferTexture1D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_4_2_Core_GlFramebufferTexture2D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_4_2_Core_GlFramebufferTexture3D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level, int zoffset)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}
void QOpenGLFunctions_4_2_Core_GlFramebufferTextureLayer5(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level, int layer)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glFramebufferTextureLayer(target, attachment, texture, level, layer);
}
void QOpenGLFunctions_4_2_Core_GlFrontFace5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_4_2_Core_GlGenBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGenBuffers(n, &buffers);
}
void QOpenGLFunctions_4_2_Core_GlGenFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGenFramebuffers(n, &framebuffers);
}
void QOpenGLFunctions_4_2_Core_GlGenProgramPipelines5(void* ptr, int n, unsigned int pipelines)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGenProgramPipelines(n, &pipelines);
}
void QOpenGLFunctions_4_2_Core_GlGenQueries5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGenQueries(n, &ids);
}
void QOpenGLFunctions_4_2_Core_GlGenRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGenRenderbuffers(n, &renderbuffers);
}
void QOpenGLFunctions_4_2_Core_GlGenSamplers5(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGenSamplers(count, &samplers);
}
void QOpenGLFunctions_4_2_Core_GlGenTextures5(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_4_2_Core_GlGenTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGenTransformFeedbacks(n, &ids);
}
void QOpenGLFunctions_4_2_Core_GlGenVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGenVertexArrays(n, &arrays);
}
void QOpenGLFunctions_4_2_Core_GlGenerateMipmap5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGenerateMipmap(target);
}
void QOpenGLFunctions_4_2_Core_GlGetActiveAtomicCounterBufferiv5(void* ptr, unsigned int program, unsigned int bufferIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetActiveAtomicCounterBufferiv(program, bufferIndex, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetActiveSubroutineUniformiv5(void* ptr, unsigned int program, unsigned int shadertype, unsigned int index, unsigned int pname, int values)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetActiveSubroutineUniformiv(program, shadertype, index, pname, &values);
}
void QOpenGLFunctions_4_2_Core_GlGetActiveUniformBlockiv5(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetActiveUniformsiv5(void* ptr, unsigned int program, int uniformCount, unsigned int uniformIndices, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetActiveUniformsiv(program, uniformCount, const_cast<const GLuint*>(&uniformIndices), pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetAttachedShaders5(void* ptr, unsigned int program, int maxCount, int count, unsigned int obj)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetAttachedShaders(program, maxCount, &count, &obj);
}
void QOpenGLFunctions_4_2_Core_GlGetBooleani_v5(void* ptr, unsigned int target, unsigned int index, char data)
{
Q_UNUSED(data);
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetBooleani_v(target, index, NULL);
}
void QOpenGLFunctions_4_2_Core_GlGetBooleanv5(void* ptr, unsigned int pname, char params)
{
Q_UNUSED(params);
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_4_2_Core_GlGetBufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetBufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetBufferPointerv5(void* ptr, unsigned int target, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetBufferPointerv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetCompressedTexImage5(void* ptr, unsigned int target, int level, void* img)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetCompressedTexImage(target, level, img);
}
void QOpenGLFunctions_4_2_Core_GlGetFloati_v5(void* ptr, unsigned int target, unsigned int index, float data)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetFloati_v(target, index, &data);
}
void QOpenGLFunctions_4_2_Core_GlGetFloatv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetFloatv(pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetFramebufferAttachmentParameteriv5(void* ptr, unsigned int target, unsigned int attachment, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetFramebufferAttachmentParameteriv(target, attachment, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetIntegeri_v5(void* ptr, unsigned int target, unsigned int index, int data)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetIntegeri_v(target, index, &data);
}
void QOpenGLFunctions_4_2_Core_GlGetIntegerv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetIntegerv(pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetInternalformativ5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int pname, int bufSize, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetInternalformativ(target, internalformat, pname, bufSize, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetMultisamplefv5(void* ptr, unsigned int pname, unsigned int index, float val)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetMultisamplefv(pname, index, &val);
}
void QOpenGLFunctions_4_2_Core_GlGetPointerv5(void* ptr, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetPointerv(pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetProgramBinary5(void* ptr, unsigned int program, int bufSize, int length, unsigned int binaryFormat, void* binary)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetProgramBinary(program, bufSize, &length, &binaryFormat, binary);
}
void QOpenGLFunctions_4_2_Core_GlGetProgramPipelineiv5(void* ptr, unsigned int pipeline, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetProgramPipelineiv(pipeline, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetProgramStageiv5(void* ptr, unsigned int program, unsigned int shadertype, unsigned int pname, int values)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetProgramStageiv(program, shadertype, pname, &values);
}
void QOpenGLFunctions_4_2_Core_GlGetProgramiv5(void* ptr, unsigned int program, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetProgramiv(program, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetQueryIndexediv5(void* ptr, unsigned int target, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetQueryIndexediv(target, index, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetQueryObjectiv5(void* ptr, unsigned int id, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetQueryObjectiv(id, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetQueryObjectuiv5(void* ptr, unsigned int id, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetQueryObjectuiv(id, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetQueryiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetQueryiv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetRenderbufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetRenderbufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetSamplerParameterIiv5(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetSamplerParameterIiv(sampler, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetSamplerParameterIuiv5(void* ptr, unsigned int sampler, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetSamplerParameterIuiv(sampler, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetSamplerParameterfv5(void* ptr, unsigned int sampler, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetSamplerParameterfv(sampler, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetSamplerParameteriv5(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetSamplerParameteriv(sampler, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetShaderPrecisionFormat5(void* ptr, unsigned int shadertype, unsigned int precisiontype, int ran, int precision)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetShaderPrecisionFormat(shadertype, precisiontype, &ran, &precision);
}
void QOpenGLFunctions_4_2_Core_GlGetShaderiv5(void* ptr, unsigned int shader, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetShaderiv(shader, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetTexImage5(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_4_2_Core_GlGetTexLevelParameterfv5(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetTexLevelParameteriv5(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetTexParameterIiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetTexParameterIiv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetTexParameterIuiv5(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetTexParameterIuiv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetTexParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetTexParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetUniformSubroutineuiv5(void* ptr, unsigned int shadertype, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetUniformSubroutineuiv(shadertype, location, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetUniformfv5(void* ptr, unsigned int program, int location, float params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetUniformfv(program, location, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetUniformiv5(void* ptr, unsigned int program, int location, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetUniformiv(program, location, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetUniformuiv5(void* ptr, unsigned int program, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetUniformuiv(program, location, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetVertexAttribIiv5(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetVertexAttribIiv(index, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetVertexAttribIuiv5(void* ptr, unsigned int index, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetVertexAttribIuiv(index, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetVertexAttribPointerv5(void* ptr, unsigned int index, unsigned int pname, void* pointer)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetVertexAttribPointerv(index, pname, &pointer);
}
void QOpenGLFunctions_4_2_Core_GlGetVertexAttribfv5(void* ptr, unsigned int index, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetVertexAttribfv(index, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlGetVertexAttribiv5(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glGetVertexAttribiv(index, pname, &params);
}
void QOpenGLFunctions_4_2_Core_GlHint5(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_4_2_Core_GlIndexub5(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glIndexub(*static_cast<GLubyte*>(static_cast<void*>(c)));
}
void QOpenGLFunctions_4_2_Core_GlIndexubv5(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glIndexubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(c))));
}
void QOpenGLFunctions_4_2_Core_GlLineWidth5(void* ptr, float width)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_4_2_Core_GlLinkProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glLinkProgram(program);
}
void QOpenGLFunctions_4_2_Core_GlLogicOp5(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_4_2_Core_GlMemoryBarrier5(void* ptr, unsigned int barriers)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glMemoryBarrier(barriers);
}
void QOpenGLFunctions_4_2_Core_GlMinSampleShading5(void* ptr, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glMinSampleShading(value);
}
void QOpenGLFunctions_4_2_Core_GlMultiDrawArrays5(void* ptr, unsigned int mode, int first, int count, int drawcount)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glMultiDrawArrays(mode, const_cast<const GLint*>(&first), const_cast<const GLsizei*>(&count), drawcount);
}
void QOpenGLFunctions_4_2_Core_GlMultiTexCoordP1ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glMultiTexCoordP1ui(texture, ty, coords);
}
void QOpenGLFunctions_4_2_Core_GlMultiTexCoordP1uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glMultiTexCoordP1uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_2_Core_GlMultiTexCoordP2ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glMultiTexCoordP2ui(texture, ty, coords);
}
void QOpenGLFunctions_4_2_Core_GlMultiTexCoordP2uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glMultiTexCoordP2uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_2_Core_GlMultiTexCoordP3ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glMultiTexCoordP3ui(texture, ty, coords);
}
void QOpenGLFunctions_4_2_Core_GlMultiTexCoordP3uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glMultiTexCoordP3uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_2_Core_GlMultiTexCoordP4ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glMultiTexCoordP4ui(texture, ty, coords);
}
void QOpenGLFunctions_4_2_Core_GlMultiTexCoordP4uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glMultiTexCoordP4uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_2_Core_GlNormalP3ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glNormalP3ui(ty, coords);
}
void QOpenGLFunctions_4_2_Core_GlNormalP3uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glNormalP3uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_2_Core_GlPatchParameterfv5(void* ptr, unsigned int pname, float values)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glPatchParameterfv(pname, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_4_2_Core_GlPatchParameteri5(void* ptr, unsigned int pname, int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glPatchParameteri(pname, value);
}
void QOpenGLFunctions_4_2_Core_GlPauseTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glPauseTransformFeedback();
}
void QOpenGLFunctions_4_2_Core_GlPixelStoref5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_4_2_Core_GlPixelStorei5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_4_2_Core_GlPointParameterf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glPointParameterf(pname, param);
}
void QOpenGLFunctions_4_2_Core_GlPointParameterfv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glPointParameterfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_2_Core_GlPointParameteri5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glPointParameteri(pname, param);
}
void QOpenGLFunctions_4_2_Core_GlPointParameteriv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glPointParameteriv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_2_Core_GlPointSize5(void* ptr, float size)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_4_2_Core_GlPolygonMode5(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_4_2_Core_GlPolygonOffset5(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_4_2_Core_GlPrimitiveRestartIndex5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glPrimitiveRestartIndex(index);
}
void QOpenGLFunctions_4_2_Core_GlProgramBinary5(void* ptr, unsigned int program, unsigned int binaryFormat, void* binary, int length)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramBinary(program, binaryFormat, binary, length);
}
void QOpenGLFunctions_4_2_Core_GlProgramParameteri5(void* ptr, unsigned int program, unsigned int pname, int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramParameteri(program, pname, value);
}
void QOpenGLFunctions_4_2_Core_GlProgramUniform1f5(void* ptr, unsigned int program, int location, float v0)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniform1f(program, location, v0);
}
void QOpenGLFunctions_4_2_Core_GlProgramUniform1fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniform1fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlProgramUniform1i5(void* ptr, unsigned int program, int location, int v0)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniform1i(program, location, v0);
}
void QOpenGLFunctions_4_2_Core_GlProgramUniform1iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniform1iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlProgramUniform1ui5(void* ptr, unsigned int program, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniform1ui(program, location, v0);
}
void QOpenGLFunctions_4_2_Core_GlProgramUniform1uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniform1uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlProgramUniform2f5(void* ptr, unsigned int program, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniform2f(program, location, v0, v1);
}
void QOpenGLFunctions_4_2_Core_GlProgramUniform2fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniform2fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlProgramUniform2i5(void* ptr, unsigned int program, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniform2i(program, location, v0, v1);
}
void QOpenGLFunctions_4_2_Core_GlProgramUniform2iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniform2iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlProgramUniform2ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniform2ui(program, location, v0, v1);
}
void QOpenGLFunctions_4_2_Core_GlProgramUniform2uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniform2uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlProgramUniform3f5(void* ptr, unsigned int program, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniform3f(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_2_Core_GlProgramUniform3fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniform3fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlProgramUniform3i5(void* ptr, unsigned int program, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniform3i(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_2_Core_GlProgramUniform3iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniform3iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlProgramUniform3ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniform3ui(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_2_Core_GlProgramUniform3uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniform3uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlProgramUniform4f5(void* ptr, unsigned int program, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniform4f(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_2_Core_GlProgramUniform4fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniform4fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlProgramUniform4i5(void* ptr, unsigned int program, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniform4i(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_2_Core_GlProgramUniform4iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniform4iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlProgramUniform4ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniform4ui(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_2_Core_GlProgramUniform4uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniform4uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlProgramUniformMatrix2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniformMatrix2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlProgramUniformMatrix2x3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniformMatrix2x3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlProgramUniformMatrix2x4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniformMatrix2x4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlProgramUniformMatrix3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniformMatrix3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlProgramUniformMatrix3x2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniformMatrix3x2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlProgramUniformMatrix3x4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniformMatrix3x4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlProgramUniformMatrix4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniformMatrix4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlProgramUniformMatrix4x2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniformMatrix4x2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlProgramUniformMatrix4x3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProgramUniformMatrix4x3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlProvokingVertex5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glProvokingVertex(mode);
}
void QOpenGLFunctions_4_2_Core_GlQueryCounter5(void* ptr, unsigned int id, unsigned int target)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glQueryCounter(id, target);
}
void QOpenGLFunctions_4_2_Core_GlReadBuffer5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glReadBuffer(mode);
}
void QOpenGLFunctions_4_2_Core_GlReadPixels5(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_2_Core_GlReleaseShaderCompiler5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glReleaseShaderCompiler();
}
void QOpenGLFunctions_4_2_Core_GlRenderbufferStorage5(void* ptr, unsigned int target, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glRenderbufferStorage(target, internalformat, width, height);
}
void QOpenGLFunctions_4_2_Core_GlRenderbufferStorageMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
}
void QOpenGLFunctions_4_2_Core_GlResumeTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glResumeTransformFeedback();
}
void QOpenGLFunctions_4_2_Core_GlSampleCoverage5(void* ptr, float value, char invert)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glSampleCoverage(value, invert != 0);
}
void QOpenGLFunctions_4_2_Core_GlSampleMaski5(void* ptr, unsigned int index, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glSampleMaski(index, mask);
}
void QOpenGLFunctions_4_2_Core_GlSamplerParameterIiv5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glSamplerParameterIiv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_2_Core_GlSamplerParameterIuiv5(void* ptr, unsigned int sampler, unsigned int pname, unsigned int param)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glSamplerParameterIuiv(sampler, pname, const_cast<const GLuint*>(&param));
}
void QOpenGLFunctions_4_2_Core_GlSamplerParameterf5(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glSamplerParameterf(sampler, pname, param);
}
void QOpenGLFunctions_4_2_Core_GlSamplerParameterfv5(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glSamplerParameterfv(sampler, pname, const_cast<const GLfloat*>(&param));
}
void QOpenGLFunctions_4_2_Core_GlSamplerParameteri5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glSamplerParameteri(sampler, pname, param);
}
void QOpenGLFunctions_4_2_Core_GlSamplerParameteriv5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glSamplerParameteriv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_2_Core_GlScissor5(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_4_2_Core_GlScissorArrayv5(void* ptr, unsigned int first, int count, int v)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glScissorArrayv(first, count, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Core_GlScissorIndexed5(void* ptr, unsigned int index, int left, int bottom, int width, int height)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glScissorIndexed(index, left, bottom, width, height);
}
void QOpenGLFunctions_4_2_Core_GlScissorIndexedv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glScissorIndexedv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_2_Core_GlSecondaryColorP3ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glSecondaryColorP3ui(ty, color);
}
void QOpenGLFunctions_4_2_Core_GlSecondaryColorP3uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glSecondaryColorP3uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_2_Core_GlShaderBinary5(void* ptr, int count, unsigned int shaders, unsigned int binaryformat, void* binary, int length)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glShaderBinary(count, const_cast<const GLuint*>(&shaders), binaryformat, binary, length);
}
void QOpenGLFunctions_4_2_Core_GlStencilFunc5(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_4_2_Core_GlStencilFuncSeparate5(void* ptr, unsigned int face, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glStencilFuncSeparate(face, fu, ref, mask);
}
void QOpenGLFunctions_4_2_Core_GlStencilMask5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_4_2_Core_GlStencilMaskSeparate5(void* ptr, unsigned int face, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glStencilMaskSeparate(face, mask);
}
void QOpenGLFunctions_4_2_Core_GlStencilOp5(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_4_2_Core_GlStencilOpSeparate5(void* ptr, unsigned int face, unsigned int sfail, unsigned int dpfail, unsigned int dppass)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glStencilOpSeparate(face, sfail, dpfail, dppass);
}
void QOpenGLFunctions_4_2_Core_GlTexBuffer5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexBuffer(target, internalformat, buffer);
}
void QOpenGLFunctions_4_2_Core_GlTexCoordP1ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexCoordP1ui(ty, coords);
}
void QOpenGLFunctions_4_2_Core_GlTexCoordP1uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexCoordP1uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_2_Core_GlTexCoordP2ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexCoordP2ui(ty, coords);
}
void QOpenGLFunctions_4_2_Core_GlTexCoordP2uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexCoordP2uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_2_Core_GlTexCoordP3ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexCoordP3ui(ty, coords);
}
void QOpenGLFunctions_4_2_Core_GlTexCoordP3uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexCoordP3uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_2_Core_GlTexCoordP4ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexCoordP4ui(ty, coords);
}
void QOpenGLFunctions_4_2_Core_GlTexCoordP4uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexCoordP4uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_2_Core_GlTexImage1D5(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_4_2_Core_GlTexImage2D5(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_4_2_Core_GlTexImage2DMultisample5(void* ptr, unsigned int target, int samples, int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_2_Core_GlTexImage3D5(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLFunctions_4_2_Core_GlTexImage3DMultisample5(void* ptr, unsigned int target, int samples, int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_2_Core_GlTexParameterIiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexParameterIiv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_2_Core_GlTexParameterIuiv5(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexParameterIuiv(target, pname, const_cast<const GLuint*>(&params));
}
void QOpenGLFunctions_4_2_Core_GlTexParameterf5(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_4_2_Core_GlTexParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_2_Core_GlTexParameteri5(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_4_2_Core_GlTexParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_2_Core_GlTexStorage1D5(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexStorage1D(target, levels, internalformat, width);
}
void QOpenGLFunctions_4_2_Core_GlTexStorage2D5(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexStorage2D(target, levels, internalformat, width, height);
}
void QOpenGLFunctions_4_2_Core_GlTexStorage3D5(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width, int height, int depth)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexStorage3D(target, levels, internalformat, width, height, depth);
}
void QOpenGLFunctions_4_2_Core_GlTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_4_2_Core_GlTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_2_Core_GlTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_4_2_Core_GlUniform1f5(void* ptr, int location, float v0)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniform1f(location, v0);
}
void QOpenGLFunctions_4_2_Core_GlUniform1fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniform1fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlUniform1i5(void* ptr, int location, int v0)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniform1i(location, v0);
}
void QOpenGLFunctions_4_2_Core_GlUniform1iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniform1iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlUniform1ui5(void* ptr, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniform1ui(location, v0);
}
void QOpenGLFunctions_4_2_Core_GlUniform1uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniform1uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlUniform2f5(void* ptr, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniform2f(location, v0, v1);
}
void QOpenGLFunctions_4_2_Core_GlUniform2fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniform2fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlUniform2i5(void* ptr, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniform2i(location, v0, v1);
}
void QOpenGLFunctions_4_2_Core_GlUniform2iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniform2iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlUniform2ui5(void* ptr, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniform2ui(location, v0, v1);
}
void QOpenGLFunctions_4_2_Core_GlUniform2uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniform2uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlUniform3f5(void* ptr, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniform3f(location, v0, v1, v2);
}
void QOpenGLFunctions_4_2_Core_GlUniform3fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniform3fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlUniform3i5(void* ptr, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniform3i(location, v0, v1, v2);
}
void QOpenGLFunctions_4_2_Core_GlUniform3iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniform3iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlUniform3ui5(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniform3ui(location, v0, v1, v2);
}
void QOpenGLFunctions_4_2_Core_GlUniform3uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniform3uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlUniform4f5(void* ptr, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniform4f(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_2_Core_GlUniform4fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniform4fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlUniform4i5(void* ptr, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniform4i(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_2_Core_GlUniform4iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniform4iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlUniform4ui5(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniform4ui(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_2_Core_GlUniform4uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniform4uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlUniformBlockBinding5(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int uniformBlockBinding)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}
void QOpenGLFunctions_4_2_Core_GlUniformMatrix2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniformMatrix2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlUniformMatrix2x3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniformMatrix2x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlUniformMatrix2x4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniformMatrix2x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlUniformMatrix3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniformMatrix3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlUniformMatrix3x2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniformMatrix3x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlUniformMatrix3x4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniformMatrix3x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlUniformMatrix4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniformMatrix4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlUniformMatrix4x2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniformMatrix4x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlUniformMatrix4x3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniformMatrix4x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlUniformSubroutinesuiv5(void* ptr, unsigned int shadertype, int count, unsigned int indices)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUniformSubroutinesuiv(shadertype, count, const_cast<const GLuint*>(&indices));
}
void QOpenGLFunctions_4_2_Core_GlUseProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUseProgram(program);
}
void QOpenGLFunctions_4_2_Core_GlUseProgramStages5(void* ptr, unsigned int pipeline, unsigned int stages, unsigned int program)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glUseProgramStages(pipeline, stages, program);
}
void QOpenGLFunctions_4_2_Core_GlValidateProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glValidateProgram(program);
}
void QOpenGLFunctions_4_2_Core_GlValidateProgramPipeline5(void* ptr, unsigned int pipeline)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glValidateProgramPipeline(pipeline);
}
void QOpenGLFunctions_4_2_Core_GlVertexAttribDivisor5(void* ptr, unsigned int index, unsigned int divisor)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glVertexAttribDivisor(index, divisor);
}
void QOpenGLFunctions_4_2_Core_GlVertexAttribIPointer5(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glVertexAttribIPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_4_2_Core_GlVertexAttribLPointer5(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glVertexAttribLPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_4_2_Core_GlVertexAttribP1ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glVertexAttribP1ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_2_Core_GlVertexAttribP1uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glVertexAttribP1uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlVertexAttribP2ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glVertexAttribP2ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_2_Core_GlVertexAttribP2uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glVertexAttribP2uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlVertexAttribP3ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glVertexAttribP3ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_2_Core_GlVertexAttribP3uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glVertexAttribP3uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlVertexAttribP4ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glVertexAttribP4ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_2_Core_GlVertexAttribP4uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glVertexAttribP4uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlVertexAttribPointer5(void* ptr, unsigned int index, int size, unsigned int ty, char normalized, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glVertexAttribPointer(index, size, ty, normalized != 0, stride, pointer);
}
void QOpenGLFunctions_4_2_Core_GlVertexP2ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glVertexP2ui(ty, value);
}
void QOpenGLFunctions_4_2_Core_GlVertexP2uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glVertexP2uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlVertexP3ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glVertexP3ui(ty, value);
}
void QOpenGLFunctions_4_2_Core_GlVertexP3uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glVertexP3uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlVertexP4ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glVertexP4ui(ty, value);
}
void QOpenGLFunctions_4_2_Core_GlVertexP4uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glVertexP4uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_2_Core_GlViewport5(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_4_2_Core_GlViewportArrayv5(void* ptr, unsigned int first, int count, float v)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glViewportArrayv(first, count, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Core_GlViewportIndexedf5(void* ptr, unsigned int index, float x, float y, float w, float h)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glViewportIndexedf(index, x, y, w, h);
}
void QOpenGLFunctions_4_2_Core_GlViewportIndexedfv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glViewportIndexedfv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_2_Core_DestroyQOpenGLFunctions_4_2_Core5(void* ptr)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->~QOpenGLFunctions_4_2_Core();
}
void QOpenGLFunctions_4_2_Core_DestroyQOpenGLFunctions_4_2_Core5Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_4_3_Compatibility: public QOpenGLFunctions_4_3_Compatibility
{
public:
MyQOpenGLFunctions_4_3_Compatibility() : QOpenGLFunctions_4_3_Compatibility() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_4_3_Compatibility_InitializeOpenGLFunctions5(this) != 0; };
~MyQOpenGLFunctions_4_3_Compatibility() { callbackQOpenGLFunctions_4_3_Compatibility_DestroyQOpenGLFunctions_4_3_Compatibility5(this); };
};
char QOpenGLFunctions_4_3_Compatibility_GlAreTexturesResident5(void* ptr, int n, unsigned int textures, char residences)
{
Q_UNUSED(residences);
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glAreTexturesResident(n, const_cast<const GLuint*>(&textures), NULL);
}
char QOpenGLFunctions_4_3_Compatibility_GlIsBuffer5(void* ptr, unsigned int buffer)
{
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glIsBuffer(buffer);
}
char QOpenGLFunctions_4_3_Compatibility_GlIsEnabled5(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_4_3_Compatibility_GlIsEnabledi5(void* ptr, unsigned int target, unsigned int index)
{
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glIsEnabledi(target, index);
}
char QOpenGLFunctions_4_3_Compatibility_GlIsFramebuffer5(void* ptr, unsigned int framebuffer)
{
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glIsFramebuffer(framebuffer);
}
char QOpenGLFunctions_4_3_Compatibility_GlIsList5(void* ptr, unsigned int list)
{
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glIsList(list);
}
char QOpenGLFunctions_4_3_Compatibility_GlIsProgram5(void* ptr, unsigned int program)
{
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glIsProgram(program);
}
char QOpenGLFunctions_4_3_Compatibility_GlIsProgramPipeline5(void* ptr, unsigned int pipeline)
{
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glIsProgramPipeline(pipeline);
}
char QOpenGLFunctions_4_3_Compatibility_GlIsQuery5(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glIsQuery(id);
}
char QOpenGLFunctions_4_3_Compatibility_GlIsRenderbuffer5(void* ptr, unsigned int renderbuffer)
{
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glIsRenderbuffer(renderbuffer);
}
char QOpenGLFunctions_4_3_Compatibility_GlIsSampler5(void* ptr, unsigned int sampler)
{
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glIsSampler(sampler);
}
char QOpenGLFunctions_4_3_Compatibility_GlIsShader5(void* ptr, unsigned int shader)
{
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glIsShader(shader);
}
char QOpenGLFunctions_4_3_Compatibility_GlIsTexture5(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glIsTexture(texture);
}
char QOpenGLFunctions_4_3_Compatibility_GlIsTransformFeedback5(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glIsTransformFeedback(id);
}
char QOpenGLFunctions_4_3_Compatibility_GlIsVertexArray5(void* ptr, unsigned int array)
{
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glIsVertexArray(array);
}
char QOpenGLFunctions_4_3_Compatibility_GlUnmapBuffer5(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUnmapBuffer(target);
}
unsigned int QOpenGLFunctions_4_3_Compatibility_GlCheckFramebufferStatus5(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glCheckFramebufferStatus(target);
}
unsigned int QOpenGLFunctions_4_3_Compatibility_GlGetError5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetError();
}
int QOpenGLFunctions_4_3_Compatibility_GlRenderMode5(void* ptr, unsigned int mode)
{
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRenderMode(mode);
}
unsigned int QOpenGLFunctions_4_3_Compatibility_GlCreateProgram5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glCreateProgram();
}
unsigned int QOpenGLFunctions_4_3_Compatibility_GlCreateShader5(void* ptr, unsigned int ty)
{
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glCreateShader(ty);
}
unsigned int QOpenGLFunctions_4_3_Compatibility_GlGenLists5(void* ptr, int ran)
{
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGenLists(ran);
}
void* QOpenGLFunctions_4_3_Compatibility_GlMapBuffer5(void* ptr, unsigned int target, unsigned int access)
{
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMapBuffer(target, access);
}
void* QOpenGLFunctions_4_3_Compatibility_NewQOpenGLFunctions_4_3_Compatibility5()
{
return new MyQOpenGLFunctions_4_3_Compatibility();
}
char QOpenGLFunctions_4_3_Compatibility_InitializeOpenGLFunctions5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_4_3_Compatibility_InitializeOpenGLFunctions5Default(void* ptr)
{
return static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->QOpenGLFunctions_4_3_Compatibility::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_4_3_Compatibility_GlGetString5(void* ptr, unsigned int name)
{
return ({ char* tf93bfe = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetString(name)))); QtGui_PackedString { tf93bfe, -1 }; });
}
struct QtGui_PackedString QOpenGLFunctions_4_3_Compatibility_GlGetStringi5(void* ptr, unsigned int name, unsigned int index)
{
return ({ char* tdac133 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetStringi(name, index)))); QtGui_PackedString { tdac133, -1 }; });
}
void QOpenGLFunctions_4_3_Compatibility_GlAccum5(void* ptr, unsigned int op, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glAccum(op, value);
}
void QOpenGLFunctions_4_3_Compatibility_GlActiveShaderProgram5(void* ptr, unsigned int pipeline, unsigned int program)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glActiveShaderProgram(pipeline, program);
}
void QOpenGLFunctions_4_3_Compatibility_GlActiveTexture5(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glActiveTexture(texture);
}
void QOpenGLFunctions_4_3_Compatibility_GlAlphaFunc5(void* ptr, unsigned int fu, float ref)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glAlphaFunc(fu, ref);
}
void QOpenGLFunctions_4_3_Compatibility_GlArrayElement5(void* ptr, int i)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glArrayElement(i);
}
void QOpenGLFunctions_4_3_Compatibility_GlAttachShader5(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glAttachShader(program, shader);
}
void QOpenGLFunctions_4_3_Compatibility_GlBegin5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBegin(mode);
}
void QOpenGLFunctions_4_3_Compatibility_GlBeginConditionalRender5(void* ptr, unsigned int id, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBeginConditionalRender(id, mode);
}
void QOpenGLFunctions_4_3_Compatibility_GlBeginQuery5(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBeginQuery(target, id);
}
void QOpenGLFunctions_4_3_Compatibility_GlBeginQueryIndexed5(void* ptr, unsigned int target, unsigned int index, unsigned int id)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBeginQueryIndexed(target, index, id);
}
void QOpenGLFunctions_4_3_Compatibility_GlBeginTransformFeedback5(void* ptr, unsigned int primitiveMode)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBeginTransformFeedback(primitiveMode);
}
void QOpenGLFunctions_4_3_Compatibility_GlBindBuffer5(void* ptr, unsigned int target, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBindBuffer(target, buffer);
}
void QOpenGLFunctions_4_3_Compatibility_GlBindBufferBase5(void* ptr, unsigned int target, unsigned int index, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBindBufferBase(target, index, buffer);
}
void QOpenGLFunctions_4_3_Compatibility_GlBindFramebuffer5(void* ptr, unsigned int target, unsigned int framebuffer)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBindFramebuffer(target, framebuffer);
}
void QOpenGLFunctions_4_3_Compatibility_GlBindImageTexture5(void* ptr, unsigned int unit, unsigned int texture, int level, char layered, int layer, unsigned int access, unsigned int format)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBindImageTexture(unit, texture, level, layered != 0, layer, access, format);
}
void QOpenGLFunctions_4_3_Compatibility_GlBindProgramPipeline5(void* ptr, unsigned int pipeline)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBindProgramPipeline(pipeline);
}
void QOpenGLFunctions_4_3_Compatibility_GlBindRenderbuffer5(void* ptr, unsigned int target, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBindRenderbuffer(target, renderbuffer);
}
void QOpenGLFunctions_4_3_Compatibility_GlBindSampler5(void* ptr, unsigned int unit, unsigned int sampler)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBindSampler(unit, sampler);
}
void QOpenGLFunctions_4_3_Compatibility_GlBindTexture5(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_4_3_Compatibility_GlBindTransformFeedback5(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBindTransformFeedback(target, id);
}
void QOpenGLFunctions_4_3_Compatibility_GlBindVertexArray5(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBindVertexArray(array);
}
void QOpenGLFunctions_4_3_Compatibility_GlBitmap5(void* ptr, int width, int height, float xorig, float yorig, float xmove, float ymove, char* bitmap)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBitmap(width, height, xorig, yorig, xmove, ymove, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(bitmap))));
}
void QOpenGLFunctions_4_3_Compatibility_GlBlendColor5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_4_3_Compatibility_GlBlendEquation5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_4_3_Compatibility_GlBlendEquationSeparate5(void* ptr, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBlendEquationSeparate(modeRGB, modeAlpha);
}
void QOpenGLFunctions_4_3_Compatibility_GlBlendEquationSeparatei5(void* ptr, unsigned int buf, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBlendEquationSeparatei(buf, modeRGB, modeAlpha);
}
void QOpenGLFunctions_4_3_Compatibility_GlBlendEquationi5(void* ptr, unsigned int buf, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBlendEquationi(buf, mode);
}
void QOpenGLFunctions_4_3_Compatibility_GlBlendFunc5(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_4_3_Compatibility_GlBlendFuncSeparate5(void* ptr, unsigned int sfactorRGB, unsigned int dfactorRGB, unsigned int sfactorAlpha, unsigned int dfactorAlpha)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void QOpenGLFunctions_4_3_Compatibility_GlBlendFuncSeparatei5(void* ptr, unsigned int buf, unsigned int srcRGB, unsigned int dstRGB, unsigned int srcAlpha, unsigned int dstAlpha)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
void QOpenGLFunctions_4_3_Compatibility_GlBlendFunci5(void* ptr, unsigned int buf, unsigned int src, unsigned int dst)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBlendFunci(buf, src, dst);
}
void QOpenGLFunctions_4_3_Compatibility_GlBlitFramebuffer5(void* ptr, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, unsigned int mask, unsigned int filter)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
void QOpenGLFunctions_4_3_Compatibility_GlCallList5(void* ptr, unsigned int list)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glCallList(list);
}
void QOpenGLFunctions_4_3_Compatibility_GlCallLists5(void* ptr, int n, unsigned int ty, void* lists)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glCallLists(n, ty, lists);
}
void QOpenGLFunctions_4_3_Compatibility_GlClampColor5(void* ptr, unsigned int target, unsigned int clamp)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glClampColor(target, clamp);
}
void QOpenGLFunctions_4_3_Compatibility_GlClear5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_4_3_Compatibility_GlClearAccum5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glClearAccum(red, green, blue, alpha);
}
void QOpenGLFunctions_4_3_Compatibility_GlClearBufferData5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glClearBufferData(target, internalformat, format, ty, data);
}
void QOpenGLFunctions_4_3_Compatibility_GlClearBufferfi5(void* ptr, unsigned int buffer, int drawbuffer, float depth, int stencil)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glClearBufferfi(buffer, drawbuffer, depth, stencil);
}
void QOpenGLFunctions_4_3_Compatibility_GlClearBufferfv5(void* ptr, unsigned int buffer, int drawbuffer, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glClearBufferfv(buffer, drawbuffer, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlClearBufferiv5(void* ptr, unsigned int buffer, int drawbuffer, int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glClearBufferiv(buffer, drawbuffer, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlClearBufferuiv5(void* ptr, unsigned int buffer, int drawbuffer, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glClearBufferuiv(buffer, drawbuffer, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlClearColor5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_4_3_Compatibility_GlClearDepthf5(void* ptr, float dd)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glClearDepthf(dd);
}
void QOpenGLFunctions_4_3_Compatibility_GlClearIndex5(void* ptr, float c)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glClearIndex(c);
}
void QOpenGLFunctions_4_3_Compatibility_GlClearStencil5(void* ptr, int s)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_4_3_Compatibility_GlClientActiveTexture5(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glClientActiveTexture(texture);
}
void QOpenGLFunctions_4_3_Compatibility_GlColor3f5(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColor3f(red, green, blue);
}
void QOpenGLFunctions_4_3_Compatibility_GlColor3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlColor3i5(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColor3i(red, green, blue);
}
void QOpenGLFunctions_4_3_Compatibility_GlColor3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlColor3s5(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColor3s(red, green, blue);
}
void QOpenGLFunctions_4_3_Compatibility_GlColor3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlColor3ub5(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_4_3_Compatibility_GlColor3ubv5(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_3_Compatibility_GlColor3ui5(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColor3ui(red, green, blue);
}
void QOpenGLFunctions_4_3_Compatibility_GlColor3uiv5(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlColor3us5(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColor3us(red, green, blue);
}
void QOpenGLFunctions_4_3_Compatibility_GlColor3usv5(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlColor4f5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColor4f(red, green, blue, alpha);
}
void QOpenGLFunctions_4_3_Compatibility_GlColor4fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColor4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlColor4i5(void* ptr, int red, int green, int blue, int alpha)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColor4i(red, green, blue, alpha);
}
void QOpenGLFunctions_4_3_Compatibility_GlColor4iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColor4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlColor4s5(void* ptr, short red, short green, short blue, short alpha)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColor4s(red, green, blue, alpha);
}
void QOpenGLFunctions_4_3_Compatibility_GlColor4sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColor4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlColor4ub5(void* ptr, char* red, char* green, char* blue, char* alpha)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColor4ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)), *static_cast<GLubyte*>(static_cast<void*>(alpha)));
}
void QOpenGLFunctions_4_3_Compatibility_GlColor4ubv5(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColor4ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_3_Compatibility_GlColor4ui5(void* ptr, unsigned int red, unsigned int green, unsigned int blue, unsigned int alpha)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColor4ui(red, green, blue, alpha);
}
void QOpenGLFunctions_4_3_Compatibility_GlColor4uiv5(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColor4uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlColor4us5(void* ptr, unsigned short red, unsigned short green, unsigned short blue, unsigned short alpha)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColor4us(red, green, blue, alpha);
}
void QOpenGLFunctions_4_3_Compatibility_GlColor4usv5(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColor4usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlColorMask5(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_4_3_Compatibility_GlColorMaski5(void* ptr, unsigned int index, char r, char g, char b, char a)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColorMaski(index, r != 0, g != 0, b != 0, a != 0);
}
void QOpenGLFunctions_4_3_Compatibility_GlColorMaterial5(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColorMaterial(face, mode);
}
void QOpenGLFunctions_4_3_Compatibility_GlColorP3ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColorP3ui(ty, color);
}
void QOpenGLFunctions_4_3_Compatibility_GlColorP3uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColorP3uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_3_Compatibility_GlColorP4ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColorP4ui(ty, color);
}
void QOpenGLFunctions_4_3_Compatibility_GlColorP4uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColorP4uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_3_Compatibility_GlColorPointer5(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_4_3_Compatibility_GlColorSubTable5(void* ptr, unsigned int target, int start, int count, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColorSubTable(target, start, count, format, ty, data);
}
void QOpenGLFunctions_4_3_Compatibility_GlColorTable5(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColorTable(target, internalformat, width, format, ty, table);
}
void QOpenGLFunctions_4_3_Compatibility_GlColorTableParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColorTableParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_3_Compatibility_GlColorTableParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glColorTableParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_3_Compatibility_GlCompileShader5(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glCompileShader(shader);
}
void QOpenGLFunctions_4_3_Compatibility_GlCompressedTexImage1D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
void QOpenGLFunctions_4_3_Compatibility_GlCompressedTexImage2D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void QOpenGLFunctions_4_3_Compatibility_GlCompressedTexImage3D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int depth, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void QOpenGLFunctions_4_3_Compatibility_GlCompressedTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_4_3_Compatibility_GlCompressedTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_4_3_Compatibility_GlCompressedTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_4_3_Compatibility_GlConvolutionFilter1D5(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glConvolutionFilter1D(target, internalformat, width, format, ty, image);
}
void QOpenGLFunctions_4_3_Compatibility_GlConvolutionFilter2D5(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glConvolutionFilter2D(target, internalformat, width, height, format, ty, image);
}
void QOpenGLFunctions_4_3_Compatibility_GlConvolutionParameterf5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glConvolutionParameterf(target, pname, params);
}
void QOpenGLFunctions_4_3_Compatibility_GlConvolutionParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glConvolutionParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_3_Compatibility_GlConvolutionParameteri5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glConvolutionParameteri(target, pname, params);
}
void QOpenGLFunctions_4_3_Compatibility_GlConvolutionParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glConvolutionParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_3_Compatibility_GlCopyColorSubTable5(void* ptr, unsigned int target, int start, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glCopyColorSubTable(target, start, x, y, width);
}
void QOpenGLFunctions_4_3_Compatibility_GlCopyColorTable5(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glCopyColorTable(target, internalformat, x, y, width);
}
void QOpenGLFunctions_4_3_Compatibility_GlCopyConvolutionFilter1D5(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glCopyConvolutionFilter1D(target, internalformat, x, y, width);
}
void QOpenGLFunctions_4_3_Compatibility_GlCopyConvolutionFilter2D5(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);
}
void QOpenGLFunctions_4_3_Compatibility_GlCopyImageSubData5(void* ptr, unsigned int srcName, unsigned int srcTarget, int srcLevel, int srcX, int srcY, int srcZ, unsigned int dstName, unsigned int dstTarget, int dstLevel, int dstX, int dstY, int dstZ, int srcWidth, int srcHeight, int srcDepth)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
}
void QOpenGLFunctions_4_3_Compatibility_GlCopyPixels5(void* ptr, int x, int y, int width, int height, unsigned int ty)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glCopyPixels(x, y, width, height, ty);
}
void QOpenGLFunctions_4_3_Compatibility_GlCopyTexImage1D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_4_3_Compatibility_GlCopyTexImage2D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_4_3_Compatibility_GlCopyTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_4_3_Compatibility_GlCopyTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_4_3_Compatibility_GlCopyTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_4_3_Compatibility_GlCullFace5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_4_3_Compatibility_GlDeleteBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDeleteBuffers(n, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_4_3_Compatibility_GlDeleteFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDeleteFramebuffers(n, const_cast<const GLuint*>(&framebuffers));
}
void QOpenGLFunctions_4_3_Compatibility_GlDeleteLists5(void* ptr, unsigned int list, int ran)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDeleteLists(list, ran);
}
void QOpenGLFunctions_4_3_Compatibility_GlDeleteProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDeleteProgram(program);
}
void QOpenGLFunctions_4_3_Compatibility_GlDeleteProgramPipelines5(void* ptr, int n, unsigned int pipelines)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDeleteProgramPipelines(n, const_cast<const GLuint*>(&pipelines));
}
void QOpenGLFunctions_4_3_Compatibility_GlDeleteQueries5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDeleteQueries(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_4_3_Compatibility_GlDeleteRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDeleteRenderbuffers(n, const_cast<const GLuint*>(&renderbuffers));
}
void QOpenGLFunctions_4_3_Compatibility_GlDeleteSamplers5(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDeleteSamplers(count, const_cast<const GLuint*>(&samplers));
}
void QOpenGLFunctions_4_3_Compatibility_GlDeleteShader5(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDeleteShader(shader);
}
void QOpenGLFunctions_4_3_Compatibility_GlDeleteTextures5(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_4_3_Compatibility_GlDeleteTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDeleteTransformFeedbacks(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_4_3_Compatibility_GlDeleteVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDeleteVertexArrays(n, const_cast<const GLuint*>(&arrays));
}
void QOpenGLFunctions_4_3_Compatibility_GlDepthFunc5(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_4_3_Compatibility_GlDepthMask5(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_4_3_Compatibility_GlDepthRangef5(void* ptr, float n, float fo)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDepthRangef(n, fo);
}
void QOpenGLFunctions_4_3_Compatibility_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDetachShader(program, shader);
}
void QOpenGLFunctions_4_3_Compatibility_GlDisable5(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_4_3_Compatibility_GlDisableClientState5(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDisableClientState(array);
}
void QOpenGLFunctions_4_3_Compatibility_GlDisableVertexAttribArray5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDisableVertexAttribArray(index);
}
void QOpenGLFunctions_4_3_Compatibility_GlDisablei5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDisablei(target, index);
}
void QOpenGLFunctions_4_3_Compatibility_GlDispatchCompute5(void* ptr, unsigned int num_groups_x, unsigned int num_groups_y, unsigned int num_groups_z)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
}
void QOpenGLFunctions_4_3_Compatibility_GlDrawArrays5(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_4_3_Compatibility_GlDrawArraysIndirect5(void* ptr, unsigned int mode, void* indirect)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDrawArraysIndirect(mode, indirect);
}
void QOpenGLFunctions_4_3_Compatibility_GlDrawArraysInstanced5(void* ptr, unsigned int mode, int first, int count, int instancecount)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDrawArraysInstanced(mode, first, count, instancecount);
}
void QOpenGLFunctions_4_3_Compatibility_GlDrawArraysInstancedBaseInstance5(void* ptr, unsigned int mode, int first, int count, int instancecount, unsigned int baseinstance)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
}
void QOpenGLFunctions_4_3_Compatibility_GlDrawBuffer5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDrawBuffer(mode);
}
void QOpenGLFunctions_4_3_Compatibility_GlDrawBuffers5(void* ptr, int n, unsigned int bufs)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDrawBuffers(n, const_cast<const GLenum*>(&bufs));
}
void QOpenGLFunctions_4_3_Compatibility_GlDrawElements5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_4_3_Compatibility_GlDrawElementsBaseVertex5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDrawElementsBaseVertex(mode, count, ty, indices, basevertex);
}
void QOpenGLFunctions_4_3_Compatibility_GlDrawElementsIndirect5(void* ptr, unsigned int mode, unsigned int ty, void* indirect)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDrawElementsIndirect(mode, ty, indirect);
}
void QOpenGLFunctions_4_3_Compatibility_GlDrawElementsInstanced5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDrawElementsInstanced(mode, count, ty, indices, instancecount);
}
void QOpenGLFunctions_4_3_Compatibility_GlDrawElementsInstancedBaseInstance5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, unsigned int baseinstance)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDrawElementsInstancedBaseInstance(mode, count, ty, indices, instancecount, baseinstance);
}
void QOpenGLFunctions_4_3_Compatibility_GlDrawElementsInstancedBaseVertex5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDrawElementsInstancedBaseVertex(mode, count, ty, indices, instancecount, basevertex);
}
void QOpenGLFunctions_4_3_Compatibility_GlDrawElementsInstancedBaseVertexBaseInstance5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex, unsigned int baseinstance)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDrawElementsInstancedBaseVertexBaseInstance(mode, count, ty, indices, instancecount, basevertex, baseinstance);
}
void QOpenGLFunctions_4_3_Compatibility_GlDrawPixels5(void* ptr, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDrawPixels(width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_3_Compatibility_GlDrawRangeElements5(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLFunctions_4_3_Compatibility_GlDrawRangeElementsBaseVertex5(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDrawRangeElementsBaseVertex(mode, start, end, count, ty, indices, basevertex);
}
void QOpenGLFunctions_4_3_Compatibility_GlDrawTransformFeedback5(void* ptr, unsigned int mode, unsigned int id)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDrawTransformFeedback(mode, id);
}
void QOpenGLFunctions_4_3_Compatibility_GlDrawTransformFeedbackInstanced5(void* ptr, unsigned int mode, unsigned int id, int instancecount)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDrawTransformFeedbackInstanced(mode, id, instancecount);
}
void QOpenGLFunctions_4_3_Compatibility_GlDrawTransformFeedbackStream5(void* ptr, unsigned int mode, unsigned int id, unsigned int stream)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDrawTransformFeedbackStream(mode, id, stream);
}
void QOpenGLFunctions_4_3_Compatibility_GlDrawTransformFeedbackStreamInstanced5(void* ptr, unsigned int mode, unsigned int id, unsigned int stream, int instancecount)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
}
void QOpenGLFunctions_4_3_Compatibility_GlEdgeFlag5(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glEdgeFlag(flag != 0);
}
void QOpenGLFunctions_4_3_Compatibility_GlEdgeFlagPointer5(void* ptr, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glEdgeFlagPointer(stride, pointer);
}
void QOpenGLFunctions_4_3_Compatibility_GlEdgeFlagv5(void* ptr, char flag)
{
Q_UNUSED(flag);
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glEdgeFlagv(NULL);
}
void QOpenGLFunctions_4_3_Compatibility_GlEnable5(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_4_3_Compatibility_GlEnableClientState5(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glEnableClientState(array);
}
void QOpenGLFunctions_4_3_Compatibility_GlEnableVertexAttribArray5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glEnableVertexAttribArray(index);
}
void QOpenGLFunctions_4_3_Compatibility_GlEnablei5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glEnablei(target, index);
}
void QOpenGLFunctions_4_3_Compatibility_GlEnd5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glEnd();
}
void QOpenGLFunctions_4_3_Compatibility_GlEndConditionalRender5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glEndConditionalRender();
}
void QOpenGLFunctions_4_3_Compatibility_GlEndList5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glEndList();
}
void QOpenGLFunctions_4_3_Compatibility_GlEndQuery5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glEndQuery(target);
}
void QOpenGLFunctions_4_3_Compatibility_GlEndQueryIndexed5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glEndQueryIndexed(target, index);
}
void QOpenGLFunctions_4_3_Compatibility_GlEndTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glEndTransformFeedback();
}
void QOpenGLFunctions_4_3_Compatibility_GlEvalCoord1f5(void* ptr, float u)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glEvalCoord1f(u);
}
void QOpenGLFunctions_4_3_Compatibility_GlEvalCoord1fv5(void* ptr, float u)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glEvalCoord1fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_4_3_Compatibility_GlEvalCoord2f5(void* ptr, float u, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glEvalCoord2f(u, v);
}
void QOpenGLFunctions_4_3_Compatibility_GlEvalCoord2fv5(void* ptr, float u)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glEvalCoord2fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_4_3_Compatibility_GlEvalMesh15(void* ptr, unsigned int mode, int i1, int i2)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glEvalMesh1(mode, i1, i2);
}
void QOpenGLFunctions_4_3_Compatibility_GlEvalMesh25(void* ptr, unsigned int mode, int i1, int i2, int j1, int j2)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glEvalMesh2(mode, i1, i2, j1, j2);
}
void QOpenGLFunctions_4_3_Compatibility_GlEvalPoint15(void* ptr, int i)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glEvalPoint1(i);
}
void QOpenGLFunctions_4_3_Compatibility_GlEvalPoint25(void* ptr, int i, int j)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glEvalPoint2(i, j);
}
void QOpenGLFunctions_4_3_Compatibility_GlFeedbackBuffer5(void* ptr, int size, unsigned int ty, float buffer)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glFeedbackBuffer(size, ty, &buffer);
}
void QOpenGLFunctions_4_3_Compatibility_GlFinish5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glFinish();
}
void QOpenGLFunctions_4_3_Compatibility_GlFlush5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glFlush();
}
void QOpenGLFunctions_4_3_Compatibility_GlFogCoordPointer5(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glFogCoordPointer(ty, stride, pointer);
}
void QOpenGLFunctions_4_3_Compatibility_GlFogCoordf5(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glFogCoordf(coord);
}
void QOpenGLFunctions_4_3_Compatibility_GlFogCoordfv5(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glFogCoordfv(const_cast<const GLfloat*>(&coord));
}
void QOpenGLFunctions_4_3_Compatibility_GlFogf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glFogf(pname, param);
}
void QOpenGLFunctions_4_3_Compatibility_GlFogfv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glFogfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_3_Compatibility_GlFogi5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glFogi(pname, param);
}
void QOpenGLFunctions_4_3_Compatibility_GlFogiv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glFogiv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_3_Compatibility_GlFramebufferParameteri5(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glFramebufferParameteri(target, pname, param);
}
void QOpenGLFunctions_4_3_Compatibility_GlFramebufferRenderbuffer5(void* ptr, unsigned int target, unsigned int attachment, unsigned int renderbuffertarget, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
void QOpenGLFunctions_4_3_Compatibility_GlFramebufferTexture5(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glFramebufferTexture(target, attachment, texture, level);
}
void QOpenGLFunctions_4_3_Compatibility_GlFramebufferTexture1D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glFramebufferTexture1D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_4_3_Compatibility_GlFramebufferTexture2D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_4_3_Compatibility_GlFramebufferTexture3D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level, int zoffset)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}
void QOpenGLFunctions_4_3_Compatibility_GlFramebufferTextureLayer5(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level, int layer)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glFramebufferTextureLayer(target, attachment, texture, level, layer);
}
void QOpenGLFunctions_4_3_Compatibility_GlFrontFace5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_4_3_Compatibility_GlGenBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGenBuffers(n, &buffers);
}
void QOpenGLFunctions_4_3_Compatibility_GlGenFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGenFramebuffers(n, &framebuffers);
}
void QOpenGLFunctions_4_3_Compatibility_GlGenProgramPipelines5(void* ptr, int n, unsigned int pipelines)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGenProgramPipelines(n, &pipelines);
}
void QOpenGLFunctions_4_3_Compatibility_GlGenQueries5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGenQueries(n, &ids);
}
void QOpenGLFunctions_4_3_Compatibility_GlGenRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGenRenderbuffers(n, &renderbuffers);
}
void QOpenGLFunctions_4_3_Compatibility_GlGenSamplers5(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGenSamplers(count, &samplers);
}
void QOpenGLFunctions_4_3_Compatibility_GlGenTextures5(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_4_3_Compatibility_GlGenTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGenTransformFeedbacks(n, &ids);
}
void QOpenGLFunctions_4_3_Compatibility_GlGenVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGenVertexArrays(n, &arrays);
}
void QOpenGLFunctions_4_3_Compatibility_GlGenerateMipmap5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGenerateMipmap(target);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetActiveAtomicCounterBufferiv5(void* ptr, unsigned int program, unsigned int bufferIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetActiveAtomicCounterBufferiv(program, bufferIndex, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetActiveSubroutineUniformiv5(void* ptr, unsigned int program, unsigned int shadertype, unsigned int index, unsigned int pname, int values)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetActiveSubroutineUniformiv(program, shadertype, index, pname, &values);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetActiveUniformBlockiv5(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetActiveUniformsiv5(void* ptr, unsigned int program, int uniformCount, unsigned int uniformIndices, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetActiveUniformsiv(program, uniformCount, const_cast<const GLuint*>(&uniformIndices), pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetAttachedShaders5(void* ptr, unsigned int program, int maxCount, int count, unsigned int obj)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetAttachedShaders(program, maxCount, &count, &obj);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetBooleani_v5(void* ptr, unsigned int target, unsigned int index, char data)
{
Q_UNUSED(data);
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetBooleani_v(target, index, NULL);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetBooleanv5(void* ptr, unsigned int pname, char params)
{
Q_UNUSED(params);
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetBufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetBufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetBufferPointerv5(void* ptr, unsigned int target, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetBufferPointerv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetColorTable5(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetColorTable(target, format, ty, table);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetColorTableParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetColorTableParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetColorTableParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetColorTableParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetCompressedTexImage5(void* ptr, unsigned int target, int level, void* img)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetCompressedTexImage(target, level, img);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetConvolutionFilter5(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetConvolutionFilter(target, format, ty, image);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetConvolutionParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetConvolutionParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetConvolutionParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetConvolutionParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetFloati_v5(void* ptr, unsigned int target, unsigned int index, float data)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetFloati_v(target, index, &data);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetFloatv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetFloatv(pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetFramebufferAttachmentParameteriv5(void* ptr, unsigned int target, unsigned int attachment, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetFramebufferAttachmentParameteriv(target, attachment, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetFramebufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetFramebufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetHistogram5(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetHistogram(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetHistogramParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetHistogramParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetHistogramParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetHistogramParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetIntegeri_v5(void* ptr, unsigned int target, unsigned int index, int data)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetIntegeri_v(target, index, &data);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetIntegerv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetIntegerv(pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetInternalformativ5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int pname, int bufSize, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetInternalformativ(target, internalformat, pname, bufSize, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetLightfv5(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetLightfv(light, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetLightiv5(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetLightiv(light, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetMapfv5(void* ptr, unsigned int target, unsigned int query, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetMapfv(target, query, &v);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetMapiv5(void* ptr, unsigned int target, unsigned int query, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetMapiv(target, query, &v);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetMaterialfv5(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetMaterialfv(face, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetMaterialiv5(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetMaterialiv(face, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetMinmax5(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetMinmax(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetMinmaxParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetMinmaxParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetMinmaxParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetMinmaxParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetMultisamplefv5(void* ptr, unsigned int pname, unsigned int index, float val)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetMultisamplefv(pname, index, &val);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetPixelMapfv5(void* ptr, unsigned int m, float values)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetPixelMapfv(m, &values);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetPixelMapuiv5(void* ptr, unsigned int m, unsigned int values)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetPixelMapuiv(m, &values);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetPixelMapusv5(void* ptr, unsigned int m, unsigned short values)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetPixelMapusv(m, &values);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetPointerv5(void* ptr, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetPointerv(pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetPolygonStipple5(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetPolygonStipple(static_cast<GLubyte*>(static_cast<void*>(mask)));
}
void QOpenGLFunctions_4_3_Compatibility_GlGetProgramBinary5(void* ptr, unsigned int program, int bufSize, int length, unsigned int binaryFormat, void* binary)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetProgramBinary(program, bufSize, &length, &binaryFormat, binary);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetProgramInterfaceiv5(void* ptr, unsigned int program, unsigned int programInterface, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetProgramInterfaceiv(program, programInterface, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetProgramPipelineiv5(void* ptr, unsigned int pipeline, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetProgramPipelineiv(pipeline, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetProgramResourceiv5(void* ptr, unsigned int program, unsigned int programInterface, unsigned int index, int propCount, unsigned int props, int bufSize, int length, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetProgramResourceiv(program, programInterface, index, propCount, const_cast<const GLenum*>(&props), bufSize, &length, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetProgramStageiv5(void* ptr, unsigned int program, unsigned int shadertype, unsigned int pname, int values)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetProgramStageiv(program, shadertype, pname, &values);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetProgramiv5(void* ptr, unsigned int program, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetProgramiv(program, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetQueryIndexediv5(void* ptr, unsigned int target, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetQueryIndexediv(target, index, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetQueryObjectiv5(void* ptr, unsigned int id, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetQueryObjectiv(id, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetQueryObjectuiv5(void* ptr, unsigned int id, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetQueryObjectuiv(id, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetQueryiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetQueryiv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetRenderbufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetRenderbufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetSamplerParameterIiv5(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetSamplerParameterIiv(sampler, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetSamplerParameterIuiv5(void* ptr, unsigned int sampler, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetSamplerParameterIuiv(sampler, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetSamplerParameterfv5(void* ptr, unsigned int sampler, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetSamplerParameterfv(sampler, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetSamplerParameteriv5(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetSamplerParameteriv(sampler, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetSeparableFilter5(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* row, void* column, void* span)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetSeparableFilter(target, format, ty, row, column, span);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetShaderPrecisionFormat5(void* ptr, unsigned int shadertype, unsigned int precisiontype, int ran, int precision)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetShaderPrecisionFormat(shadertype, precisiontype, &ran, &precision);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetShaderiv5(void* ptr, unsigned int shader, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetShaderiv(shader, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetTexEnvfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetTexEnvfv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetTexEnviv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetTexEnviv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetTexGenfv5(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetTexGenfv(coord, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetTexGeniv5(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetTexGeniv(coord, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetTexImage5(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetTexLevelParameterfv5(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetTexLevelParameteriv5(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetTexParameterIiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetTexParameterIiv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetTexParameterIuiv5(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetTexParameterIuiv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetTexParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetTexParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetUniformSubroutineuiv5(void* ptr, unsigned int shadertype, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetUniformSubroutineuiv(shadertype, location, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetUniformfv5(void* ptr, unsigned int program, int location, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetUniformfv(program, location, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetUniformiv5(void* ptr, unsigned int program, int location, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetUniformiv(program, location, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetUniformuiv5(void* ptr, unsigned int program, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetUniformuiv(program, location, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetVertexAttribIiv5(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetVertexAttribIiv(index, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetVertexAttribIuiv5(void* ptr, unsigned int index, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetVertexAttribIuiv(index, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetVertexAttribPointerv5(void* ptr, unsigned int index, unsigned int pname, void* pointer)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetVertexAttribPointerv(index, pname, &pointer);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetVertexAttribfv5(void* ptr, unsigned int index, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetVertexAttribfv(index, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlGetVertexAttribiv5(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glGetVertexAttribiv(index, pname, &params);
}
void QOpenGLFunctions_4_3_Compatibility_GlHint5(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_4_3_Compatibility_GlHistogram5(void* ptr, unsigned int target, int width, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glHistogram(target, width, internalformat, sink != 0);
}
void QOpenGLFunctions_4_3_Compatibility_GlIndexMask5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glIndexMask(mask);
}
void QOpenGLFunctions_4_3_Compatibility_GlIndexPointer5(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glIndexPointer(ty, stride, pointer);
}
void QOpenGLFunctions_4_3_Compatibility_GlIndexf5(void* ptr, float c)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glIndexf(c);
}
void QOpenGLFunctions_4_3_Compatibility_GlIndexfv5(void* ptr, float c)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glIndexfv(const_cast<const GLfloat*>(&c));
}
void QOpenGLFunctions_4_3_Compatibility_GlIndexi5(void* ptr, int c)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glIndexi(c);
}
void QOpenGLFunctions_4_3_Compatibility_GlIndexiv5(void* ptr, int c)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glIndexiv(const_cast<const GLint*>(&c));
}
void QOpenGLFunctions_4_3_Compatibility_GlIndexs5(void* ptr, short c)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glIndexs(c);
}
void QOpenGLFunctions_4_3_Compatibility_GlIndexsv5(void* ptr, short c)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glIndexsv(const_cast<const GLshort*>(&c));
}
void QOpenGLFunctions_4_3_Compatibility_GlIndexub5(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glIndexub(*static_cast<GLubyte*>(static_cast<void*>(c)));
}
void QOpenGLFunctions_4_3_Compatibility_GlIndexubv5(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glIndexubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(c))));
}
void QOpenGLFunctions_4_3_Compatibility_GlInitNames5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glInitNames();
}
void QOpenGLFunctions_4_3_Compatibility_GlInterleavedArrays5(void* ptr, unsigned int format, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glInterleavedArrays(format, stride, pointer);
}
void QOpenGLFunctions_4_3_Compatibility_GlInvalidateBufferData5(void* ptr, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glInvalidateBufferData(buffer);
}
void QOpenGLFunctions_4_3_Compatibility_GlInvalidateFramebuffer5(void* ptr, unsigned int target, int numAttachments, unsigned int attachments)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glInvalidateFramebuffer(target, numAttachments, const_cast<const GLenum*>(&attachments));
}
void QOpenGLFunctions_4_3_Compatibility_GlInvalidateSubFramebuffer5(void* ptr, unsigned int target, int numAttachments, unsigned int attachments, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glInvalidateSubFramebuffer(target, numAttachments, const_cast<const GLenum*>(&attachments), x, y, width, height);
}
void QOpenGLFunctions_4_3_Compatibility_GlInvalidateTexImage5(void* ptr, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glInvalidateTexImage(texture, level);
}
void QOpenGLFunctions_4_3_Compatibility_GlInvalidateTexSubImage5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glInvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
}
void QOpenGLFunctions_4_3_Compatibility_GlLightModelf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glLightModelf(pname, param);
}
void QOpenGLFunctions_4_3_Compatibility_GlLightModelfv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glLightModelfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_3_Compatibility_GlLightModeli5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glLightModeli(pname, param);
}
void QOpenGLFunctions_4_3_Compatibility_GlLightModeliv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glLightModeliv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_3_Compatibility_GlLightf5(void* ptr, unsigned int light, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glLightf(light, pname, param);
}
void QOpenGLFunctions_4_3_Compatibility_GlLightfv5(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glLightfv(light, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_3_Compatibility_GlLighti5(void* ptr, unsigned int light, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glLighti(light, pname, param);
}
void QOpenGLFunctions_4_3_Compatibility_GlLightiv5(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glLightiv(light, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_3_Compatibility_GlLineStipple5(void* ptr, int factor, unsigned short pattern)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glLineStipple(factor, pattern);
}
void QOpenGLFunctions_4_3_Compatibility_GlLineWidth5(void* ptr, float width)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_4_3_Compatibility_GlLinkProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glLinkProgram(program);
}
void QOpenGLFunctions_4_3_Compatibility_GlListBase5(void* ptr, unsigned int base)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glListBase(base);
}
void QOpenGLFunctions_4_3_Compatibility_GlLoadIdentity5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glLoadIdentity();
}
void QOpenGLFunctions_4_3_Compatibility_GlLoadMatrixf5(void* ptr, float m)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glLoadMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_4_3_Compatibility_GlLoadName5(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glLoadName(name);
}
void QOpenGLFunctions_4_3_Compatibility_GlLoadTransposeMatrixf5(void* ptr, float m)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glLoadTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_4_3_Compatibility_GlLogicOp5(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_4_3_Compatibility_GlMap1f5(void* ptr, unsigned int target, float u1, float u2, int stride, int order, float points)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMap1f(target, u1, u2, stride, order, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_4_3_Compatibility_GlMap2f5(void* ptr, unsigned int target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float points)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_4_3_Compatibility_GlMapGrid1f5(void* ptr, int un, float u1, float u2)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMapGrid1f(un, u1, u2);
}
void QOpenGLFunctions_4_3_Compatibility_GlMapGrid2f5(void* ptr, int un, float u1, float u2, int vn, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMapGrid2f(un, u1, u2, vn, v1, v2);
}
void QOpenGLFunctions_4_3_Compatibility_GlMaterialf5(void* ptr, unsigned int face, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMaterialf(face, pname, param);
}
void QOpenGLFunctions_4_3_Compatibility_GlMaterialfv5(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMaterialfv(face, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_3_Compatibility_GlMateriali5(void* ptr, unsigned int face, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMateriali(face, pname, param);
}
void QOpenGLFunctions_4_3_Compatibility_GlMaterialiv5(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMaterialiv(face, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_3_Compatibility_GlMatrixMode5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMatrixMode(mode);
}
void QOpenGLFunctions_4_3_Compatibility_GlMemoryBarrier5(void* ptr, unsigned int barriers)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMemoryBarrier(barriers);
}
void QOpenGLFunctions_4_3_Compatibility_GlMinSampleShading5(void* ptr, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMinSampleShading(value);
}
void QOpenGLFunctions_4_3_Compatibility_GlMinmax5(void* ptr, unsigned int target, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMinmax(target, internalformat, sink != 0);
}
void QOpenGLFunctions_4_3_Compatibility_GlMultMatrixf5(void* ptr, float m)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_4_3_Compatibility_GlMultTransposeMatrixf5(void* ptr, float m)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiDrawArrays5(void* ptr, unsigned int mode, int first, int count, int drawcount)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiDrawArrays(mode, const_cast<const GLint*>(&first), const_cast<const GLsizei*>(&count), drawcount);
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiDrawArraysIndirect5(void* ptr, unsigned int mode, void* indirect, int drawcount, int stride)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiDrawArraysIndirect(mode, indirect, drawcount, stride);
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiDrawElementsIndirect5(void* ptr, unsigned int mode, unsigned int ty, void* indirect, int drawcount, int stride)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiDrawElementsIndirect(mode, ty, indirect, drawcount, stride);
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoord1f5(void* ptr, unsigned int target, float s)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoord1f(target, s);
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoord1fv5(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoord1fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoord1i5(void* ptr, unsigned int target, int s)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoord1i(target, s);
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoord1iv5(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoord1iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoord1s5(void* ptr, unsigned int target, short s)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoord1s(target, s);
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoord1sv5(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoord1sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoord2f5(void* ptr, unsigned int target, float s, float t)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoord2f(target, s, t);
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoord2fv5(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoord2fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoord2i5(void* ptr, unsigned int target, int s, int t)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoord2i(target, s, t);
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoord2iv5(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoord2iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoord2s5(void* ptr, unsigned int target, short s, short t)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoord2s(target, s, t);
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoord2sv5(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoord2sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoord3f5(void* ptr, unsigned int target, float s, float t, float r)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoord3f(target, s, t, r);
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoord3fv5(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoord3fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoord3i5(void* ptr, unsigned int target, int s, int t, int r)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoord3i(target, s, t, r);
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoord3iv5(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoord3iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoord3s5(void* ptr, unsigned int target, short s, short t, short r)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoord3s(target, s, t, r);
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoord3sv5(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoord3sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoord4f5(void* ptr, unsigned int target, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoord4f(target, s, t, r, q);
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoord4fv5(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoord4fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoord4i5(void* ptr, unsigned int target, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoord4i(target, s, t, r, q);
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoord4iv5(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoord4iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoord4s5(void* ptr, unsigned int target, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoord4s(target, s, t, r, q);
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoord4sv5(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoord4sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoordP1ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoordP1ui(texture, ty, coords);
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoordP1uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoordP1uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoordP2ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoordP2ui(texture, ty, coords);
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoordP2uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoordP2uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoordP3ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoordP3ui(texture, ty, coords);
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoordP3uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoordP3uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoordP4ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoordP4ui(texture, ty, coords);
}
void QOpenGLFunctions_4_3_Compatibility_GlMultiTexCoordP4uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glMultiTexCoordP4uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_3_Compatibility_GlNewList5(void* ptr, unsigned int list, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glNewList(list, mode);
}
void QOpenGLFunctions_4_3_Compatibility_GlNormal3f5(void* ptr, float nx, float ny, float nz)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glNormal3f(nx, ny, nz);
}
void QOpenGLFunctions_4_3_Compatibility_GlNormal3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glNormal3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlNormal3i5(void* ptr, int nx, int ny, int nz)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glNormal3i(nx, ny, nz);
}
void QOpenGLFunctions_4_3_Compatibility_GlNormal3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glNormal3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlNormal3s5(void* ptr, short nx, short ny, short nz)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glNormal3s(nx, ny, nz);
}
void QOpenGLFunctions_4_3_Compatibility_GlNormal3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glNormal3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlNormalP3ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glNormalP3ui(ty, coords);
}
void QOpenGLFunctions_4_3_Compatibility_GlNormalP3uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glNormalP3uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_3_Compatibility_GlNormalPointer5(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glNormalPointer(ty, stride, pointer);
}
void QOpenGLFunctions_4_3_Compatibility_GlPassThrough5(void* ptr, float token)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPassThrough(token);
}
void QOpenGLFunctions_4_3_Compatibility_GlPatchParameterfv5(void* ptr, unsigned int pname, float values)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPatchParameterfv(pname, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_4_3_Compatibility_GlPatchParameteri5(void* ptr, unsigned int pname, int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPatchParameteri(pname, value);
}
void QOpenGLFunctions_4_3_Compatibility_GlPauseTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPauseTransformFeedback();
}
void QOpenGLFunctions_4_3_Compatibility_GlPixelMapfv5(void* ptr, unsigned int m, int mapsize, float values)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPixelMapfv(m, mapsize, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_4_3_Compatibility_GlPixelMapuiv5(void* ptr, unsigned int m, int mapsize, unsigned int values)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPixelMapuiv(m, mapsize, const_cast<const GLuint*>(&values));
}
void QOpenGLFunctions_4_3_Compatibility_GlPixelMapusv5(void* ptr, unsigned int m, int mapsize, unsigned short values)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPixelMapusv(m, mapsize, const_cast<const GLushort*>(&values));
}
void QOpenGLFunctions_4_3_Compatibility_GlPixelStoref5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_4_3_Compatibility_GlPixelStorei5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_4_3_Compatibility_GlPixelTransferf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPixelTransferf(pname, param);
}
void QOpenGLFunctions_4_3_Compatibility_GlPixelTransferi5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPixelTransferi(pname, param);
}
void QOpenGLFunctions_4_3_Compatibility_GlPixelZoom5(void* ptr, float xfactor, float yfactor)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPixelZoom(xfactor, yfactor);
}
void QOpenGLFunctions_4_3_Compatibility_GlPointParameterf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPointParameterf(pname, param);
}
void QOpenGLFunctions_4_3_Compatibility_GlPointParameterfv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPointParameterfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_3_Compatibility_GlPointParameteri5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPointParameteri(pname, param);
}
void QOpenGLFunctions_4_3_Compatibility_GlPointParameteriv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPointParameteriv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_3_Compatibility_GlPointSize5(void* ptr, float size)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_4_3_Compatibility_GlPolygonMode5(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_4_3_Compatibility_GlPolygonOffset5(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_4_3_Compatibility_GlPolygonStipple5(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPolygonStipple(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(mask))));
}
void QOpenGLFunctions_4_3_Compatibility_GlPopAttrib5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPopAttrib();
}
void QOpenGLFunctions_4_3_Compatibility_GlPopClientAttrib5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPopClientAttrib();
}
void QOpenGLFunctions_4_3_Compatibility_GlPopMatrix5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPopMatrix();
}
void QOpenGLFunctions_4_3_Compatibility_GlPopName5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPopName();
}
void QOpenGLFunctions_4_3_Compatibility_GlPrimitiveRestartIndex5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPrimitiveRestartIndex(index);
}
void QOpenGLFunctions_4_3_Compatibility_GlPrioritizeTextures5(void* ptr, int n, unsigned int textures, float priorities)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPrioritizeTextures(n, const_cast<const GLuint*>(&textures), const_cast<const GLfloat*>(&priorities));
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramBinary5(void* ptr, unsigned int program, unsigned int binaryFormat, void* binary, int length)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramBinary(program, binaryFormat, binary, length);
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramParameteri5(void* ptr, unsigned int program, unsigned int pname, int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramParameteri(program, pname, value);
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniform1f5(void* ptr, unsigned int program, int location, float v0)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniform1f(program, location, v0);
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniform1fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniform1fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniform1i5(void* ptr, unsigned int program, int location, int v0)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniform1i(program, location, v0);
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniform1iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniform1iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniform1ui5(void* ptr, unsigned int program, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniform1ui(program, location, v0);
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniform1uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniform1uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniform2f5(void* ptr, unsigned int program, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniform2f(program, location, v0, v1);
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniform2fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniform2fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniform2i5(void* ptr, unsigned int program, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniform2i(program, location, v0, v1);
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniform2iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniform2iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniform2ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniform2ui(program, location, v0, v1);
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniform2uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniform2uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniform3f5(void* ptr, unsigned int program, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniform3f(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniform3fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniform3fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniform3i5(void* ptr, unsigned int program, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniform3i(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniform3iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniform3iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniform3ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniform3ui(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniform3uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniform3uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniform4f5(void* ptr, unsigned int program, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniform4f(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniform4fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniform4fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniform4i5(void* ptr, unsigned int program, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniform4i(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniform4iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniform4iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniform4ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniform4ui(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniform4uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniform4uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniformMatrix2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniformMatrix2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniformMatrix2x3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniformMatrix2x3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniformMatrix2x4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniformMatrix2x4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniformMatrix3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniformMatrix3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniformMatrix3x2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniformMatrix3x2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniformMatrix3x4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniformMatrix3x4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniformMatrix4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniformMatrix4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniformMatrix4x2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniformMatrix4x2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlProgramUniformMatrix4x3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProgramUniformMatrix4x3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlProvokingVertex5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glProvokingVertex(mode);
}
void QOpenGLFunctions_4_3_Compatibility_GlPushAttrib5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPushAttrib(mask);
}
void QOpenGLFunctions_4_3_Compatibility_GlPushClientAttrib5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPushClientAttrib(mask);
}
void QOpenGLFunctions_4_3_Compatibility_GlPushMatrix5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPushMatrix();
}
void QOpenGLFunctions_4_3_Compatibility_GlPushName5(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glPushName(name);
}
void QOpenGLFunctions_4_3_Compatibility_GlQueryCounter5(void* ptr, unsigned int id, unsigned int target)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glQueryCounter(id, target);
}
void QOpenGLFunctions_4_3_Compatibility_GlRasterPos2f5(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRasterPos2f(x, y);
}
void QOpenGLFunctions_4_3_Compatibility_GlRasterPos2fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRasterPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlRasterPos2i5(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRasterPos2i(x, y);
}
void QOpenGLFunctions_4_3_Compatibility_GlRasterPos2iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRasterPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlRasterPos2s5(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRasterPos2s(x, y);
}
void QOpenGLFunctions_4_3_Compatibility_GlRasterPos2sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRasterPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlRasterPos3f5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRasterPos3f(x, y, z);
}
void QOpenGLFunctions_4_3_Compatibility_GlRasterPos3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRasterPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlRasterPos3i5(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRasterPos3i(x, y, z);
}
void QOpenGLFunctions_4_3_Compatibility_GlRasterPos3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRasterPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlRasterPos3s5(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRasterPos3s(x, y, z);
}
void QOpenGLFunctions_4_3_Compatibility_GlRasterPos3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRasterPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlRasterPos4f5(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRasterPos4f(x, y, z, w);
}
void QOpenGLFunctions_4_3_Compatibility_GlRasterPos4fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRasterPos4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlRasterPos4i5(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRasterPos4i(x, y, z, w);
}
void QOpenGLFunctions_4_3_Compatibility_GlRasterPos4iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRasterPos4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlRasterPos4s5(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRasterPos4s(x, y, z, w);
}
void QOpenGLFunctions_4_3_Compatibility_GlRasterPos4sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRasterPos4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlReadBuffer5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glReadBuffer(mode);
}
void QOpenGLFunctions_4_3_Compatibility_GlReadPixels5(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_3_Compatibility_GlRectf5(void* ptr, float x1, float y1, float x2, float y2)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRectf(x1, y1, x2, y2);
}
void QOpenGLFunctions_4_3_Compatibility_GlRectfv5(void* ptr, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRectfv(const_cast<const GLfloat*>(&v1), const_cast<const GLfloat*>(&v2));
}
void QOpenGLFunctions_4_3_Compatibility_GlRecti5(void* ptr, int x1, int y1, int x2, int y2)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRecti(x1, y1, x2, y2);
}
void QOpenGLFunctions_4_3_Compatibility_GlRectiv5(void* ptr, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRectiv(const_cast<const GLint*>(&v1), const_cast<const GLint*>(&v2));
}
void QOpenGLFunctions_4_3_Compatibility_GlRects5(void* ptr, short x1, short y1, short x2, short y2)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRects(x1, y1, x2, y2);
}
void QOpenGLFunctions_4_3_Compatibility_GlRectsv5(void* ptr, short v1, short v2)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRectsv(const_cast<const GLshort*>(&v1), const_cast<const GLshort*>(&v2));
}
void QOpenGLFunctions_4_3_Compatibility_GlReleaseShaderCompiler5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glReleaseShaderCompiler();
}
void QOpenGLFunctions_4_3_Compatibility_GlRenderbufferStorage5(void* ptr, unsigned int target, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRenderbufferStorage(target, internalformat, width, height);
}
void QOpenGLFunctions_4_3_Compatibility_GlRenderbufferStorageMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
}
void QOpenGLFunctions_4_3_Compatibility_GlResetHistogram5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glResetHistogram(target);
}
void QOpenGLFunctions_4_3_Compatibility_GlResetMinmax5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glResetMinmax(target);
}
void QOpenGLFunctions_4_3_Compatibility_GlResumeTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glResumeTransformFeedback();
}
void QOpenGLFunctions_4_3_Compatibility_GlRotatef5(void* ptr, float angle, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glRotatef(angle, x, y, z);
}
void QOpenGLFunctions_4_3_Compatibility_GlSampleCoverage5(void* ptr, float value, char invert)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSampleCoverage(value, invert != 0);
}
void QOpenGLFunctions_4_3_Compatibility_GlSampleMaski5(void* ptr, unsigned int index, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSampleMaski(index, mask);
}
void QOpenGLFunctions_4_3_Compatibility_GlSamplerParameterIiv5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSamplerParameterIiv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_3_Compatibility_GlSamplerParameterIuiv5(void* ptr, unsigned int sampler, unsigned int pname, unsigned int param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSamplerParameterIuiv(sampler, pname, const_cast<const GLuint*>(&param));
}
void QOpenGLFunctions_4_3_Compatibility_GlSamplerParameterf5(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSamplerParameterf(sampler, pname, param);
}
void QOpenGLFunctions_4_3_Compatibility_GlSamplerParameterfv5(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSamplerParameterfv(sampler, pname, const_cast<const GLfloat*>(&param));
}
void QOpenGLFunctions_4_3_Compatibility_GlSamplerParameteri5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSamplerParameteri(sampler, pname, param);
}
void QOpenGLFunctions_4_3_Compatibility_GlSamplerParameteriv5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSamplerParameteriv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_3_Compatibility_GlScalef5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glScalef(x, y, z);
}
void QOpenGLFunctions_4_3_Compatibility_GlScissor5(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_4_3_Compatibility_GlScissorArrayv5(void* ptr, unsigned int first, int count, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glScissorArrayv(first, count, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlScissorIndexed5(void* ptr, unsigned int index, int left, int bottom, int width, int height)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glScissorIndexed(index, left, bottom, width, height);
}
void QOpenGLFunctions_4_3_Compatibility_GlScissorIndexedv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glScissorIndexedv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlSecondaryColor3f5(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSecondaryColor3f(red, green, blue);
}
void QOpenGLFunctions_4_3_Compatibility_GlSecondaryColor3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSecondaryColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlSecondaryColor3i5(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSecondaryColor3i(red, green, blue);
}
void QOpenGLFunctions_4_3_Compatibility_GlSecondaryColor3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSecondaryColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlSecondaryColor3s5(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSecondaryColor3s(red, green, blue);
}
void QOpenGLFunctions_4_3_Compatibility_GlSecondaryColor3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSecondaryColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlSecondaryColor3ub5(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSecondaryColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_4_3_Compatibility_GlSecondaryColor3ubv5(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSecondaryColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_3_Compatibility_GlSecondaryColor3ui5(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSecondaryColor3ui(red, green, blue);
}
void QOpenGLFunctions_4_3_Compatibility_GlSecondaryColor3uiv5(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSecondaryColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlSecondaryColor3us5(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSecondaryColor3us(red, green, blue);
}
void QOpenGLFunctions_4_3_Compatibility_GlSecondaryColor3usv5(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSecondaryColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlSecondaryColorP3ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSecondaryColorP3ui(ty, color);
}
void QOpenGLFunctions_4_3_Compatibility_GlSecondaryColorP3uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSecondaryColorP3uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_3_Compatibility_GlSecondaryColorPointer5(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSecondaryColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_4_3_Compatibility_GlSelectBuffer5(void* ptr, int size, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSelectBuffer(size, &buffer);
}
void QOpenGLFunctions_4_3_Compatibility_GlSeparableFilter2D5(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* row, void* column)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glSeparableFilter2D(target, internalformat, width, height, format, ty, row, column);
}
void QOpenGLFunctions_4_3_Compatibility_GlShadeModel5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glShadeModel(mode);
}
void QOpenGLFunctions_4_3_Compatibility_GlShaderBinary5(void* ptr, int count, unsigned int shaders, unsigned int binaryformat, void* binary, int length)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glShaderBinary(count, const_cast<const GLuint*>(&shaders), binaryformat, binary, length);
}
void QOpenGLFunctions_4_3_Compatibility_GlShaderStorageBlockBinding5(void* ptr, unsigned int program, unsigned int storageBlockIndex, unsigned int storageBlockBinding)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
}
void QOpenGLFunctions_4_3_Compatibility_GlStencilFunc5(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_4_3_Compatibility_GlStencilFuncSeparate5(void* ptr, unsigned int face, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glStencilFuncSeparate(face, fu, ref, mask);
}
void QOpenGLFunctions_4_3_Compatibility_GlStencilMask5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_4_3_Compatibility_GlStencilMaskSeparate5(void* ptr, unsigned int face, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glStencilMaskSeparate(face, mask);
}
void QOpenGLFunctions_4_3_Compatibility_GlStencilOp5(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_4_3_Compatibility_GlStencilOpSeparate5(void* ptr, unsigned int face, unsigned int sfail, unsigned int dpfail, unsigned int dppass)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glStencilOpSeparate(face, sfail, dpfail, dppass);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexBuffer5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexBuffer(target, internalformat, buffer);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoord1f5(void* ptr, float s)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoord1f(s);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoord1fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoord1fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoord1i5(void* ptr, int s)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoord1i(s);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoord1iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoord1iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoord1s5(void* ptr, short s)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoord1s(s);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoord1sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoord1sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoord2f5(void* ptr, float s, float t)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoord2f(s, t);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoord2fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoord2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoord2i5(void* ptr, int s, int t)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoord2i(s, t);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoord2iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoord2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoord2s5(void* ptr, short s, short t)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoord2s(s, t);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoord2sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoord2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoord3f5(void* ptr, float s, float t, float r)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoord3f(s, t, r);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoord3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoord3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoord3i5(void* ptr, int s, int t, int r)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoord3i(s, t, r);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoord3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoord3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoord3s5(void* ptr, short s, short t, short r)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoord3s(s, t, r);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoord3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoord3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoord4f5(void* ptr, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoord4f(s, t, r, q);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoord4fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoord4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoord4i5(void* ptr, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoord4i(s, t, r, q);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoord4iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoord4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoord4s5(void* ptr, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoord4s(s, t, r, q);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoord4sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoord4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoordP1ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoordP1ui(ty, coords);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoordP1uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoordP1uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoordP2ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoordP2ui(ty, coords);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoordP2uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoordP2uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoordP3ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoordP3ui(ty, coords);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoordP3uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoordP3uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoordP4ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoordP4ui(ty, coords);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoordP4uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoordP4uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_3_Compatibility_GlTexCoordPointer5(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexCoordPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexEnvf5(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexEnvf(target, pname, param);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexEnvfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexEnvfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_3_Compatibility_GlTexEnvi5(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexEnvi(target, pname, param);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexEnviv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexEnviv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_3_Compatibility_GlTexGenf5(void* ptr, unsigned int coord, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexGenf(coord, pname, param);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexGenfv5(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexGenfv(coord, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_3_Compatibility_GlTexGeni5(void* ptr, unsigned int coord, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexGeni(coord, pname, param);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexGeniv5(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexGeniv(coord, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_3_Compatibility_GlTexImage1D5(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexImage2D5(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexImage2DMultisample5(void* ptr, unsigned int target, int samples, int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexImage3D5(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexImage3DMultisample5(void* ptr, unsigned int target, int samples, int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexParameterIiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexParameterIiv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_3_Compatibility_GlTexParameterIuiv5(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexParameterIuiv(target, pname, const_cast<const GLuint*>(&params));
}
void QOpenGLFunctions_4_3_Compatibility_GlTexParameterf5(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_3_Compatibility_GlTexParameteri5(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_3_Compatibility_GlTexStorage1D5(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexStorage1D(target, levels, internalformat, width);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexStorage2D5(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexStorage2D(target, levels, internalformat, width, height);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexStorage2DMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexStorage3D5(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width, int height, int depth)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexStorage3D(target, levels, internalformat, width, height, depth);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexStorage3DMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_3_Compatibility_GlTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_4_3_Compatibility_GlTextureView5(void* ptr, unsigned int texture, unsigned int target, unsigned int origtexture, unsigned int internalformat, unsigned int minlevel, unsigned int numlevels, unsigned int minlayer, unsigned int numlayers)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
}
void QOpenGLFunctions_4_3_Compatibility_GlTranslatef5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glTranslatef(x, y, z);
}
void QOpenGLFunctions_4_3_Compatibility_GlUniform1f5(void* ptr, int location, float v0)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniform1f(location, v0);
}
void QOpenGLFunctions_4_3_Compatibility_GlUniform1fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniform1fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlUniform1i5(void* ptr, int location, int v0)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniform1i(location, v0);
}
void QOpenGLFunctions_4_3_Compatibility_GlUniform1iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniform1iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlUniform1ui5(void* ptr, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniform1ui(location, v0);
}
void QOpenGLFunctions_4_3_Compatibility_GlUniform1uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniform1uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlUniform2f5(void* ptr, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniform2f(location, v0, v1);
}
void QOpenGLFunctions_4_3_Compatibility_GlUniform2fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniform2fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlUniform2i5(void* ptr, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniform2i(location, v0, v1);
}
void QOpenGLFunctions_4_3_Compatibility_GlUniform2iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniform2iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlUniform2ui5(void* ptr, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniform2ui(location, v0, v1);
}
void QOpenGLFunctions_4_3_Compatibility_GlUniform2uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniform2uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlUniform3f5(void* ptr, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniform3f(location, v0, v1, v2);
}
void QOpenGLFunctions_4_3_Compatibility_GlUniform3fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniform3fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlUniform3i5(void* ptr, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniform3i(location, v0, v1, v2);
}
void QOpenGLFunctions_4_3_Compatibility_GlUniform3iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniform3iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlUniform3ui5(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniform3ui(location, v0, v1, v2);
}
void QOpenGLFunctions_4_3_Compatibility_GlUniform3uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniform3uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlUniform4f5(void* ptr, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniform4f(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_3_Compatibility_GlUniform4fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniform4fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlUniform4i5(void* ptr, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniform4i(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_3_Compatibility_GlUniform4iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniform4iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlUniform4ui5(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniform4ui(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_3_Compatibility_GlUniform4uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniform4uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlUniformBlockBinding5(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int uniformBlockBinding)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}
void QOpenGLFunctions_4_3_Compatibility_GlUniformMatrix2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniformMatrix2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlUniformMatrix2x3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniformMatrix2x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlUniformMatrix2x4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniformMatrix2x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlUniformMatrix3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniformMatrix3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlUniformMatrix3x2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniformMatrix3x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlUniformMatrix3x4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniformMatrix3x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlUniformMatrix4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniformMatrix4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlUniformMatrix4x2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniformMatrix4x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlUniformMatrix4x3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniformMatrix4x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlUniformSubroutinesuiv5(void* ptr, unsigned int shadertype, int count, unsigned int indices)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUniformSubroutinesuiv(shadertype, count, const_cast<const GLuint*>(&indices));
}
void QOpenGLFunctions_4_3_Compatibility_GlUseProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUseProgram(program);
}
void QOpenGLFunctions_4_3_Compatibility_GlUseProgramStages5(void* ptr, unsigned int pipeline, unsigned int stages, unsigned int program)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glUseProgramStages(pipeline, stages, program);
}
void QOpenGLFunctions_4_3_Compatibility_GlValidateProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glValidateProgram(program);
}
void QOpenGLFunctions_4_3_Compatibility_GlValidateProgramPipeline5(void* ptr, unsigned int pipeline)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glValidateProgramPipeline(pipeline);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertex2f5(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertex2f(x, y);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertex2fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertex2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertex2i5(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertex2i(x, y);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertex2iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertex2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertex2s5(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertex2s(x, y);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertex2sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertex2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertex3f5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertex3f(x, y, z);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertex3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertex3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertex3i5(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertex3i(x, y, z);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertex3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertex3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertex3s5(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertex3s(x, y, z);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertex3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertex3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertex4f5(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertex4f(x, y, z, w);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertex4fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertex4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertex4i5(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertex4i(x, y, z, w);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertex4iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertex4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertex4s5(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertex4s(x, y, z, w);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertex4sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertex4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib1f5(void* ptr, unsigned int index, float x)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib1f(index, x);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib1fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib1fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib1s5(void* ptr, unsigned int index, short x)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib1s(index, x);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib1sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib1sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib2f5(void* ptr, unsigned int index, float x, float y)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib2f(index, x, y);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib2fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib2fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib2s5(void* ptr, unsigned int index, short x, short y)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib2s(index, x, y);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib2sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib2sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib3f5(void* ptr, unsigned int index, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib3f(index, x, y, z);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib3fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib3fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib3s5(void* ptr, unsigned int index, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib3s(index, x, y, z);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib3sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib3sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib4Niv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib4Niv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib4Nsv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib4Nsv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib4Nub5(void* ptr, unsigned int index, char* x, char* y, char* z, char* w)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib4Nub(index, *static_cast<GLubyte*>(static_cast<void*>(x)), *static_cast<GLubyte*>(static_cast<void*>(y)), *static_cast<GLubyte*>(static_cast<void*>(z)), *static_cast<GLubyte*>(static_cast<void*>(w)));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib4Nubv5(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib4Nubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib4Nuiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib4Nuiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib4Nusv5(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib4Nusv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib4f5(void* ptr, unsigned int index, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib4f(index, x, y, z, w);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib4fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib4fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib4iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib4s5(void* ptr, unsigned int index, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib4s(index, x, y, z, w);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib4sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib4sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib4ubv5(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib4ubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib4uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttrib4usv5(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttrib4usv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribBinding5(void* ptr, unsigned int attribindex, unsigned int bindingindex)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribBinding(attribindex, bindingindex);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribDivisor5(void* ptr, unsigned int index, unsigned int divisor)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribDivisor(index, divisor);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribFormat5(void* ptr, unsigned int attribindex, int size, unsigned int ty, char normalized, unsigned int relativeoffset)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribFormat(attribindex, size, ty, normalized != 0, relativeoffset);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribI1i5(void* ptr, unsigned int index, int x)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribI1i(index, x);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribI1iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribI1iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribI1ui5(void* ptr, unsigned int index, unsigned int x)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribI1ui(index, x);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribI1uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribI1uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribI2i5(void* ptr, unsigned int index, int x, int y)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribI2i(index, x, y);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribI2iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribI2iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribI2ui5(void* ptr, unsigned int index, unsigned int x, unsigned int y)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribI2ui(index, x, y);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribI2uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribI2uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribI3i5(void* ptr, unsigned int index, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribI3i(index, x, y, z);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribI3iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribI3iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribI3ui5(void* ptr, unsigned int index, unsigned int x, unsigned int y, unsigned int z)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribI3ui(index, x, y, z);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribI3uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribI3uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribI4i5(void* ptr, unsigned int index, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribI4i(index, x, y, z, w);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribI4iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribI4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribI4sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribI4sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribI4ubv5(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribI4ubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribI4ui5(void* ptr, unsigned int index, unsigned int x, unsigned int y, unsigned int z, unsigned int w)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribI4ui(index, x, y, z, w);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribI4uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribI4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribI4usv5(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribI4usv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribIFormat5(void* ptr, unsigned int attribindex, int size, unsigned int ty, unsigned int relativeoffset)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribIFormat(attribindex, size, ty, relativeoffset);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribIPointer5(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribIPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribLFormat5(void* ptr, unsigned int attribindex, int size, unsigned int ty, unsigned int relativeoffset)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribLFormat(attribindex, size, ty, relativeoffset);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribLPointer5(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribLPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribP1ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribP1ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribP1uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribP1uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribP2ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribP2ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribP2uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribP2uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribP3ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribP3ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribP3uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribP3uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribP4ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribP4ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribP4uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribP4uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexAttribPointer5(void* ptr, unsigned int index, int size, unsigned int ty, char normalized, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexAttribPointer(index, size, ty, normalized != 0, stride, pointer);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexBindingDivisor5(void* ptr, unsigned int bindingindex, unsigned int divisor)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexBindingDivisor(bindingindex, divisor);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexP2ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexP2ui(ty, value);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexP2uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexP2uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexP3ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexP3ui(ty, value);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexP3uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexP3uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexP4ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexP4ui(ty, value);
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexP4uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexP4uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Compatibility_GlVertexPointer5(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glVertexPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_4_3_Compatibility_GlViewport5(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_4_3_Compatibility_GlViewportArrayv5(void* ptr, unsigned int first, int count, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glViewportArrayv(first, count, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlViewportIndexedf5(void* ptr, unsigned int index, float x, float y, float w, float h)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glViewportIndexedf(index, x, y, w, h);
}
void QOpenGLFunctions_4_3_Compatibility_GlViewportIndexedfv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glViewportIndexedfv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlWindowPos2f5(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glWindowPos2f(x, y);
}
void QOpenGLFunctions_4_3_Compatibility_GlWindowPos2fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glWindowPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlWindowPos2i5(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glWindowPos2i(x, y);
}
void QOpenGLFunctions_4_3_Compatibility_GlWindowPos2iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glWindowPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlWindowPos2s5(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glWindowPos2s(x, y);
}
void QOpenGLFunctions_4_3_Compatibility_GlWindowPos2sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glWindowPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlWindowPos3f5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glWindowPos3f(x, y, z);
}
void QOpenGLFunctions_4_3_Compatibility_GlWindowPos3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glWindowPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlWindowPos3i5(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glWindowPos3i(x, y, z);
}
void QOpenGLFunctions_4_3_Compatibility_GlWindowPos3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glWindowPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_GlWindowPos3s5(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glWindowPos3s(x, y, z);
}
void QOpenGLFunctions_4_3_Compatibility_GlWindowPos3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glWindowPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_3_Compatibility_DestroyQOpenGLFunctions_4_3_Compatibility5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->~QOpenGLFunctions_4_3_Compatibility();
}
void QOpenGLFunctions_4_3_Compatibility_DestroyQOpenGLFunctions_4_3_Compatibility5Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_4_3_Core: public QOpenGLFunctions_4_3_Core
{
public:
MyQOpenGLFunctions_4_3_Core() : QOpenGLFunctions_4_3_Core() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_4_3_Core_InitializeOpenGLFunctions5(this) != 0; };
~MyQOpenGLFunctions_4_3_Core() { callbackQOpenGLFunctions_4_3_Core_DestroyQOpenGLFunctions_4_3_Core5(this); };
};
char QOpenGLFunctions_4_3_Core_GlIsBuffer5(void* ptr, unsigned int buffer)
{
return static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glIsBuffer(buffer);
}
char QOpenGLFunctions_4_3_Core_GlIsEnabled5(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_4_3_Core_GlIsEnabledi5(void* ptr, unsigned int target, unsigned int index)
{
return static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glIsEnabledi(target, index);
}
char QOpenGLFunctions_4_3_Core_GlIsFramebuffer5(void* ptr, unsigned int framebuffer)
{
return static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glIsFramebuffer(framebuffer);
}
char QOpenGLFunctions_4_3_Core_GlIsProgram5(void* ptr, unsigned int program)
{
return static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glIsProgram(program);
}
char QOpenGLFunctions_4_3_Core_GlIsProgramPipeline5(void* ptr, unsigned int pipeline)
{
return static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glIsProgramPipeline(pipeline);
}
char QOpenGLFunctions_4_3_Core_GlIsQuery5(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glIsQuery(id);
}
char QOpenGLFunctions_4_3_Core_GlIsRenderbuffer5(void* ptr, unsigned int renderbuffer)
{
return static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glIsRenderbuffer(renderbuffer);
}
char QOpenGLFunctions_4_3_Core_GlIsSampler5(void* ptr, unsigned int sampler)
{
return static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glIsSampler(sampler);
}
char QOpenGLFunctions_4_3_Core_GlIsShader5(void* ptr, unsigned int shader)
{
return static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glIsShader(shader);
}
char QOpenGLFunctions_4_3_Core_GlIsTexture5(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glIsTexture(texture);
}
char QOpenGLFunctions_4_3_Core_GlIsTransformFeedback5(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glIsTransformFeedback(id);
}
char QOpenGLFunctions_4_3_Core_GlIsVertexArray5(void* ptr, unsigned int array)
{
return static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glIsVertexArray(array);
}
char QOpenGLFunctions_4_3_Core_GlUnmapBuffer5(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUnmapBuffer(target);
}
unsigned int QOpenGLFunctions_4_3_Core_GlCheckFramebufferStatus5(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glCheckFramebufferStatus(target);
}
unsigned int QOpenGLFunctions_4_3_Core_GlGetError5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetError();
}
unsigned int QOpenGLFunctions_4_3_Core_GlCreateProgram5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glCreateProgram();
}
unsigned int QOpenGLFunctions_4_3_Core_GlCreateShader5(void* ptr, unsigned int ty)
{
return static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glCreateShader(ty);
}
void* QOpenGLFunctions_4_3_Core_GlMapBuffer5(void* ptr, unsigned int target, unsigned int access)
{
return static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glMapBuffer(target, access);
}
void* QOpenGLFunctions_4_3_Core_NewQOpenGLFunctions_4_3_Core5()
{
return new MyQOpenGLFunctions_4_3_Core();
}
char QOpenGLFunctions_4_3_Core_InitializeOpenGLFunctions5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_4_3_Core_InitializeOpenGLFunctions5Default(void* ptr)
{
return static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->QOpenGLFunctions_4_3_Core::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_4_3_Core_GlGetString5(void* ptr, unsigned int name)
{
return ({ char* t9897b7 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetString(name)))); QtGui_PackedString { t9897b7, -1 }; });
}
struct QtGui_PackedString QOpenGLFunctions_4_3_Core_GlGetStringi5(void* ptr, unsigned int name, unsigned int index)
{
return ({ char* t0363b0 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetStringi(name, index)))); QtGui_PackedString { t0363b0, -1 }; });
}
void QOpenGLFunctions_4_3_Core_GlActiveShaderProgram5(void* ptr, unsigned int pipeline, unsigned int program)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glActiveShaderProgram(pipeline, program);
}
void QOpenGLFunctions_4_3_Core_GlActiveTexture5(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glActiveTexture(texture);
}
void QOpenGLFunctions_4_3_Core_GlAttachShader5(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glAttachShader(program, shader);
}
void QOpenGLFunctions_4_3_Core_GlBeginConditionalRender5(void* ptr, unsigned int id, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glBeginConditionalRender(id, mode);
}
void QOpenGLFunctions_4_3_Core_GlBeginQuery5(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glBeginQuery(target, id);
}
void QOpenGLFunctions_4_3_Core_GlBeginQueryIndexed5(void* ptr, unsigned int target, unsigned int index, unsigned int id)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glBeginQueryIndexed(target, index, id);
}
void QOpenGLFunctions_4_3_Core_GlBeginTransformFeedback5(void* ptr, unsigned int primitiveMode)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glBeginTransformFeedback(primitiveMode);
}
void QOpenGLFunctions_4_3_Core_GlBindBuffer5(void* ptr, unsigned int target, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glBindBuffer(target, buffer);
}
void QOpenGLFunctions_4_3_Core_GlBindBufferBase5(void* ptr, unsigned int target, unsigned int index, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glBindBufferBase(target, index, buffer);
}
void QOpenGLFunctions_4_3_Core_GlBindFramebuffer5(void* ptr, unsigned int target, unsigned int framebuffer)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glBindFramebuffer(target, framebuffer);
}
void QOpenGLFunctions_4_3_Core_GlBindImageTexture5(void* ptr, unsigned int unit, unsigned int texture, int level, char layered, int layer, unsigned int access, unsigned int format)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glBindImageTexture(unit, texture, level, layered != 0, layer, access, format);
}
void QOpenGLFunctions_4_3_Core_GlBindProgramPipeline5(void* ptr, unsigned int pipeline)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glBindProgramPipeline(pipeline);
}
void QOpenGLFunctions_4_3_Core_GlBindRenderbuffer5(void* ptr, unsigned int target, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glBindRenderbuffer(target, renderbuffer);
}
void QOpenGLFunctions_4_3_Core_GlBindSampler5(void* ptr, unsigned int unit, unsigned int sampler)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glBindSampler(unit, sampler);
}
void QOpenGLFunctions_4_3_Core_GlBindTexture5(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_4_3_Core_GlBindTransformFeedback5(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glBindTransformFeedback(target, id);
}
void QOpenGLFunctions_4_3_Core_GlBindVertexArray5(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glBindVertexArray(array);
}
void QOpenGLFunctions_4_3_Core_GlBlendColor5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_4_3_Core_GlBlendEquation5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_4_3_Core_GlBlendEquationSeparate5(void* ptr, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glBlendEquationSeparate(modeRGB, modeAlpha);
}
void QOpenGLFunctions_4_3_Core_GlBlendEquationSeparatei5(void* ptr, unsigned int buf, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glBlendEquationSeparatei(buf, modeRGB, modeAlpha);
}
void QOpenGLFunctions_4_3_Core_GlBlendEquationi5(void* ptr, unsigned int buf, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glBlendEquationi(buf, mode);
}
void QOpenGLFunctions_4_3_Core_GlBlendFunc5(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_4_3_Core_GlBlendFuncSeparate5(void* ptr, unsigned int sfactorRGB, unsigned int dfactorRGB, unsigned int sfactorAlpha, unsigned int dfactorAlpha)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void QOpenGLFunctions_4_3_Core_GlBlendFuncSeparatei5(void* ptr, unsigned int buf, unsigned int srcRGB, unsigned int dstRGB, unsigned int srcAlpha, unsigned int dstAlpha)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
void QOpenGLFunctions_4_3_Core_GlBlendFunci5(void* ptr, unsigned int buf, unsigned int src, unsigned int dst)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glBlendFunci(buf, src, dst);
}
void QOpenGLFunctions_4_3_Core_GlBlitFramebuffer5(void* ptr, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, unsigned int mask, unsigned int filter)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
void QOpenGLFunctions_4_3_Core_GlClampColor5(void* ptr, unsigned int target, unsigned int clamp)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glClampColor(target, clamp);
}
void QOpenGLFunctions_4_3_Core_GlClear5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_4_3_Core_GlClearBufferData5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glClearBufferData(target, internalformat, format, ty, data);
}
void QOpenGLFunctions_4_3_Core_GlClearBufferfi5(void* ptr, unsigned int buffer, int drawbuffer, float depth, int stencil)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glClearBufferfi(buffer, drawbuffer, depth, stencil);
}
void QOpenGLFunctions_4_3_Core_GlClearBufferfv5(void* ptr, unsigned int buffer, int drawbuffer, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glClearBufferfv(buffer, drawbuffer, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlClearBufferiv5(void* ptr, unsigned int buffer, int drawbuffer, int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glClearBufferiv(buffer, drawbuffer, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlClearBufferuiv5(void* ptr, unsigned int buffer, int drawbuffer, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glClearBufferuiv(buffer, drawbuffer, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlClearColor5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_4_3_Core_GlClearDepthf5(void* ptr, float dd)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glClearDepthf(dd);
}
void QOpenGLFunctions_4_3_Core_GlClearStencil5(void* ptr, int s)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_4_3_Core_GlColorMask5(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_4_3_Core_GlColorMaski5(void* ptr, unsigned int index, char r, char g, char b, char a)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glColorMaski(index, r != 0, g != 0, b != 0, a != 0);
}
void QOpenGLFunctions_4_3_Core_GlColorP3ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glColorP3ui(ty, color);
}
void QOpenGLFunctions_4_3_Core_GlColorP3uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glColorP3uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_3_Core_GlColorP4ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glColorP4ui(ty, color);
}
void QOpenGLFunctions_4_3_Core_GlColorP4uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glColorP4uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_3_Core_GlCompileShader5(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glCompileShader(shader);
}
void QOpenGLFunctions_4_3_Core_GlCompressedTexImage1D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
void QOpenGLFunctions_4_3_Core_GlCompressedTexImage2D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void QOpenGLFunctions_4_3_Core_GlCompressedTexImage3D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int depth, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void QOpenGLFunctions_4_3_Core_GlCompressedTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_4_3_Core_GlCompressedTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_4_3_Core_GlCompressedTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_4_3_Core_GlCopyImageSubData5(void* ptr, unsigned int srcName, unsigned int srcTarget, int srcLevel, int srcX, int srcY, int srcZ, unsigned int dstName, unsigned int dstTarget, int dstLevel, int dstX, int dstY, int dstZ, int srcWidth, int srcHeight, int srcDepth)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
}
void QOpenGLFunctions_4_3_Core_GlCopyTexImage1D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_4_3_Core_GlCopyTexImage2D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_4_3_Core_GlCopyTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_4_3_Core_GlCopyTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_4_3_Core_GlCopyTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_4_3_Core_GlCullFace5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_4_3_Core_GlDeleteBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDeleteBuffers(n, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_4_3_Core_GlDeleteFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDeleteFramebuffers(n, const_cast<const GLuint*>(&framebuffers));
}
void QOpenGLFunctions_4_3_Core_GlDeleteProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDeleteProgram(program);
}
void QOpenGLFunctions_4_3_Core_GlDeleteProgramPipelines5(void* ptr, int n, unsigned int pipelines)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDeleteProgramPipelines(n, const_cast<const GLuint*>(&pipelines));
}
void QOpenGLFunctions_4_3_Core_GlDeleteQueries5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDeleteQueries(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_4_3_Core_GlDeleteRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDeleteRenderbuffers(n, const_cast<const GLuint*>(&renderbuffers));
}
void QOpenGLFunctions_4_3_Core_GlDeleteSamplers5(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDeleteSamplers(count, const_cast<const GLuint*>(&samplers));
}
void QOpenGLFunctions_4_3_Core_GlDeleteShader5(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDeleteShader(shader);
}
void QOpenGLFunctions_4_3_Core_GlDeleteTextures5(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_4_3_Core_GlDeleteTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDeleteTransformFeedbacks(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_4_3_Core_GlDeleteVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDeleteVertexArrays(n, const_cast<const GLuint*>(&arrays));
}
void QOpenGLFunctions_4_3_Core_GlDepthFunc5(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_4_3_Core_GlDepthMask5(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_4_3_Core_GlDepthRangef5(void* ptr, float n, float fo)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDepthRangef(n, fo);
}
void QOpenGLFunctions_4_3_Core_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDetachShader(program, shader);
}
void QOpenGLFunctions_4_3_Core_GlDisable5(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_4_3_Core_GlDisableVertexAttribArray5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDisableVertexAttribArray(index);
}
void QOpenGLFunctions_4_3_Core_GlDisablei5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDisablei(target, index);
}
void QOpenGLFunctions_4_3_Core_GlDispatchCompute5(void* ptr, unsigned int num_groups_x, unsigned int num_groups_y, unsigned int num_groups_z)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
}
void QOpenGLFunctions_4_3_Core_GlDrawArrays5(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_4_3_Core_GlDrawArraysIndirect5(void* ptr, unsigned int mode, void* indirect)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDrawArraysIndirect(mode, indirect);
}
void QOpenGLFunctions_4_3_Core_GlDrawArraysInstanced5(void* ptr, unsigned int mode, int first, int count, int instancecount)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDrawArraysInstanced(mode, first, count, instancecount);
}
void QOpenGLFunctions_4_3_Core_GlDrawArraysInstancedBaseInstance5(void* ptr, unsigned int mode, int first, int count, int instancecount, unsigned int baseinstance)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
}
void QOpenGLFunctions_4_3_Core_GlDrawBuffer5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDrawBuffer(mode);
}
void QOpenGLFunctions_4_3_Core_GlDrawBuffers5(void* ptr, int n, unsigned int bufs)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDrawBuffers(n, const_cast<const GLenum*>(&bufs));
}
void QOpenGLFunctions_4_3_Core_GlDrawElements5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_4_3_Core_GlDrawElementsBaseVertex5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDrawElementsBaseVertex(mode, count, ty, indices, basevertex);
}
void QOpenGLFunctions_4_3_Core_GlDrawElementsIndirect5(void* ptr, unsigned int mode, unsigned int ty, void* indirect)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDrawElementsIndirect(mode, ty, indirect);
}
void QOpenGLFunctions_4_3_Core_GlDrawElementsInstanced5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDrawElementsInstanced(mode, count, ty, indices, instancecount);
}
void QOpenGLFunctions_4_3_Core_GlDrawElementsInstancedBaseInstance5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, unsigned int baseinstance)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDrawElementsInstancedBaseInstance(mode, count, ty, indices, instancecount, baseinstance);
}
void QOpenGLFunctions_4_3_Core_GlDrawElementsInstancedBaseVertex5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDrawElementsInstancedBaseVertex(mode, count, ty, indices, instancecount, basevertex);
}
void QOpenGLFunctions_4_3_Core_GlDrawElementsInstancedBaseVertexBaseInstance5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex, unsigned int baseinstance)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDrawElementsInstancedBaseVertexBaseInstance(mode, count, ty, indices, instancecount, basevertex, baseinstance);
}
void QOpenGLFunctions_4_3_Core_GlDrawRangeElements5(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLFunctions_4_3_Core_GlDrawRangeElementsBaseVertex5(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDrawRangeElementsBaseVertex(mode, start, end, count, ty, indices, basevertex);
}
void QOpenGLFunctions_4_3_Core_GlDrawTransformFeedback5(void* ptr, unsigned int mode, unsigned int id)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDrawTransformFeedback(mode, id);
}
void QOpenGLFunctions_4_3_Core_GlDrawTransformFeedbackInstanced5(void* ptr, unsigned int mode, unsigned int id, int instancecount)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDrawTransformFeedbackInstanced(mode, id, instancecount);
}
void QOpenGLFunctions_4_3_Core_GlDrawTransformFeedbackStream5(void* ptr, unsigned int mode, unsigned int id, unsigned int stream)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDrawTransformFeedbackStream(mode, id, stream);
}
void QOpenGLFunctions_4_3_Core_GlDrawTransformFeedbackStreamInstanced5(void* ptr, unsigned int mode, unsigned int id, unsigned int stream, int instancecount)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
}
void QOpenGLFunctions_4_3_Core_GlEnable5(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_4_3_Core_GlEnableVertexAttribArray5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glEnableVertexAttribArray(index);
}
void QOpenGLFunctions_4_3_Core_GlEnablei5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glEnablei(target, index);
}
void QOpenGLFunctions_4_3_Core_GlEndConditionalRender5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glEndConditionalRender();
}
void QOpenGLFunctions_4_3_Core_GlEndQuery5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glEndQuery(target);
}
void QOpenGLFunctions_4_3_Core_GlEndQueryIndexed5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glEndQueryIndexed(target, index);
}
void QOpenGLFunctions_4_3_Core_GlEndTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glEndTransformFeedback();
}
void QOpenGLFunctions_4_3_Core_GlFinish5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glFinish();
}
void QOpenGLFunctions_4_3_Core_GlFlush5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glFlush();
}
void QOpenGLFunctions_4_3_Core_GlFramebufferParameteri5(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glFramebufferParameteri(target, pname, param);
}
void QOpenGLFunctions_4_3_Core_GlFramebufferRenderbuffer5(void* ptr, unsigned int target, unsigned int attachment, unsigned int renderbuffertarget, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
void QOpenGLFunctions_4_3_Core_GlFramebufferTexture5(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glFramebufferTexture(target, attachment, texture, level);
}
void QOpenGLFunctions_4_3_Core_GlFramebufferTexture1D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glFramebufferTexture1D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_4_3_Core_GlFramebufferTexture2D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_4_3_Core_GlFramebufferTexture3D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level, int zoffset)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}
void QOpenGLFunctions_4_3_Core_GlFramebufferTextureLayer5(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level, int layer)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glFramebufferTextureLayer(target, attachment, texture, level, layer);
}
void QOpenGLFunctions_4_3_Core_GlFrontFace5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_4_3_Core_GlGenBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGenBuffers(n, &buffers);
}
void QOpenGLFunctions_4_3_Core_GlGenFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGenFramebuffers(n, &framebuffers);
}
void QOpenGLFunctions_4_3_Core_GlGenProgramPipelines5(void* ptr, int n, unsigned int pipelines)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGenProgramPipelines(n, &pipelines);
}
void QOpenGLFunctions_4_3_Core_GlGenQueries5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGenQueries(n, &ids);
}
void QOpenGLFunctions_4_3_Core_GlGenRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGenRenderbuffers(n, &renderbuffers);
}
void QOpenGLFunctions_4_3_Core_GlGenSamplers5(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGenSamplers(count, &samplers);
}
void QOpenGLFunctions_4_3_Core_GlGenTextures5(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_4_3_Core_GlGenTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGenTransformFeedbacks(n, &ids);
}
void QOpenGLFunctions_4_3_Core_GlGenVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGenVertexArrays(n, &arrays);
}
void QOpenGLFunctions_4_3_Core_GlGenerateMipmap5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGenerateMipmap(target);
}
void QOpenGLFunctions_4_3_Core_GlGetActiveAtomicCounterBufferiv5(void* ptr, unsigned int program, unsigned int bufferIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetActiveAtomicCounterBufferiv(program, bufferIndex, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetActiveSubroutineUniformiv5(void* ptr, unsigned int program, unsigned int shadertype, unsigned int index, unsigned int pname, int values)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetActiveSubroutineUniformiv(program, shadertype, index, pname, &values);
}
void QOpenGLFunctions_4_3_Core_GlGetActiveUniformBlockiv5(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetActiveUniformsiv5(void* ptr, unsigned int program, int uniformCount, unsigned int uniformIndices, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetActiveUniformsiv(program, uniformCount, const_cast<const GLuint*>(&uniformIndices), pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetAttachedShaders5(void* ptr, unsigned int program, int maxCount, int count, unsigned int obj)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetAttachedShaders(program, maxCount, &count, &obj);
}
void QOpenGLFunctions_4_3_Core_GlGetBooleani_v5(void* ptr, unsigned int target, unsigned int index, char data)
{
Q_UNUSED(data);
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetBooleani_v(target, index, NULL);
}
void QOpenGLFunctions_4_3_Core_GlGetBooleanv5(void* ptr, unsigned int pname, char params)
{
Q_UNUSED(params);
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_4_3_Core_GlGetBufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetBufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetBufferPointerv5(void* ptr, unsigned int target, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetBufferPointerv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetCompressedTexImage5(void* ptr, unsigned int target, int level, void* img)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetCompressedTexImage(target, level, img);
}
void QOpenGLFunctions_4_3_Core_GlGetFloati_v5(void* ptr, unsigned int target, unsigned int index, float data)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetFloati_v(target, index, &data);
}
void QOpenGLFunctions_4_3_Core_GlGetFloatv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetFloatv(pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetFramebufferAttachmentParameteriv5(void* ptr, unsigned int target, unsigned int attachment, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetFramebufferAttachmentParameteriv(target, attachment, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetFramebufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetFramebufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetIntegeri_v5(void* ptr, unsigned int target, unsigned int index, int data)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetIntegeri_v(target, index, &data);
}
void QOpenGLFunctions_4_3_Core_GlGetIntegerv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetIntegerv(pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetInternalformativ5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int pname, int bufSize, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetInternalformativ(target, internalformat, pname, bufSize, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetMultisamplefv5(void* ptr, unsigned int pname, unsigned int index, float val)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetMultisamplefv(pname, index, &val);
}
void QOpenGLFunctions_4_3_Core_GlGetPointerv5(void* ptr, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetPointerv(pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetProgramBinary5(void* ptr, unsigned int program, int bufSize, int length, unsigned int binaryFormat, void* binary)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetProgramBinary(program, bufSize, &length, &binaryFormat, binary);
}
void QOpenGLFunctions_4_3_Core_GlGetProgramInterfaceiv5(void* ptr, unsigned int program, unsigned int programInterface, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetProgramInterfaceiv(program, programInterface, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetProgramPipelineiv5(void* ptr, unsigned int pipeline, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetProgramPipelineiv(pipeline, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetProgramResourceiv5(void* ptr, unsigned int program, unsigned int programInterface, unsigned int index, int propCount, unsigned int props, int bufSize, int length, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetProgramResourceiv(program, programInterface, index, propCount, const_cast<const GLenum*>(&props), bufSize, &length, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetProgramStageiv5(void* ptr, unsigned int program, unsigned int shadertype, unsigned int pname, int values)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetProgramStageiv(program, shadertype, pname, &values);
}
void QOpenGLFunctions_4_3_Core_GlGetProgramiv5(void* ptr, unsigned int program, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetProgramiv(program, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetQueryIndexediv5(void* ptr, unsigned int target, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetQueryIndexediv(target, index, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetQueryObjectiv5(void* ptr, unsigned int id, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetQueryObjectiv(id, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetQueryObjectuiv5(void* ptr, unsigned int id, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetQueryObjectuiv(id, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetQueryiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetQueryiv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetRenderbufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetRenderbufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetSamplerParameterIiv5(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetSamplerParameterIiv(sampler, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetSamplerParameterIuiv5(void* ptr, unsigned int sampler, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetSamplerParameterIuiv(sampler, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetSamplerParameterfv5(void* ptr, unsigned int sampler, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetSamplerParameterfv(sampler, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetSamplerParameteriv5(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetSamplerParameteriv(sampler, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetShaderPrecisionFormat5(void* ptr, unsigned int shadertype, unsigned int precisiontype, int ran, int precision)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetShaderPrecisionFormat(shadertype, precisiontype, &ran, &precision);
}
void QOpenGLFunctions_4_3_Core_GlGetShaderiv5(void* ptr, unsigned int shader, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetShaderiv(shader, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetTexImage5(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_4_3_Core_GlGetTexLevelParameterfv5(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetTexLevelParameteriv5(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetTexParameterIiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetTexParameterIiv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetTexParameterIuiv5(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetTexParameterIuiv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetTexParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetTexParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetUniformSubroutineuiv5(void* ptr, unsigned int shadertype, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetUniformSubroutineuiv(shadertype, location, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetUniformfv5(void* ptr, unsigned int program, int location, float params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetUniformfv(program, location, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetUniformiv5(void* ptr, unsigned int program, int location, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetUniformiv(program, location, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetUniformuiv5(void* ptr, unsigned int program, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetUniformuiv(program, location, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetVertexAttribIiv5(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetVertexAttribIiv(index, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetVertexAttribIuiv5(void* ptr, unsigned int index, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetVertexAttribIuiv(index, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetVertexAttribPointerv5(void* ptr, unsigned int index, unsigned int pname, void* pointer)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetVertexAttribPointerv(index, pname, &pointer);
}
void QOpenGLFunctions_4_3_Core_GlGetVertexAttribfv5(void* ptr, unsigned int index, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetVertexAttribfv(index, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlGetVertexAttribiv5(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glGetVertexAttribiv(index, pname, &params);
}
void QOpenGLFunctions_4_3_Core_GlHint5(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_4_3_Core_GlIndexub5(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glIndexub(*static_cast<GLubyte*>(static_cast<void*>(c)));
}
void QOpenGLFunctions_4_3_Core_GlIndexubv5(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glIndexubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(c))));
}
void QOpenGLFunctions_4_3_Core_GlInvalidateBufferData5(void* ptr, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glInvalidateBufferData(buffer);
}
void QOpenGLFunctions_4_3_Core_GlInvalidateFramebuffer5(void* ptr, unsigned int target, int numAttachments, unsigned int attachments)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glInvalidateFramebuffer(target, numAttachments, const_cast<const GLenum*>(&attachments));
}
void QOpenGLFunctions_4_3_Core_GlInvalidateSubFramebuffer5(void* ptr, unsigned int target, int numAttachments, unsigned int attachments, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glInvalidateSubFramebuffer(target, numAttachments, const_cast<const GLenum*>(&attachments), x, y, width, height);
}
void QOpenGLFunctions_4_3_Core_GlInvalidateTexImage5(void* ptr, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glInvalidateTexImage(texture, level);
}
void QOpenGLFunctions_4_3_Core_GlInvalidateTexSubImage5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glInvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
}
void QOpenGLFunctions_4_3_Core_GlLineWidth5(void* ptr, float width)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_4_3_Core_GlLinkProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glLinkProgram(program);
}
void QOpenGLFunctions_4_3_Core_GlLogicOp5(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_4_3_Core_GlMemoryBarrier5(void* ptr, unsigned int barriers)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glMemoryBarrier(barriers);
}
void QOpenGLFunctions_4_3_Core_GlMinSampleShading5(void* ptr, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glMinSampleShading(value);
}
void QOpenGLFunctions_4_3_Core_GlMultiDrawArrays5(void* ptr, unsigned int mode, int first, int count, int drawcount)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glMultiDrawArrays(mode, const_cast<const GLint*>(&first), const_cast<const GLsizei*>(&count), drawcount);
}
void QOpenGLFunctions_4_3_Core_GlMultiDrawArraysIndirect5(void* ptr, unsigned int mode, void* indirect, int drawcount, int stride)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glMultiDrawArraysIndirect(mode, indirect, drawcount, stride);
}
void QOpenGLFunctions_4_3_Core_GlMultiDrawElementsIndirect5(void* ptr, unsigned int mode, unsigned int ty, void* indirect, int drawcount, int stride)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glMultiDrawElementsIndirect(mode, ty, indirect, drawcount, stride);
}
void QOpenGLFunctions_4_3_Core_GlMultiTexCoordP1ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glMultiTexCoordP1ui(texture, ty, coords);
}
void QOpenGLFunctions_4_3_Core_GlMultiTexCoordP1uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glMultiTexCoordP1uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_3_Core_GlMultiTexCoordP2ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glMultiTexCoordP2ui(texture, ty, coords);
}
void QOpenGLFunctions_4_3_Core_GlMultiTexCoordP2uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glMultiTexCoordP2uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_3_Core_GlMultiTexCoordP3ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glMultiTexCoordP3ui(texture, ty, coords);
}
void QOpenGLFunctions_4_3_Core_GlMultiTexCoordP3uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glMultiTexCoordP3uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_3_Core_GlMultiTexCoordP4ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glMultiTexCoordP4ui(texture, ty, coords);
}
void QOpenGLFunctions_4_3_Core_GlMultiTexCoordP4uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glMultiTexCoordP4uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_3_Core_GlNormalP3ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glNormalP3ui(ty, coords);
}
void QOpenGLFunctions_4_3_Core_GlNormalP3uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glNormalP3uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_3_Core_GlPatchParameterfv5(void* ptr, unsigned int pname, float values)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glPatchParameterfv(pname, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_4_3_Core_GlPatchParameteri5(void* ptr, unsigned int pname, int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glPatchParameteri(pname, value);
}
void QOpenGLFunctions_4_3_Core_GlPauseTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glPauseTransformFeedback();
}
void QOpenGLFunctions_4_3_Core_GlPixelStoref5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_4_3_Core_GlPixelStorei5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_4_3_Core_GlPointParameterf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glPointParameterf(pname, param);
}
void QOpenGLFunctions_4_3_Core_GlPointParameterfv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glPointParameterfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_3_Core_GlPointParameteri5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glPointParameteri(pname, param);
}
void QOpenGLFunctions_4_3_Core_GlPointParameteriv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glPointParameteriv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_3_Core_GlPointSize5(void* ptr, float size)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_4_3_Core_GlPolygonMode5(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_4_3_Core_GlPolygonOffset5(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_4_3_Core_GlPrimitiveRestartIndex5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glPrimitiveRestartIndex(index);
}
void QOpenGLFunctions_4_3_Core_GlProgramBinary5(void* ptr, unsigned int program, unsigned int binaryFormat, void* binary, int length)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramBinary(program, binaryFormat, binary, length);
}
void QOpenGLFunctions_4_3_Core_GlProgramParameteri5(void* ptr, unsigned int program, unsigned int pname, int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramParameteri(program, pname, value);
}
void QOpenGLFunctions_4_3_Core_GlProgramUniform1f5(void* ptr, unsigned int program, int location, float v0)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniform1f(program, location, v0);
}
void QOpenGLFunctions_4_3_Core_GlProgramUniform1fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniform1fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlProgramUniform1i5(void* ptr, unsigned int program, int location, int v0)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniform1i(program, location, v0);
}
void QOpenGLFunctions_4_3_Core_GlProgramUniform1iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniform1iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlProgramUniform1ui5(void* ptr, unsigned int program, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniform1ui(program, location, v0);
}
void QOpenGLFunctions_4_3_Core_GlProgramUniform1uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniform1uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlProgramUniform2f5(void* ptr, unsigned int program, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniform2f(program, location, v0, v1);
}
void QOpenGLFunctions_4_3_Core_GlProgramUniform2fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniform2fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlProgramUniform2i5(void* ptr, unsigned int program, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniform2i(program, location, v0, v1);
}
void QOpenGLFunctions_4_3_Core_GlProgramUniform2iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniform2iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlProgramUniform2ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniform2ui(program, location, v0, v1);
}
void QOpenGLFunctions_4_3_Core_GlProgramUniform2uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniform2uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlProgramUniform3f5(void* ptr, unsigned int program, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniform3f(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_3_Core_GlProgramUniform3fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniform3fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlProgramUniform3i5(void* ptr, unsigned int program, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniform3i(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_3_Core_GlProgramUniform3iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniform3iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlProgramUniform3ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniform3ui(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_3_Core_GlProgramUniform3uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniform3uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlProgramUniform4f5(void* ptr, unsigned int program, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniform4f(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_3_Core_GlProgramUniform4fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniform4fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlProgramUniform4i5(void* ptr, unsigned int program, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniform4i(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_3_Core_GlProgramUniform4iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniform4iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlProgramUniform4ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniform4ui(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_3_Core_GlProgramUniform4uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniform4uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlProgramUniformMatrix2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniformMatrix2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlProgramUniformMatrix2x3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniformMatrix2x3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlProgramUniformMatrix2x4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniformMatrix2x4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlProgramUniformMatrix3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniformMatrix3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlProgramUniformMatrix3x2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniformMatrix3x2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlProgramUniformMatrix3x4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniformMatrix3x4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlProgramUniformMatrix4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniformMatrix4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlProgramUniformMatrix4x2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniformMatrix4x2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlProgramUniformMatrix4x3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProgramUniformMatrix4x3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlProvokingVertex5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glProvokingVertex(mode);
}
void QOpenGLFunctions_4_3_Core_GlQueryCounter5(void* ptr, unsigned int id, unsigned int target)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glQueryCounter(id, target);
}
void QOpenGLFunctions_4_3_Core_GlReadBuffer5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glReadBuffer(mode);
}
void QOpenGLFunctions_4_3_Core_GlReadPixels5(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_3_Core_GlReleaseShaderCompiler5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glReleaseShaderCompiler();
}
void QOpenGLFunctions_4_3_Core_GlRenderbufferStorage5(void* ptr, unsigned int target, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glRenderbufferStorage(target, internalformat, width, height);
}
void QOpenGLFunctions_4_3_Core_GlRenderbufferStorageMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
}
void QOpenGLFunctions_4_3_Core_GlResumeTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glResumeTransformFeedback();
}
void QOpenGLFunctions_4_3_Core_GlSampleCoverage5(void* ptr, float value, char invert)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glSampleCoverage(value, invert != 0);
}
void QOpenGLFunctions_4_3_Core_GlSampleMaski5(void* ptr, unsigned int index, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glSampleMaski(index, mask);
}
void QOpenGLFunctions_4_3_Core_GlSamplerParameterIiv5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glSamplerParameterIiv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_3_Core_GlSamplerParameterIuiv5(void* ptr, unsigned int sampler, unsigned int pname, unsigned int param)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glSamplerParameterIuiv(sampler, pname, const_cast<const GLuint*>(&param));
}
void QOpenGLFunctions_4_3_Core_GlSamplerParameterf5(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glSamplerParameterf(sampler, pname, param);
}
void QOpenGLFunctions_4_3_Core_GlSamplerParameterfv5(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glSamplerParameterfv(sampler, pname, const_cast<const GLfloat*>(&param));
}
void QOpenGLFunctions_4_3_Core_GlSamplerParameteri5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glSamplerParameteri(sampler, pname, param);
}
void QOpenGLFunctions_4_3_Core_GlSamplerParameteriv5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glSamplerParameteriv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_3_Core_GlScissor5(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_4_3_Core_GlScissorArrayv5(void* ptr, unsigned int first, int count, int v)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glScissorArrayv(first, count, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Core_GlScissorIndexed5(void* ptr, unsigned int index, int left, int bottom, int width, int height)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glScissorIndexed(index, left, bottom, width, height);
}
void QOpenGLFunctions_4_3_Core_GlScissorIndexedv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glScissorIndexedv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_3_Core_GlSecondaryColorP3ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glSecondaryColorP3ui(ty, color);
}
void QOpenGLFunctions_4_3_Core_GlSecondaryColorP3uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glSecondaryColorP3uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_3_Core_GlShaderBinary5(void* ptr, int count, unsigned int shaders, unsigned int binaryformat, void* binary, int length)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glShaderBinary(count, const_cast<const GLuint*>(&shaders), binaryformat, binary, length);
}
void QOpenGLFunctions_4_3_Core_GlShaderStorageBlockBinding5(void* ptr, unsigned int program, unsigned int storageBlockIndex, unsigned int storageBlockBinding)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
}
void QOpenGLFunctions_4_3_Core_GlStencilFunc5(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_4_3_Core_GlStencilFuncSeparate5(void* ptr, unsigned int face, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glStencilFuncSeparate(face, fu, ref, mask);
}
void QOpenGLFunctions_4_3_Core_GlStencilMask5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_4_3_Core_GlStencilMaskSeparate5(void* ptr, unsigned int face, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glStencilMaskSeparate(face, mask);
}
void QOpenGLFunctions_4_3_Core_GlStencilOp5(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_4_3_Core_GlStencilOpSeparate5(void* ptr, unsigned int face, unsigned int sfail, unsigned int dpfail, unsigned int dppass)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glStencilOpSeparate(face, sfail, dpfail, dppass);
}
void QOpenGLFunctions_4_3_Core_GlTexBuffer5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexBuffer(target, internalformat, buffer);
}
void QOpenGLFunctions_4_3_Core_GlTexCoordP1ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexCoordP1ui(ty, coords);
}
void QOpenGLFunctions_4_3_Core_GlTexCoordP1uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexCoordP1uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_3_Core_GlTexCoordP2ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexCoordP2ui(ty, coords);
}
void QOpenGLFunctions_4_3_Core_GlTexCoordP2uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexCoordP2uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_3_Core_GlTexCoordP3ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexCoordP3ui(ty, coords);
}
void QOpenGLFunctions_4_3_Core_GlTexCoordP3uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexCoordP3uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_3_Core_GlTexCoordP4ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexCoordP4ui(ty, coords);
}
void QOpenGLFunctions_4_3_Core_GlTexCoordP4uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexCoordP4uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_3_Core_GlTexImage1D5(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_4_3_Core_GlTexImage2D5(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_4_3_Core_GlTexImage2DMultisample5(void* ptr, unsigned int target, int samples, int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_3_Core_GlTexImage3D5(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLFunctions_4_3_Core_GlTexImage3DMultisample5(void* ptr, unsigned int target, int samples, int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_3_Core_GlTexParameterIiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexParameterIiv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_3_Core_GlTexParameterIuiv5(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexParameterIuiv(target, pname, const_cast<const GLuint*>(&params));
}
void QOpenGLFunctions_4_3_Core_GlTexParameterf5(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_4_3_Core_GlTexParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_3_Core_GlTexParameteri5(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_4_3_Core_GlTexParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_3_Core_GlTexStorage1D5(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexStorage1D(target, levels, internalformat, width);
}
void QOpenGLFunctions_4_3_Core_GlTexStorage2D5(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexStorage2D(target, levels, internalformat, width, height);
}
void QOpenGLFunctions_4_3_Core_GlTexStorage2DMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_3_Core_GlTexStorage3D5(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width, int height, int depth)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexStorage3D(target, levels, internalformat, width, height, depth);
}
void QOpenGLFunctions_4_3_Core_GlTexStorage3DMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_3_Core_GlTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_4_3_Core_GlTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_3_Core_GlTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_4_3_Core_GlTextureView5(void* ptr, unsigned int texture, unsigned int target, unsigned int origtexture, unsigned int internalformat, unsigned int minlevel, unsigned int numlevels, unsigned int minlayer, unsigned int numlayers)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glTextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
}
void QOpenGLFunctions_4_3_Core_GlUniform1f5(void* ptr, int location, float v0)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniform1f(location, v0);
}
void QOpenGLFunctions_4_3_Core_GlUniform1fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniform1fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlUniform1i5(void* ptr, int location, int v0)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniform1i(location, v0);
}
void QOpenGLFunctions_4_3_Core_GlUniform1iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniform1iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlUniform1ui5(void* ptr, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniform1ui(location, v0);
}
void QOpenGLFunctions_4_3_Core_GlUniform1uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniform1uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlUniform2f5(void* ptr, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniform2f(location, v0, v1);
}
void QOpenGLFunctions_4_3_Core_GlUniform2fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniform2fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlUniform2i5(void* ptr, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniform2i(location, v0, v1);
}
void QOpenGLFunctions_4_3_Core_GlUniform2iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniform2iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlUniform2ui5(void* ptr, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniform2ui(location, v0, v1);
}
void QOpenGLFunctions_4_3_Core_GlUniform2uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniform2uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlUniform3f5(void* ptr, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniform3f(location, v0, v1, v2);
}
void QOpenGLFunctions_4_3_Core_GlUniform3fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniform3fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlUniform3i5(void* ptr, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniform3i(location, v0, v1, v2);
}
void QOpenGLFunctions_4_3_Core_GlUniform3iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniform3iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlUniform3ui5(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniform3ui(location, v0, v1, v2);
}
void QOpenGLFunctions_4_3_Core_GlUniform3uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniform3uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlUniform4f5(void* ptr, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniform4f(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_3_Core_GlUniform4fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniform4fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlUniform4i5(void* ptr, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniform4i(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_3_Core_GlUniform4iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniform4iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlUniform4ui5(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniform4ui(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_3_Core_GlUniform4uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniform4uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlUniformBlockBinding5(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int uniformBlockBinding)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}
void QOpenGLFunctions_4_3_Core_GlUniformMatrix2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniformMatrix2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlUniformMatrix2x3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniformMatrix2x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlUniformMatrix2x4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniformMatrix2x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlUniformMatrix3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniformMatrix3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlUniformMatrix3x2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniformMatrix3x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlUniformMatrix3x4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniformMatrix3x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlUniformMatrix4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniformMatrix4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlUniformMatrix4x2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniformMatrix4x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlUniformMatrix4x3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniformMatrix4x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlUniformSubroutinesuiv5(void* ptr, unsigned int shadertype, int count, unsigned int indices)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUniformSubroutinesuiv(shadertype, count, const_cast<const GLuint*>(&indices));
}
void QOpenGLFunctions_4_3_Core_GlUseProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUseProgram(program);
}
void QOpenGLFunctions_4_3_Core_GlUseProgramStages5(void* ptr, unsigned int pipeline, unsigned int stages, unsigned int program)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glUseProgramStages(pipeline, stages, program);
}
void QOpenGLFunctions_4_3_Core_GlValidateProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glValidateProgram(program);
}
void QOpenGLFunctions_4_3_Core_GlValidateProgramPipeline5(void* ptr, unsigned int pipeline)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glValidateProgramPipeline(pipeline);
}
void QOpenGLFunctions_4_3_Core_GlVertexAttribBinding5(void* ptr, unsigned int attribindex, unsigned int bindingindex)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glVertexAttribBinding(attribindex, bindingindex);
}
void QOpenGLFunctions_4_3_Core_GlVertexAttribDivisor5(void* ptr, unsigned int index, unsigned int divisor)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glVertexAttribDivisor(index, divisor);
}
void QOpenGLFunctions_4_3_Core_GlVertexAttribFormat5(void* ptr, unsigned int attribindex, int size, unsigned int ty, char normalized, unsigned int relativeoffset)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glVertexAttribFormat(attribindex, size, ty, normalized != 0, relativeoffset);
}
void QOpenGLFunctions_4_3_Core_GlVertexAttribIFormat5(void* ptr, unsigned int attribindex, int size, unsigned int ty, unsigned int relativeoffset)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glVertexAttribIFormat(attribindex, size, ty, relativeoffset);
}
void QOpenGLFunctions_4_3_Core_GlVertexAttribIPointer5(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glVertexAttribIPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_4_3_Core_GlVertexAttribLFormat5(void* ptr, unsigned int attribindex, int size, unsigned int ty, unsigned int relativeoffset)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glVertexAttribLFormat(attribindex, size, ty, relativeoffset);
}
void QOpenGLFunctions_4_3_Core_GlVertexAttribLPointer5(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glVertexAttribLPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_4_3_Core_GlVertexAttribP1ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glVertexAttribP1ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_3_Core_GlVertexAttribP1uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glVertexAttribP1uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlVertexAttribP2ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glVertexAttribP2ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_3_Core_GlVertexAttribP2uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glVertexAttribP2uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlVertexAttribP3ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glVertexAttribP3ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_3_Core_GlVertexAttribP3uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glVertexAttribP3uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlVertexAttribP4ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glVertexAttribP4ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_3_Core_GlVertexAttribP4uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glVertexAttribP4uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlVertexAttribPointer5(void* ptr, unsigned int index, int size, unsigned int ty, char normalized, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glVertexAttribPointer(index, size, ty, normalized != 0, stride, pointer);
}
void QOpenGLFunctions_4_3_Core_GlVertexBindingDivisor5(void* ptr, unsigned int bindingindex, unsigned int divisor)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glVertexBindingDivisor(bindingindex, divisor);
}
void QOpenGLFunctions_4_3_Core_GlVertexP2ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glVertexP2ui(ty, value);
}
void QOpenGLFunctions_4_3_Core_GlVertexP2uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glVertexP2uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlVertexP3ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glVertexP3ui(ty, value);
}
void QOpenGLFunctions_4_3_Core_GlVertexP3uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glVertexP3uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlVertexP4ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glVertexP4ui(ty, value);
}
void QOpenGLFunctions_4_3_Core_GlVertexP4uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glVertexP4uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_3_Core_GlViewport5(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_4_3_Core_GlViewportArrayv5(void* ptr, unsigned int first, int count, float v)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glViewportArrayv(first, count, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Core_GlViewportIndexedf5(void* ptr, unsigned int index, float x, float y, float w, float h)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glViewportIndexedf(index, x, y, w, h);
}
void QOpenGLFunctions_4_3_Core_GlViewportIndexedfv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glViewportIndexedfv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_3_Core_DestroyQOpenGLFunctions_4_3_Core5(void* ptr)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->~QOpenGLFunctions_4_3_Core();
}
void QOpenGLFunctions_4_3_Core_DestroyQOpenGLFunctions_4_3_Core5Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_4_4_Compatibility: public QOpenGLFunctions_4_4_Compatibility
{
public:
MyQOpenGLFunctions_4_4_Compatibility() : QOpenGLFunctions_4_4_Compatibility() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_4_4_Compatibility_InitializeOpenGLFunctions5(this) != 0; };
~MyQOpenGLFunctions_4_4_Compatibility() { callbackQOpenGLFunctions_4_4_Compatibility_DestroyQOpenGLFunctions_4_4_Compatibility5(this); };
};
char QOpenGLFunctions_4_4_Compatibility_GlAreTexturesResident5(void* ptr, int n, unsigned int textures, char residences)
{
Q_UNUSED(residences);
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glAreTexturesResident(n, const_cast<const GLuint*>(&textures), NULL);
}
char QOpenGLFunctions_4_4_Compatibility_GlIsBuffer5(void* ptr, unsigned int buffer)
{
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glIsBuffer(buffer);
}
char QOpenGLFunctions_4_4_Compatibility_GlIsEnabled5(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_4_4_Compatibility_GlIsEnabledi5(void* ptr, unsigned int target, unsigned int index)
{
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glIsEnabledi(target, index);
}
char QOpenGLFunctions_4_4_Compatibility_GlIsFramebuffer5(void* ptr, unsigned int framebuffer)
{
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glIsFramebuffer(framebuffer);
}
char QOpenGLFunctions_4_4_Compatibility_GlIsList5(void* ptr, unsigned int list)
{
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glIsList(list);
}
char QOpenGLFunctions_4_4_Compatibility_GlIsProgram5(void* ptr, unsigned int program)
{
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glIsProgram(program);
}
char QOpenGLFunctions_4_4_Compatibility_GlIsProgramPipeline5(void* ptr, unsigned int pipeline)
{
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glIsProgramPipeline(pipeline);
}
char QOpenGLFunctions_4_4_Compatibility_GlIsQuery5(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glIsQuery(id);
}
char QOpenGLFunctions_4_4_Compatibility_GlIsRenderbuffer5(void* ptr, unsigned int renderbuffer)
{
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glIsRenderbuffer(renderbuffer);
}
char QOpenGLFunctions_4_4_Compatibility_GlIsSampler5(void* ptr, unsigned int sampler)
{
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glIsSampler(sampler);
}
char QOpenGLFunctions_4_4_Compatibility_GlIsShader5(void* ptr, unsigned int shader)
{
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glIsShader(shader);
}
char QOpenGLFunctions_4_4_Compatibility_GlIsTexture5(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glIsTexture(texture);
}
char QOpenGLFunctions_4_4_Compatibility_GlIsTransformFeedback5(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glIsTransformFeedback(id);
}
char QOpenGLFunctions_4_4_Compatibility_GlIsVertexArray5(void* ptr, unsigned int array)
{
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glIsVertexArray(array);
}
char QOpenGLFunctions_4_4_Compatibility_GlUnmapBuffer5(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUnmapBuffer(target);
}
unsigned int QOpenGLFunctions_4_4_Compatibility_GlCheckFramebufferStatus5(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glCheckFramebufferStatus(target);
}
unsigned int QOpenGLFunctions_4_4_Compatibility_GlGetError5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetError();
}
int QOpenGLFunctions_4_4_Compatibility_GlRenderMode5(void* ptr, unsigned int mode)
{
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRenderMode(mode);
}
unsigned int QOpenGLFunctions_4_4_Compatibility_GlCreateProgram5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glCreateProgram();
}
unsigned int QOpenGLFunctions_4_4_Compatibility_GlCreateShader5(void* ptr, unsigned int ty)
{
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glCreateShader(ty);
}
unsigned int QOpenGLFunctions_4_4_Compatibility_GlGenLists5(void* ptr, int ran)
{
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGenLists(ran);
}
void* QOpenGLFunctions_4_4_Compatibility_NewQOpenGLFunctions_4_4_Compatibility5()
{
return new MyQOpenGLFunctions_4_4_Compatibility();
}
char QOpenGLFunctions_4_4_Compatibility_InitializeOpenGLFunctions5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_4_4_Compatibility_InitializeOpenGLFunctions5Default(void* ptr)
{
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->QOpenGLFunctions_4_4_Compatibility::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_4_4_Compatibility_GlGetString5(void* ptr, unsigned int name)
{
return ({ char* td736f1 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetString(name)))); QtGui_PackedString { td736f1, -1 }; });
}
struct QtGui_PackedString QOpenGLFunctions_4_4_Compatibility_GlGetStringi5(void* ptr, unsigned int name, unsigned int index)
{
return ({ char* t926f00 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetStringi(name, index)))); QtGui_PackedString { t926f00, -1 }; });
}
void* QOpenGLFunctions_4_4_Compatibility_GlMapBuffer5(void* ptr, unsigned int target, unsigned int access)
{
return static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMapBuffer(target, access);
}
void QOpenGLFunctions_4_4_Compatibility_GlAccum5(void* ptr, unsigned int op, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glAccum(op, value);
}
void QOpenGLFunctions_4_4_Compatibility_GlActiveShaderProgram5(void* ptr, unsigned int pipeline, unsigned int program)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glActiveShaderProgram(pipeline, program);
}
void QOpenGLFunctions_4_4_Compatibility_GlActiveTexture5(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glActiveTexture(texture);
}
void QOpenGLFunctions_4_4_Compatibility_GlAlphaFunc5(void* ptr, unsigned int fu, float ref)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glAlphaFunc(fu, ref);
}
void QOpenGLFunctions_4_4_Compatibility_GlArrayElement5(void* ptr, int i)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glArrayElement(i);
}
void QOpenGLFunctions_4_4_Compatibility_GlAttachShader5(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glAttachShader(program, shader);
}
void QOpenGLFunctions_4_4_Compatibility_GlBegin5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBegin(mode);
}
void QOpenGLFunctions_4_4_Compatibility_GlBeginConditionalRender5(void* ptr, unsigned int id, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBeginConditionalRender(id, mode);
}
void QOpenGLFunctions_4_4_Compatibility_GlBeginQuery5(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBeginQuery(target, id);
}
void QOpenGLFunctions_4_4_Compatibility_GlBeginQueryIndexed5(void* ptr, unsigned int target, unsigned int index, unsigned int id)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBeginQueryIndexed(target, index, id);
}
void QOpenGLFunctions_4_4_Compatibility_GlBeginTransformFeedback5(void* ptr, unsigned int primitiveMode)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBeginTransformFeedback(primitiveMode);
}
void QOpenGLFunctions_4_4_Compatibility_GlBindBuffer5(void* ptr, unsigned int target, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBindBuffer(target, buffer);
}
void QOpenGLFunctions_4_4_Compatibility_GlBindBufferBase5(void* ptr, unsigned int target, unsigned int index, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBindBufferBase(target, index, buffer);
}
void QOpenGLFunctions_4_4_Compatibility_GlBindBuffersBase5(void* ptr, unsigned int target, unsigned int first, int count, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBindBuffersBase(target, first, count, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_4_4_Compatibility_GlBindFramebuffer5(void* ptr, unsigned int target, unsigned int framebuffer)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBindFramebuffer(target, framebuffer);
}
void QOpenGLFunctions_4_4_Compatibility_GlBindImageTexture5(void* ptr, unsigned int unit, unsigned int texture, int level, char layered, int layer, unsigned int access, unsigned int format)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBindImageTexture(unit, texture, level, layered != 0, layer, access, format);
}
void QOpenGLFunctions_4_4_Compatibility_GlBindImageTextures5(void* ptr, unsigned int first, int count, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBindImageTextures(first, count, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_4_4_Compatibility_GlBindProgramPipeline5(void* ptr, unsigned int pipeline)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBindProgramPipeline(pipeline);
}
void QOpenGLFunctions_4_4_Compatibility_GlBindRenderbuffer5(void* ptr, unsigned int target, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBindRenderbuffer(target, renderbuffer);
}
void QOpenGLFunctions_4_4_Compatibility_GlBindSampler5(void* ptr, unsigned int unit, unsigned int sampler)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBindSampler(unit, sampler);
}
void QOpenGLFunctions_4_4_Compatibility_GlBindSamplers5(void* ptr, unsigned int first, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBindSamplers(first, count, const_cast<const GLuint*>(&samplers));
}
void QOpenGLFunctions_4_4_Compatibility_GlBindTexture5(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_4_4_Compatibility_GlBindTextures5(void* ptr, unsigned int first, int count, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBindTextures(first, count, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_4_4_Compatibility_GlBindTransformFeedback5(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBindTransformFeedback(target, id);
}
void QOpenGLFunctions_4_4_Compatibility_GlBindVertexArray5(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBindVertexArray(array);
}
void QOpenGLFunctions_4_4_Compatibility_GlBitmap5(void* ptr, int width, int height, float xorig, float yorig, float xmove, float ymove, char* bitmap)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBitmap(width, height, xorig, yorig, xmove, ymove, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(bitmap))));
}
void QOpenGLFunctions_4_4_Compatibility_GlBlendColor5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_4_4_Compatibility_GlBlendEquation5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_4_4_Compatibility_GlBlendEquationSeparate5(void* ptr, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBlendEquationSeparate(modeRGB, modeAlpha);
}
void QOpenGLFunctions_4_4_Compatibility_GlBlendEquationSeparatei5(void* ptr, unsigned int buf, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBlendEquationSeparatei(buf, modeRGB, modeAlpha);
}
void QOpenGLFunctions_4_4_Compatibility_GlBlendEquationi5(void* ptr, unsigned int buf, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBlendEquationi(buf, mode);
}
void QOpenGLFunctions_4_4_Compatibility_GlBlendFunc5(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_4_4_Compatibility_GlBlendFuncSeparate5(void* ptr, unsigned int sfactorRGB, unsigned int dfactorRGB, unsigned int sfactorAlpha, unsigned int dfactorAlpha)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void QOpenGLFunctions_4_4_Compatibility_GlBlendFuncSeparatei5(void* ptr, unsigned int buf, unsigned int srcRGB, unsigned int dstRGB, unsigned int srcAlpha, unsigned int dstAlpha)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
void QOpenGLFunctions_4_4_Compatibility_GlBlendFunci5(void* ptr, unsigned int buf, unsigned int src, unsigned int dst)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBlendFunci(buf, src, dst);
}
void QOpenGLFunctions_4_4_Compatibility_GlBlitFramebuffer5(void* ptr, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, unsigned int mask, unsigned int filter)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
void QOpenGLFunctions_4_4_Compatibility_GlCallList5(void* ptr, unsigned int list)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glCallList(list);
}
void QOpenGLFunctions_4_4_Compatibility_GlCallLists5(void* ptr, int n, unsigned int ty, void* lists)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glCallLists(n, ty, lists);
}
void QOpenGLFunctions_4_4_Compatibility_GlClampColor5(void* ptr, unsigned int target, unsigned int clamp)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glClampColor(target, clamp);
}
void QOpenGLFunctions_4_4_Compatibility_GlClear5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_4_4_Compatibility_GlClearAccum5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glClearAccum(red, green, blue, alpha);
}
void QOpenGLFunctions_4_4_Compatibility_GlClearBufferData5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glClearBufferData(target, internalformat, format, ty, data);
}
void QOpenGLFunctions_4_4_Compatibility_GlClearBufferfi5(void* ptr, unsigned int buffer, int drawbuffer, float depth, int stencil)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glClearBufferfi(buffer, drawbuffer, depth, stencil);
}
void QOpenGLFunctions_4_4_Compatibility_GlClearBufferfv5(void* ptr, unsigned int buffer, int drawbuffer, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glClearBufferfv(buffer, drawbuffer, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlClearBufferiv5(void* ptr, unsigned int buffer, int drawbuffer, int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glClearBufferiv(buffer, drawbuffer, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlClearBufferuiv5(void* ptr, unsigned int buffer, int drawbuffer, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glClearBufferuiv(buffer, drawbuffer, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlClearColor5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_4_4_Compatibility_GlClearDepthf5(void* ptr, float dd)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glClearDepthf(dd);
}
void QOpenGLFunctions_4_4_Compatibility_GlClearIndex5(void* ptr, float c)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glClearIndex(c);
}
void QOpenGLFunctions_4_4_Compatibility_GlClearStencil5(void* ptr, int s)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_4_4_Compatibility_GlClearTexImage5(void* ptr, unsigned int texture, int level, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glClearTexImage(texture, level, format, ty, data);
}
void QOpenGLFunctions_4_4_Compatibility_GlClearTexSubImage5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, data);
}
void QOpenGLFunctions_4_4_Compatibility_GlClientActiveTexture5(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glClientActiveTexture(texture);
}
void QOpenGLFunctions_4_4_Compatibility_GlColor3f5(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColor3f(red, green, blue);
}
void QOpenGLFunctions_4_4_Compatibility_GlColor3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlColor3i5(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColor3i(red, green, blue);
}
void QOpenGLFunctions_4_4_Compatibility_GlColor3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlColor3s5(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColor3s(red, green, blue);
}
void QOpenGLFunctions_4_4_Compatibility_GlColor3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlColor3ub5(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_4_4_Compatibility_GlColor3ubv5(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_4_Compatibility_GlColor3ui5(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColor3ui(red, green, blue);
}
void QOpenGLFunctions_4_4_Compatibility_GlColor3uiv5(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlColor3us5(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColor3us(red, green, blue);
}
void QOpenGLFunctions_4_4_Compatibility_GlColor3usv5(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlColor4f5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColor4f(red, green, blue, alpha);
}
void QOpenGLFunctions_4_4_Compatibility_GlColor4fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColor4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlColor4i5(void* ptr, int red, int green, int blue, int alpha)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColor4i(red, green, blue, alpha);
}
void QOpenGLFunctions_4_4_Compatibility_GlColor4iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColor4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlColor4s5(void* ptr, short red, short green, short blue, short alpha)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColor4s(red, green, blue, alpha);
}
void QOpenGLFunctions_4_4_Compatibility_GlColor4sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColor4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlColor4ub5(void* ptr, char* red, char* green, char* blue, char* alpha)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColor4ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)), *static_cast<GLubyte*>(static_cast<void*>(alpha)));
}
void QOpenGLFunctions_4_4_Compatibility_GlColor4ubv5(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColor4ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_4_Compatibility_GlColor4ui5(void* ptr, unsigned int red, unsigned int green, unsigned int blue, unsigned int alpha)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColor4ui(red, green, blue, alpha);
}
void QOpenGLFunctions_4_4_Compatibility_GlColor4uiv5(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColor4uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlColor4us5(void* ptr, unsigned short red, unsigned short green, unsigned short blue, unsigned short alpha)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColor4us(red, green, blue, alpha);
}
void QOpenGLFunctions_4_4_Compatibility_GlColor4usv5(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColor4usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlColorMask5(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_4_4_Compatibility_GlColorMaski5(void* ptr, unsigned int index, char r, char g, char b, char a)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColorMaski(index, r != 0, g != 0, b != 0, a != 0);
}
void QOpenGLFunctions_4_4_Compatibility_GlColorMaterial5(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColorMaterial(face, mode);
}
void QOpenGLFunctions_4_4_Compatibility_GlColorP3ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColorP3ui(ty, color);
}
void QOpenGLFunctions_4_4_Compatibility_GlColorP3uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColorP3uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_4_Compatibility_GlColorP4ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColorP4ui(ty, color);
}
void QOpenGLFunctions_4_4_Compatibility_GlColorP4uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColorP4uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_4_Compatibility_GlColorPointer5(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_4_4_Compatibility_GlColorSubTable5(void* ptr, unsigned int target, int start, int count, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColorSubTable(target, start, count, format, ty, data);
}
void QOpenGLFunctions_4_4_Compatibility_GlColorTable5(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColorTable(target, internalformat, width, format, ty, table);
}
void QOpenGLFunctions_4_4_Compatibility_GlColorTableParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColorTableParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_4_Compatibility_GlColorTableParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glColorTableParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_4_Compatibility_GlCompileShader5(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glCompileShader(shader);
}
void QOpenGLFunctions_4_4_Compatibility_GlCompressedTexImage1D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
void QOpenGLFunctions_4_4_Compatibility_GlCompressedTexImage2D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void QOpenGLFunctions_4_4_Compatibility_GlCompressedTexImage3D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int depth, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void QOpenGLFunctions_4_4_Compatibility_GlCompressedTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_4_4_Compatibility_GlCompressedTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_4_4_Compatibility_GlCompressedTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_4_4_Compatibility_GlConvolutionFilter1D5(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glConvolutionFilter1D(target, internalformat, width, format, ty, image);
}
void QOpenGLFunctions_4_4_Compatibility_GlConvolutionFilter2D5(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glConvolutionFilter2D(target, internalformat, width, height, format, ty, image);
}
void QOpenGLFunctions_4_4_Compatibility_GlConvolutionParameterf5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glConvolutionParameterf(target, pname, params);
}
void QOpenGLFunctions_4_4_Compatibility_GlConvolutionParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glConvolutionParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_4_Compatibility_GlConvolutionParameteri5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glConvolutionParameteri(target, pname, params);
}
void QOpenGLFunctions_4_4_Compatibility_GlConvolutionParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glConvolutionParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_4_Compatibility_GlCopyColorSubTable5(void* ptr, unsigned int target, int start, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glCopyColorSubTable(target, start, x, y, width);
}
void QOpenGLFunctions_4_4_Compatibility_GlCopyColorTable5(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glCopyColorTable(target, internalformat, x, y, width);
}
void QOpenGLFunctions_4_4_Compatibility_GlCopyConvolutionFilter1D5(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glCopyConvolutionFilter1D(target, internalformat, x, y, width);
}
void QOpenGLFunctions_4_4_Compatibility_GlCopyConvolutionFilter2D5(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);
}
void QOpenGLFunctions_4_4_Compatibility_GlCopyImageSubData5(void* ptr, unsigned int srcName, unsigned int srcTarget, int srcLevel, int srcX, int srcY, int srcZ, unsigned int dstName, unsigned int dstTarget, int dstLevel, int dstX, int dstY, int dstZ, int srcWidth, int srcHeight, int srcDepth)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
}
void QOpenGLFunctions_4_4_Compatibility_GlCopyPixels5(void* ptr, int x, int y, int width, int height, unsigned int ty)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glCopyPixels(x, y, width, height, ty);
}
void QOpenGLFunctions_4_4_Compatibility_GlCopyTexImage1D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_4_4_Compatibility_GlCopyTexImage2D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_4_4_Compatibility_GlCopyTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_4_4_Compatibility_GlCopyTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_4_4_Compatibility_GlCopyTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_4_4_Compatibility_GlCullFace5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_4_4_Compatibility_GlDebugMessageControl5(void* ptr, unsigned int source, unsigned int ty, unsigned int severity, int count, unsigned int ids, char enabled)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDebugMessageControl(source, ty, severity, count, const_cast<const GLuint*>(&ids), enabled != 0);
}
void QOpenGLFunctions_4_4_Compatibility_GlDeleteBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDeleteBuffers(n, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_4_4_Compatibility_GlDeleteFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDeleteFramebuffers(n, const_cast<const GLuint*>(&framebuffers));
}
void QOpenGLFunctions_4_4_Compatibility_GlDeleteLists5(void* ptr, unsigned int list, int ran)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDeleteLists(list, ran);
}
void QOpenGLFunctions_4_4_Compatibility_GlDeleteProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDeleteProgram(program);
}
void QOpenGLFunctions_4_4_Compatibility_GlDeleteProgramPipelines5(void* ptr, int n, unsigned int pipelines)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDeleteProgramPipelines(n, const_cast<const GLuint*>(&pipelines));
}
void QOpenGLFunctions_4_4_Compatibility_GlDeleteQueries5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDeleteQueries(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_4_4_Compatibility_GlDeleteRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDeleteRenderbuffers(n, const_cast<const GLuint*>(&renderbuffers));
}
void QOpenGLFunctions_4_4_Compatibility_GlDeleteSamplers5(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDeleteSamplers(count, const_cast<const GLuint*>(&samplers));
}
void QOpenGLFunctions_4_4_Compatibility_GlDeleteShader5(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDeleteShader(shader);
}
void QOpenGLFunctions_4_4_Compatibility_GlDeleteTextures5(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_4_4_Compatibility_GlDeleteTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDeleteTransformFeedbacks(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_4_4_Compatibility_GlDeleteVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDeleteVertexArrays(n, const_cast<const GLuint*>(&arrays));
}
void QOpenGLFunctions_4_4_Compatibility_GlDepthFunc5(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_4_4_Compatibility_GlDepthMask5(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_4_4_Compatibility_GlDepthRangef5(void* ptr, float n, float fo)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDepthRangef(n, fo);
}
void QOpenGLFunctions_4_4_Compatibility_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDetachShader(program, shader);
}
void QOpenGLFunctions_4_4_Compatibility_GlDisable5(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_4_4_Compatibility_GlDisableClientState5(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDisableClientState(array);
}
void QOpenGLFunctions_4_4_Compatibility_GlDisableVertexAttribArray5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDisableVertexAttribArray(index);
}
void QOpenGLFunctions_4_4_Compatibility_GlDisablei5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDisablei(target, index);
}
void QOpenGLFunctions_4_4_Compatibility_GlDispatchCompute5(void* ptr, unsigned int num_groups_x, unsigned int num_groups_y, unsigned int num_groups_z)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
}
void QOpenGLFunctions_4_4_Compatibility_GlDrawArrays5(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_4_4_Compatibility_GlDrawArraysIndirect5(void* ptr, unsigned int mode, void* indirect)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDrawArraysIndirect(mode, indirect);
}
void QOpenGLFunctions_4_4_Compatibility_GlDrawArraysInstanced5(void* ptr, unsigned int mode, int first, int count, int instancecount)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDrawArraysInstanced(mode, first, count, instancecount);
}
void QOpenGLFunctions_4_4_Compatibility_GlDrawArraysInstancedBaseInstance5(void* ptr, unsigned int mode, int first, int count, int instancecount, unsigned int baseinstance)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
}
void QOpenGLFunctions_4_4_Compatibility_GlDrawBuffer5(void* ptr, unsigned int buf)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDrawBuffer(buf);
}
void QOpenGLFunctions_4_4_Compatibility_GlDrawBuffers5(void* ptr, int n, unsigned int bufs)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDrawBuffers(n, const_cast<const GLenum*>(&bufs));
}
void QOpenGLFunctions_4_4_Compatibility_GlDrawElements5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_4_4_Compatibility_GlDrawElementsBaseVertex5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDrawElementsBaseVertex(mode, count, ty, indices, basevertex);
}
void QOpenGLFunctions_4_4_Compatibility_GlDrawElementsIndirect5(void* ptr, unsigned int mode, unsigned int ty, void* indirect)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDrawElementsIndirect(mode, ty, indirect);
}
void QOpenGLFunctions_4_4_Compatibility_GlDrawElementsInstanced5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDrawElementsInstanced(mode, count, ty, indices, instancecount);
}
void QOpenGLFunctions_4_4_Compatibility_GlDrawElementsInstancedBaseInstance5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, unsigned int baseinstance)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDrawElementsInstancedBaseInstance(mode, count, ty, indices, instancecount, baseinstance);
}
void QOpenGLFunctions_4_4_Compatibility_GlDrawElementsInstancedBaseVertex5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDrawElementsInstancedBaseVertex(mode, count, ty, indices, instancecount, basevertex);
}
void QOpenGLFunctions_4_4_Compatibility_GlDrawElementsInstancedBaseVertexBaseInstance5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex, unsigned int baseinstance)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDrawElementsInstancedBaseVertexBaseInstance(mode, count, ty, indices, instancecount, basevertex, baseinstance);
}
void QOpenGLFunctions_4_4_Compatibility_GlDrawPixels5(void* ptr, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDrawPixels(width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_4_Compatibility_GlDrawRangeElements5(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLFunctions_4_4_Compatibility_GlDrawRangeElementsBaseVertex5(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDrawRangeElementsBaseVertex(mode, start, end, count, ty, indices, basevertex);
}
void QOpenGLFunctions_4_4_Compatibility_GlDrawTransformFeedback5(void* ptr, unsigned int mode, unsigned int id)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDrawTransformFeedback(mode, id);
}
void QOpenGLFunctions_4_4_Compatibility_GlDrawTransformFeedbackInstanced5(void* ptr, unsigned int mode, unsigned int id, int instancecount)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDrawTransformFeedbackInstanced(mode, id, instancecount);
}
void QOpenGLFunctions_4_4_Compatibility_GlDrawTransformFeedbackStream5(void* ptr, unsigned int mode, unsigned int id, unsigned int stream)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDrawTransformFeedbackStream(mode, id, stream);
}
void QOpenGLFunctions_4_4_Compatibility_GlDrawTransformFeedbackStreamInstanced5(void* ptr, unsigned int mode, unsigned int id, unsigned int stream, int instancecount)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
}
void QOpenGLFunctions_4_4_Compatibility_GlEdgeFlag5(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glEdgeFlag(flag != 0);
}
void QOpenGLFunctions_4_4_Compatibility_GlEdgeFlagPointer5(void* ptr, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glEdgeFlagPointer(stride, pointer);
}
void QOpenGLFunctions_4_4_Compatibility_GlEdgeFlagv5(void* ptr, char flag)
{
Q_UNUSED(flag);
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glEdgeFlagv(NULL);
}
void QOpenGLFunctions_4_4_Compatibility_GlEnable5(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_4_4_Compatibility_GlEnableClientState5(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glEnableClientState(array);
}
void QOpenGLFunctions_4_4_Compatibility_GlEnableVertexAttribArray5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glEnableVertexAttribArray(index);
}
void QOpenGLFunctions_4_4_Compatibility_GlEnablei5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glEnablei(target, index);
}
void QOpenGLFunctions_4_4_Compatibility_GlEnd5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glEnd();
}
void QOpenGLFunctions_4_4_Compatibility_GlEndConditionalRender5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glEndConditionalRender();
}
void QOpenGLFunctions_4_4_Compatibility_GlEndList5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glEndList();
}
void QOpenGLFunctions_4_4_Compatibility_GlEndQuery5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glEndQuery(target);
}
void QOpenGLFunctions_4_4_Compatibility_GlEndQueryIndexed5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glEndQueryIndexed(target, index);
}
void QOpenGLFunctions_4_4_Compatibility_GlEndTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glEndTransformFeedback();
}
void QOpenGLFunctions_4_4_Compatibility_GlEvalCoord1f5(void* ptr, float u)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glEvalCoord1f(u);
}
void QOpenGLFunctions_4_4_Compatibility_GlEvalCoord1fv5(void* ptr, float u)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glEvalCoord1fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_4_4_Compatibility_GlEvalCoord2f5(void* ptr, float u, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glEvalCoord2f(u, v);
}
void QOpenGLFunctions_4_4_Compatibility_GlEvalCoord2fv5(void* ptr, float u)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glEvalCoord2fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_4_4_Compatibility_GlEvalMesh15(void* ptr, unsigned int mode, int i1, int i2)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glEvalMesh1(mode, i1, i2);
}
void QOpenGLFunctions_4_4_Compatibility_GlEvalMesh25(void* ptr, unsigned int mode, int i1, int i2, int j1, int j2)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glEvalMesh2(mode, i1, i2, j1, j2);
}
void QOpenGLFunctions_4_4_Compatibility_GlEvalPoint15(void* ptr, int i)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glEvalPoint1(i);
}
void QOpenGLFunctions_4_4_Compatibility_GlEvalPoint25(void* ptr, int i, int j)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glEvalPoint2(i, j);
}
void QOpenGLFunctions_4_4_Compatibility_GlFeedbackBuffer5(void* ptr, int size, unsigned int ty, float buffer)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glFeedbackBuffer(size, ty, &buffer);
}
void QOpenGLFunctions_4_4_Compatibility_GlFinish5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glFinish();
}
void QOpenGLFunctions_4_4_Compatibility_GlFlush5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glFlush();
}
void QOpenGLFunctions_4_4_Compatibility_GlFogCoordPointer5(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glFogCoordPointer(ty, stride, pointer);
}
void QOpenGLFunctions_4_4_Compatibility_GlFogCoordf5(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glFogCoordf(coord);
}
void QOpenGLFunctions_4_4_Compatibility_GlFogCoordfv5(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glFogCoordfv(const_cast<const GLfloat*>(&coord));
}
void QOpenGLFunctions_4_4_Compatibility_GlFogf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glFogf(pname, param);
}
void QOpenGLFunctions_4_4_Compatibility_GlFogfv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glFogfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_4_Compatibility_GlFogi5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glFogi(pname, param);
}
void QOpenGLFunctions_4_4_Compatibility_GlFogiv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glFogiv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_4_Compatibility_GlFramebufferParameteri5(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glFramebufferParameteri(target, pname, param);
}
void QOpenGLFunctions_4_4_Compatibility_GlFramebufferRenderbuffer5(void* ptr, unsigned int target, unsigned int attachment, unsigned int renderbuffertarget, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
void QOpenGLFunctions_4_4_Compatibility_GlFramebufferTexture5(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glFramebufferTexture(target, attachment, texture, level);
}
void QOpenGLFunctions_4_4_Compatibility_GlFramebufferTexture1D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glFramebufferTexture1D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_4_4_Compatibility_GlFramebufferTexture2D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_4_4_Compatibility_GlFramebufferTexture3D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level, int zoffset)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}
void QOpenGLFunctions_4_4_Compatibility_GlFramebufferTextureLayer5(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level, int layer)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glFramebufferTextureLayer(target, attachment, texture, level, layer);
}
void QOpenGLFunctions_4_4_Compatibility_GlFrontFace5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_4_4_Compatibility_GlGenBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGenBuffers(n, &buffers);
}
void QOpenGLFunctions_4_4_Compatibility_GlGenFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGenFramebuffers(n, &framebuffers);
}
void QOpenGLFunctions_4_4_Compatibility_GlGenProgramPipelines5(void* ptr, int n, unsigned int pipelines)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGenProgramPipelines(n, &pipelines);
}
void QOpenGLFunctions_4_4_Compatibility_GlGenQueries5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGenQueries(n, &ids);
}
void QOpenGLFunctions_4_4_Compatibility_GlGenRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGenRenderbuffers(n, &renderbuffers);
}
void QOpenGLFunctions_4_4_Compatibility_GlGenSamplers5(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGenSamplers(count, &samplers);
}
void QOpenGLFunctions_4_4_Compatibility_GlGenTextures5(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_4_4_Compatibility_GlGenTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGenTransformFeedbacks(n, &ids);
}
void QOpenGLFunctions_4_4_Compatibility_GlGenVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGenVertexArrays(n, &arrays);
}
void QOpenGLFunctions_4_4_Compatibility_GlGenerateMipmap5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGenerateMipmap(target);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetActiveAtomicCounterBufferiv5(void* ptr, unsigned int program, unsigned int bufferIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetActiveAtomicCounterBufferiv(program, bufferIndex, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetActiveSubroutineUniformiv5(void* ptr, unsigned int program, unsigned int shadertype, unsigned int index, unsigned int pname, int values)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetActiveSubroutineUniformiv(program, shadertype, index, pname, &values);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetActiveUniformBlockiv5(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetActiveUniformsiv5(void* ptr, unsigned int program, int uniformCount, unsigned int uniformIndices, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetActiveUniformsiv(program, uniformCount, const_cast<const GLuint*>(&uniformIndices), pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetAttachedShaders5(void* ptr, unsigned int program, int maxCount, int count, unsigned int shaders)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetAttachedShaders(program, maxCount, &count, &shaders);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetBooleani_v5(void* ptr, unsigned int target, unsigned int index, char data)
{
Q_UNUSED(data);
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetBooleani_v(target, index, NULL);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetBooleanv5(void* ptr, unsigned int pname, char data)
{
Q_UNUSED(data);
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetBufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetBufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetBufferPointerv5(void* ptr, unsigned int target, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetBufferPointerv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetColorTable5(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetColorTable(target, format, ty, table);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetColorTableParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetColorTableParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetColorTableParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetColorTableParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetCompressedTexImage5(void* ptr, unsigned int target, int level, void* img)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetCompressedTexImage(target, level, img);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetConvolutionFilter5(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetConvolutionFilter(target, format, ty, image);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetConvolutionParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetConvolutionParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetConvolutionParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetConvolutionParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetFloati_v5(void* ptr, unsigned int target, unsigned int index, float data)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetFloati_v(target, index, &data);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetFloatv5(void* ptr, unsigned int pname, float data)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetFloatv(pname, &data);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetFramebufferAttachmentParameteriv5(void* ptr, unsigned int target, unsigned int attachment, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetFramebufferAttachmentParameteriv(target, attachment, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetFramebufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetFramebufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetHistogram5(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetHistogram(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetHistogramParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetHistogramParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetHistogramParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetHistogramParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetIntegeri_v5(void* ptr, unsigned int target, unsigned int index, int data)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetIntegeri_v(target, index, &data);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetIntegerv5(void* ptr, unsigned int pname, int data)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetIntegerv(pname, &data);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetInternalformativ5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int pname, int bufSize, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetInternalformativ(target, internalformat, pname, bufSize, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetLightfv5(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetLightfv(light, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetLightiv5(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetLightiv(light, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetMapfv5(void* ptr, unsigned int target, unsigned int query, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetMapfv(target, query, &v);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetMapiv5(void* ptr, unsigned int target, unsigned int query, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetMapiv(target, query, &v);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetMaterialfv5(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetMaterialfv(face, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetMaterialiv5(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetMaterialiv(face, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetMinmax5(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetMinmax(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetMinmaxParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetMinmaxParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetMinmaxParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetMinmaxParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetMultisamplefv5(void* ptr, unsigned int pname, unsigned int index, float val)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetMultisamplefv(pname, index, &val);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetPixelMapfv5(void* ptr, unsigned int m, float values)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetPixelMapfv(m, &values);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetPixelMapuiv5(void* ptr, unsigned int m, unsigned int values)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetPixelMapuiv(m, &values);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetPixelMapusv5(void* ptr, unsigned int m, unsigned short values)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetPixelMapusv(m, &values);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetPointerv5(void* ptr, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetPointerv(pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetPolygonStipple5(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetPolygonStipple(static_cast<GLubyte*>(static_cast<void*>(mask)));
}
void QOpenGLFunctions_4_4_Compatibility_GlGetProgramBinary5(void* ptr, unsigned int program, int bufSize, int length, unsigned int binaryFormat, void* binary)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetProgramBinary(program, bufSize, &length, &binaryFormat, binary);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetProgramInterfaceiv5(void* ptr, unsigned int program, unsigned int programInterface, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetProgramInterfaceiv(program, programInterface, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetProgramPipelineiv5(void* ptr, unsigned int pipeline, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetProgramPipelineiv(pipeline, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetProgramResourceiv5(void* ptr, unsigned int program, unsigned int programInterface, unsigned int index, int propCount, unsigned int props, int bufSize, int length, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetProgramResourceiv(program, programInterface, index, propCount, const_cast<const GLenum*>(&props), bufSize, &length, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetProgramStageiv5(void* ptr, unsigned int program, unsigned int shadertype, unsigned int pname, int values)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetProgramStageiv(program, shadertype, pname, &values);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetProgramiv5(void* ptr, unsigned int program, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetProgramiv(program, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetQueryIndexediv5(void* ptr, unsigned int target, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetQueryIndexediv(target, index, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetQueryObjectiv5(void* ptr, unsigned int id, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetQueryObjectiv(id, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetQueryObjectuiv5(void* ptr, unsigned int id, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetQueryObjectuiv(id, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetQueryiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetQueryiv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetRenderbufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetRenderbufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetSamplerParameterIiv5(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetSamplerParameterIiv(sampler, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetSamplerParameterIuiv5(void* ptr, unsigned int sampler, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetSamplerParameterIuiv(sampler, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetSamplerParameterfv5(void* ptr, unsigned int sampler, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetSamplerParameterfv(sampler, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetSamplerParameteriv5(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetSamplerParameteriv(sampler, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetSeparableFilter5(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* row, void* column, void* span)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetSeparableFilter(target, format, ty, row, column, span);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetShaderPrecisionFormat5(void* ptr, unsigned int shadertype, unsigned int precisiontype, int ran, int precision)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetShaderPrecisionFormat(shadertype, precisiontype, &ran, &precision);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetShaderiv5(void* ptr, unsigned int shader, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetShaderiv(shader, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetTexEnvfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetTexEnvfv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetTexEnviv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetTexEnviv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetTexGenfv5(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetTexGenfv(coord, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetTexGeniv5(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetTexGeniv(coord, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetTexImage5(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetTexLevelParameterfv5(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetTexLevelParameteriv5(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetTexParameterIiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetTexParameterIiv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetTexParameterIuiv5(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetTexParameterIuiv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetTexParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetTexParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetUniformSubroutineuiv5(void* ptr, unsigned int shadertype, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetUniformSubroutineuiv(shadertype, location, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetUniformfv5(void* ptr, unsigned int program, int location, float params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetUniformfv(program, location, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetUniformiv5(void* ptr, unsigned int program, int location, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetUniformiv(program, location, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetUniformuiv5(void* ptr, unsigned int program, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetUniformuiv(program, location, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetVertexAttribIiv5(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetVertexAttribIiv(index, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetVertexAttribIuiv5(void* ptr, unsigned int index, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetVertexAttribIuiv(index, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetVertexAttribPointerv5(void* ptr, unsigned int index, unsigned int pname, void* pointer)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetVertexAttribPointerv(index, pname, &pointer);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetVertexAttribfv5(void* ptr, unsigned int index, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetVertexAttribfv(index, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlGetVertexAttribiv5(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glGetVertexAttribiv(index, pname, &params);
}
void QOpenGLFunctions_4_4_Compatibility_GlHint5(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_4_4_Compatibility_GlHistogram5(void* ptr, unsigned int target, int width, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glHistogram(target, width, internalformat, sink != 0);
}
void QOpenGLFunctions_4_4_Compatibility_GlIndexMask5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glIndexMask(mask);
}
void QOpenGLFunctions_4_4_Compatibility_GlIndexPointer5(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glIndexPointer(ty, stride, pointer);
}
void QOpenGLFunctions_4_4_Compatibility_GlIndexf5(void* ptr, float c)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glIndexf(c);
}
void QOpenGLFunctions_4_4_Compatibility_GlIndexfv5(void* ptr, float c)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glIndexfv(const_cast<const GLfloat*>(&c));
}
void QOpenGLFunctions_4_4_Compatibility_GlIndexi5(void* ptr, int c)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glIndexi(c);
}
void QOpenGLFunctions_4_4_Compatibility_GlIndexiv5(void* ptr, int c)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glIndexiv(const_cast<const GLint*>(&c));
}
void QOpenGLFunctions_4_4_Compatibility_GlIndexs5(void* ptr, short c)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glIndexs(c);
}
void QOpenGLFunctions_4_4_Compatibility_GlIndexsv5(void* ptr, short c)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glIndexsv(const_cast<const GLshort*>(&c));
}
void QOpenGLFunctions_4_4_Compatibility_GlIndexub5(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glIndexub(*static_cast<GLubyte*>(static_cast<void*>(c)));
}
void QOpenGLFunctions_4_4_Compatibility_GlIndexubv5(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glIndexubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(c))));
}
void QOpenGLFunctions_4_4_Compatibility_GlInitNames5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glInitNames();
}
void QOpenGLFunctions_4_4_Compatibility_GlInterleavedArrays5(void* ptr, unsigned int format, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glInterleavedArrays(format, stride, pointer);
}
void QOpenGLFunctions_4_4_Compatibility_GlInvalidateBufferData5(void* ptr, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glInvalidateBufferData(buffer);
}
void QOpenGLFunctions_4_4_Compatibility_GlInvalidateFramebuffer5(void* ptr, unsigned int target, int numAttachments, unsigned int attachments)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glInvalidateFramebuffer(target, numAttachments, const_cast<const GLenum*>(&attachments));
}
void QOpenGLFunctions_4_4_Compatibility_GlInvalidateSubFramebuffer5(void* ptr, unsigned int target, int numAttachments, unsigned int attachments, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glInvalidateSubFramebuffer(target, numAttachments, const_cast<const GLenum*>(&attachments), x, y, width, height);
}
void QOpenGLFunctions_4_4_Compatibility_GlInvalidateTexImage5(void* ptr, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glInvalidateTexImage(texture, level);
}
void QOpenGLFunctions_4_4_Compatibility_GlInvalidateTexSubImage5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glInvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
}
void QOpenGLFunctions_4_4_Compatibility_GlLightModelf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glLightModelf(pname, param);
}
void QOpenGLFunctions_4_4_Compatibility_GlLightModelfv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glLightModelfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_4_Compatibility_GlLightModeli5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glLightModeli(pname, param);
}
void QOpenGLFunctions_4_4_Compatibility_GlLightModeliv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glLightModeliv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_4_Compatibility_GlLightf5(void* ptr, unsigned int light, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glLightf(light, pname, param);
}
void QOpenGLFunctions_4_4_Compatibility_GlLightfv5(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glLightfv(light, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_4_Compatibility_GlLighti5(void* ptr, unsigned int light, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glLighti(light, pname, param);
}
void QOpenGLFunctions_4_4_Compatibility_GlLightiv5(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glLightiv(light, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_4_Compatibility_GlLineStipple5(void* ptr, int factor, unsigned short pattern)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glLineStipple(factor, pattern);
}
void QOpenGLFunctions_4_4_Compatibility_GlLineWidth5(void* ptr, float width)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_4_4_Compatibility_GlLinkProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glLinkProgram(program);
}
void QOpenGLFunctions_4_4_Compatibility_GlListBase5(void* ptr, unsigned int base)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glListBase(base);
}
void QOpenGLFunctions_4_4_Compatibility_GlLoadIdentity5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glLoadIdentity();
}
void QOpenGLFunctions_4_4_Compatibility_GlLoadMatrixf5(void* ptr, float m)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glLoadMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_4_4_Compatibility_GlLoadName5(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glLoadName(name);
}
void QOpenGLFunctions_4_4_Compatibility_GlLoadTransposeMatrixf5(void* ptr, float m)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glLoadTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_4_4_Compatibility_GlLogicOp5(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_4_4_Compatibility_GlMap1f5(void* ptr, unsigned int target, float u1, float u2, int stride, int order, float points)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMap1f(target, u1, u2, stride, order, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_4_4_Compatibility_GlMap2f5(void* ptr, unsigned int target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float points)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_4_4_Compatibility_GlMapGrid1f5(void* ptr, int un, float u1, float u2)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMapGrid1f(un, u1, u2);
}
void QOpenGLFunctions_4_4_Compatibility_GlMapGrid2f5(void* ptr, int un, float u1, float u2, int vn, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMapGrid2f(un, u1, u2, vn, v1, v2);
}
void QOpenGLFunctions_4_4_Compatibility_GlMaterialf5(void* ptr, unsigned int face, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMaterialf(face, pname, param);
}
void QOpenGLFunctions_4_4_Compatibility_GlMaterialfv5(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMaterialfv(face, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_4_Compatibility_GlMateriali5(void* ptr, unsigned int face, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMateriali(face, pname, param);
}
void QOpenGLFunctions_4_4_Compatibility_GlMaterialiv5(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMaterialiv(face, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_4_Compatibility_GlMatrixMode5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMatrixMode(mode);
}
void QOpenGLFunctions_4_4_Compatibility_GlMemoryBarrier5(void* ptr, unsigned int barriers)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMemoryBarrier(barriers);
}
void QOpenGLFunctions_4_4_Compatibility_GlMinSampleShading5(void* ptr, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMinSampleShading(value);
}
void QOpenGLFunctions_4_4_Compatibility_GlMinmax5(void* ptr, unsigned int target, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMinmax(target, internalformat, sink != 0);
}
void QOpenGLFunctions_4_4_Compatibility_GlMultMatrixf5(void* ptr, float m)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_4_4_Compatibility_GlMultTransposeMatrixf5(void* ptr, float m)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiDrawArrays5(void* ptr, unsigned int mode, int first, int count, int drawcount)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiDrawArrays(mode, const_cast<const GLint*>(&first), const_cast<const GLsizei*>(&count), drawcount);
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiDrawArraysIndirect5(void* ptr, unsigned int mode, void* indirect, int drawcount, int stride)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiDrawArraysIndirect(mode, indirect, drawcount, stride);
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiDrawElementsIndirect5(void* ptr, unsigned int mode, unsigned int ty, void* indirect, int drawcount, int stride)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiDrawElementsIndirect(mode, ty, indirect, drawcount, stride);
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoord1f5(void* ptr, unsigned int target, float s)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoord1f(target, s);
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoord1fv5(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoord1fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoord1i5(void* ptr, unsigned int target, int s)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoord1i(target, s);
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoord1iv5(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoord1iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoord1s5(void* ptr, unsigned int target, short s)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoord1s(target, s);
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoord1sv5(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoord1sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoord2f5(void* ptr, unsigned int target, float s, float t)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoord2f(target, s, t);
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoord2fv5(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoord2fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoord2i5(void* ptr, unsigned int target, int s, int t)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoord2i(target, s, t);
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoord2iv5(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoord2iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoord2s5(void* ptr, unsigned int target, short s, short t)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoord2s(target, s, t);
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoord2sv5(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoord2sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoord3f5(void* ptr, unsigned int target, float s, float t, float r)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoord3f(target, s, t, r);
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoord3fv5(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoord3fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoord3i5(void* ptr, unsigned int target, int s, int t, int r)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoord3i(target, s, t, r);
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoord3iv5(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoord3iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoord3s5(void* ptr, unsigned int target, short s, short t, short r)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoord3s(target, s, t, r);
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoord3sv5(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoord3sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoord4f5(void* ptr, unsigned int target, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoord4f(target, s, t, r, q);
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoord4fv5(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoord4fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoord4i5(void* ptr, unsigned int target, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoord4i(target, s, t, r, q);
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoord4iv5(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoord4iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoord4s5(void* ptr, unsigned int target, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoord4s(target, s, t, r, q);
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoord4sv5(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoord4sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoordP1ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoordP1ui(texture, ty, coords);
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoordP1uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoordP1uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoordP2ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoordP2ui(texture, ty, coords);
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoordP2uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoordP2uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoordP3ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoordP3ui(texture, ty, coords);
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoordP3uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoordP3uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoordP4ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoordP4ui(texture, ty, coords);
}
void QOpenGLFunctions_4_4_Compatibility_GlMultiTexCoordP4uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glMultiTexCoordP4uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_4_Compatibility_GlNewList5(void* ptr, unsigned int list, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glNewList(list, mode);
}
void QOpenGLFunctions_4_4_Compatibility_GlNormal3f5(void* ptr, float nx, float ny, float nz)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glNormal3f(nx, ny, nz);
}
void QOpenGLFunctions_4_4_Compatibility_GlNormal3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glNormal3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlNormal3i5(void* ptr, int nx, int ny, int nz)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glNormal3i(nx, ny, nz);
}
void QOpenGLFunctions_4_4_Compatibility_GlNormal3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glNormal3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlNormal3s5(void* ptr, short nx, short ny, short nz)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glNormal3s(nx, ny, nz);
}
void QOpenGLFunctions_4_4_Compatibility_GlNormal3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glNormal3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlNormalP3ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glNormalP3ui(ty, coords);
}
void QOpenGLFunctions_4_4_Compatibility_GlNormalP3uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glNormalP3uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_4_Compatibility_GlNormalPointer5(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glNormalPointer(ty, stride, pointer);
}
void QOpenGLFunctions_4_4_Compatibility_GlPassThrough5(void* ptr, float token)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPassThrough(token);
}
void QOpenGLFunctions_4_4_Compatibility_GlPatchParameterfv5(void* ptr, unsigned int pname, float values)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPatchParameterfv(pname, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_4_4_Compatibility_GlPatchParameteri5(void* ptr, unsigned int pname, int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPatchParameteri(pname, value);
}
void QOpenGLFunctions_4_4_Compatibility_GlPauseTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPauseTransformFeedback();
}
void QOpenGLFunctions_4_4_Compatibility_GlPixelMapfv5(void* ptr, unsigned int m, int mapsize, float values)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPixelMapfv(m, mapsize, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_4_4_Compatibility_GlPixelMapuiv5(void* ptr, unsigned int m, int mapsize, unsigned int values)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPixelMapuiv(m, mapsize, const_cast<const GLuint*>(&values));
}
void QOpenGLFunctions_4_4_Compatibility_GlPixelMapusv5(void* ptr, unsigned int m, int mapsize, unsigned short values)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPixelMapusv(m, mapsize, const_cast<const GLushort*>(&values));
}
void QOpenGLFunctions_4_4_Compatibility_GlPixelStoref5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_4_4_Compatibility_GlPixelStorei5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_4_4_Compatibility_GlPixelTransferf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPixelTransferf(pname, param);
}
void QOpenGLFunctions_4_4_Compatibility_GlPixelTransferi5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPixelTransferi(pname, param);
}
void QOpenGLFunctions_4_4_Compatibility_GlPixelZoom5(void* ptr, float xfactor, float yfactor)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPixelZoom(xfactor, yfactor);
}
void QOpenGLFunctions_4_4_Compatibility_GlPointParameterf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPointParameterf(pname, param);
}
void QOpenGLFunctions_4_4_Compatibility_GlPointParameterfv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPointParameterfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_4_Compatibility_GlPointParameteri5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPointParameteri(pname, param);
}
void QOpenGLFunctions_4_4_Compatibility_GlPointParameteriv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPointParameteriv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_4_Compatibility_GlPointSize5(void* ptr, float size)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_4_4_Compatibility_GlPolygonMode5(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_4_4_Compatibility_GlPolygonOffset5(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_4_4_Compatibility_GlPolygonStipple5(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPolygonStipple(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(mask))));
}
void QOpenGLFunctions_4_4_Compatibility_GlPopAttrib5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPopAttrib();
}
void QOpenGLFunctions_4_4_Compatibility_GlPopClientAttrib5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPopClientAttrib();
}
void QOpenGLFunctions_4_4_Compatibility_GlPopDebugGroup5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPopDebugGroup();
}
void QOpenGLFunctions_4_4_Compatibility_GlPopMatrix5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPopMatrix();
}
void QOpenGLFunctions_4_4_Compatibility_GlPopName5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPopName();
}
void QOpenGLFunctions_4_4_Compatibility_GlPrimitiveRestartIndex5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPrimitiveRestartIndex(index);
}
void QOpenGLFunctions_4_4_Compatibility_GlPrioritizeTextures5(void* ptr, int n, unsigned int textures, float priorities)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPrioritizeTextures(n, const_cast<const GLuint*>(&textures), const_cast<const GLfloat*>(&priorities));
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramBinary5(void* ptr, unsigned int program, unsigned int binaryFormat, void* binary, int length)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramBinary(program, binaryFormat, binary, length);
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramParameteri5(void* ptr, unsigned int program, unsigned int pname, int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramParameteri(program, pname, value);
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniform1f5(void* ptr, unsigned int program, int location, float v0)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniform1f(program, location, v0);
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniform1fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniform1fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniform1i5(void* ptr, unsigned int program, int location, int v0)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniform1i(program, location, v0);
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniform1iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniform1iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniform1ui5(void* ptr, unsigned int program, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniform1ui(program, location, v0);
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniform1uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniform1uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniform2f5(void* ptr, unsigned int program, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniform2f(program, location, v0, v1);
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniform2fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniform2fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniform2i5(void* ptr, unsigned int program, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniform2i(program, location, v0, v1);
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniform2iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniform2iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniform2ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniform2ui(program, location, v0, v1);
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniform2uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniform2uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniform3f5(void* ptr, unsigned int program, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniform3f(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniform3fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniform3fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniform3i5(void* ptr, unsigned int program, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniform3i(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniform3iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniform3iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniform3ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniform3ui(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniform3uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniform3uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniform4f5(void* ptr, unsigned int program, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniform4f(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniform4fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniform4fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniform4i5(void* ptr, unsigned int program, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniform4i(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniform4iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniform4iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniform4ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniform4ui(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniform4uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniform4uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniformMatrix2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniformMatrix2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniformMatrix2x3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniformMatrix2x3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniformMatrix2x4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniformMatrix2x4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniformMatrix3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniformMatrix3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniformMatrix3x2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniformMatrix3x2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniformMatrix3x4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniformMatrix3x4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniformMatrix4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniformMatrix4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniformMatrix4x2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniformMatrix4x2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlProgramUniformMatrix4x3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProgramUniformMatrix4x3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlProvokingVertex5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glProvokingVertex(mode);
}
void QOpenGLFunctions_4_4_Compatibility_GlPushAttrib5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPushAttrib(mask);
}
void QOpenGLFunctions_4_4_Compatibility_GlPushClientAttrib5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPushClientAttrib(mask);
}
void QOpenGLFunctions_4_4_Compatibility_GlPushMatrix5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPushMatrix();
}
void QOpenGLFunctions_4_4_Compatibility_GlPushName5(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glPushName(name);
}
void QOpenGLFunctions_4_4_Compatibility_GlQueryCounter5(void* ptr, unsigned int id, unsigned int target)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glQueryCounter(id, target);
}
void QOpenGLFunctions_4_4_Compatibility_GlRasterPos2f5(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRasterPos2f(x, y);
}
void QOpenGLFunctions_4_4_Compatibility_GlRasterPos2fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRasterPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlRasterPos2i5(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRasterPos2i(x, y);
}
void QOpenGLFunctions_4_4_Compatibility_GlRasterPos2iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRasterPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlRasterPos2s5(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRasterPos2s(x, y);
}
void QOpenGLFunctions_4_4_Compatibility_GlRasterPos2sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRasterPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlRasterPos3f5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRasterPos3f(x, y, z);
}
void QOpenGLFunctions_4_4_Compatibility_GlRasterPos3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRasterPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlRasterPos3i5(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRasterPos3i(x, y, z);
}
void QOpenGLFunctions_4_4_Compatibility_GlRasterPos3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRasterPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlRasterPos3s5(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRasterPos3s(x, y, z);
}
void QOpenGLFunctions_4_4_Compatibility_GlRasterPos3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRasterPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlRasterPos4f5(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRasterPos4f(x, y, z, w);
}
void QOpenGLFunctions_4_4_Compatibility_GlRasterPos4fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRasterPos4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlRasterPos4i5(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRasterPos4i(x, y, z, w);
}
void QOpenGLFunctions_4_4_Compatibility_GlRasterPos4iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRasterPos4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlRasterPos4s5(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRasterPos4s(x, y, z, w);
}
void QOpenGLFunctions_4_4_Compatibility_GlRasterPos4sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRasterPos4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlReadBuffer5(void* ptr, unsigned int src)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glReadBuffer(src);
}
void QOpenGLFunctions_4_4_Compatibility_GlReadPixels5(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_4_Compatibility_GlRectf5(void* ptr, float x1, float y1, float x2, float y2)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRectf(x1, y1, x2, y2);
}
void QOpenGLFunctions_4_4_Compatibility_GlRectfv5(void* ptr, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRectfv(const_cast<const GLfloat*>(&v1), const_cast<const GLfloat*>(&v2));
}
void QOpenGLFunctions_4_4_Compatibility_GlRecti5(void* ptr, int x1, int y1, int x2, int y2)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRecti(x1, y1, x2, y2);
}
void QOpenGLFunctions_4_4_Compatibility_GlRectiv5(void* ptr, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRectiv(const_cast<const GLint*>(&v1), const_cast<const GLint*>(&v2));
}
void QOpenGLFunctions_4_4_Compatibility_GlRects5(void* ptr, short x1, short y1, short x2, short y2)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRects(x1, y1, x2, y2);
}
void QOpenGLFunctions_4_4_Compatibility_GlRectsv5(void* ptr, short v1, short v2)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRectsv(const_cast<const GLshort*>(&v1), const_cast<const GLshort*>(&v2));
}
void QOpenGLFunctions_4_4_Compatibility_GlReleaseShaderCompiler5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glReleaseShaderCompiler();
}
void QOpenGLFunctions_4_4_Compatibility_GlRenderbufferStorage5(void* ptr, unsigned int target, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRenderbufferStorage(target, internalformat, width, height);
}
void QOpenGLFunctions_4_4_Compatibility_GlRenderbufferStorageMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
}
void QOpenGLFunctions_4_4_Compatibility_GlResetHistogram5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glResetHistogram(target);
}
void QOpenGLFunctions_4_4_Compatibility_GlResetMinmax5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glResetMinmax(target);
}
void QOpenGLFunctions_4_4_Compatibility_GlResumeTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glResumeTransformFeedback();
}
void QOpenGLFunctions_4_4_Compatibility_GlRotatef5(void* ptr, float angle, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glRotatef(angle, x, y, z);
}
void QOpenGLFunctions_4_4_Compatibility_GlSampleCoverage5(void* ptr, float value, char invert)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSampleCoverage(value, invert != 0);
}
void QOpenGLFunctions_4_4_Compatibility_GlSampleMaski5(void* ptr, unsigned int maskNumber, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSampleMaski(maskNumber, mask);
}
void QOpenGLFunctions_4_4_Compatibility_GlSamplerParameterIiv5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSamplerParameterIiv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_4_Compatibility_GlSamplerParameterIuiv5(void* ptr, unsigned int sampler, unsigned int pname, unsigned int param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSamplerParameterIuiv(sampler, pname, const_cast<const GLuint*>(&param));
}
void QOpenGLFunctions_4_4_Compatibility_GlSamplerParameterf5(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSamplerParameterf(sampler, pname, param);
}
void QOpenGLFunctions_4_4_Compatibility_GlSamplerParameterfv5(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSamplerParameterfv(sampler, pname, const_cast<const GLfloat*>(&param));
}
void QOpenGLFunctions_4_4_Compatibility_GlSamplerParameteri5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSamplerParameteri(sampler, pname, param);
}
void QOpenGLFunctions_4_4_Compatibility_GlSamplerParameteriv5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSamplerParameteriv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_4_Compatibility_GlScalef5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glScalef(x, y, z);
}
void QOpenGLFunctions_4_4_Compatibility_GlScissor5(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_4_4_Compatibility_GlScissorArrayv5(void* ptr, unsigned int first, int count, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glScissorArrayv(first, count, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlScissorIndexed5(void* ptr, unsigned int index, int left, int bottom, int width, int height)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glScissorIndexed(index, left, bottom, width, height);
}
void QOpenGLFunctions_4_4_Compatibility_GlScissorIndexedv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glScissorIndexedv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlSecondaryColor3f5(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSecondaryColor3f(red, green, blue);
}
void QOpenGLFunctions_4_4_Compatibility_GlSecondaryColor3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSecondaryColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlSecondaryColor3i5(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSecondaryColor3i(red, green, blue);
}
void QOpenGLFunctions_4_4_Compatibility_GlSecondaryColor3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSecondaryColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlSecondaryColor3s5(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSecondaryColor3s(red, green, blue);
}
void QOpenGLFunctions_4_4_Compatibility_GlSecondaryColor3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSecondaryColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlSecondaryColor3ub5(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSecondaryColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_4_4_Compatibility_GlSecondaryColor3ubv5(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSecondaryColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_4_Compatibility_GlSecondaryColor3ui5(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSecondaryColor3ui(red, green, blue);
}
void QOpenGLFunctions_4_4_Compatibility_GlSecondaryColor3uiv5(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSecondaryColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlSecondaryColor3us5(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSecondaryColor3us(red, green, blue);
}
void QOpenGLFunctions_4_4_Compatibility_GlSecondaryColor3usv5(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSecondaryColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlSecondaryColorP3ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSecondaryColorP3ui(ty, color);
}
void QOpenGLFunctions_4_4_Compatibility_GlSecondaryColorP3uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSecondaryColorP3uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_4_Compatibility_GlSecondaryColorPointer5(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSecondaryColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_4_4_Compatibility_GlSelectBuffer5(void* ptr, int size, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSelectBuffer(size, &buffer);
}
void QOpenGLFunctions_4_4_Compatibility_GlSeparableFilter2D5(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* row, void* column)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glSeparableFilter2D(target, internalformat, width, height, format, ty, row, column);
}
void QOpenGLFunctions_4_4_Compatibility_GlShadeModel5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glShadeModel(mode);
}
void QOpenGLFunctions_4_4_Compatibility_GlShaderBinary5(void* ptr, int count, unsigned int shaders, unsigned int binaryformat, void* binary, int length)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glShaderBinary(count, const_cast<const GLuint*>(&shaders), binaryformat, binary, length);
}
void QOpenGLFunctions_4_4_Compatibility_GlShaderStorageBlockBinding5(void* ptr, unsigned int program, unsigned int storageBlockIndex, unsigned int storageBlockBinding)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
}
void QOpenGLFunctions_4_4_Compatibility_GlStencilFunc5(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_4_4_Compatibility_GlStencilFuncSeparate5(void* ptr, unsigned int face, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glStencilFuncSeparate(face, fu, ref, mask);
}
void QOpenGLFunctions_4_4_Compatibility_GlStencilMask5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_4_4_Compatibility_GlStencilMaskSeparate5(void* ptr, unsigned int face, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glStencilMaskSeparate(face, mask);
}
void QOpenGLFunctions_4_4_Compatibility_GlStencilOp5(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_4_4_Compatibility_GlStencilOpSeparate5(void* ptr, unsigned int face, unsigned int sfail, unsigned int dpfail, unsigned int dppass)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glStencilOpSeparate(face, sfail, dpfail, dppass);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexBuffer5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexBuffer(target, internalformat, buffer);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoord1f5(void* ptr, float s)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoord1f(s);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoord1fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoord1fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoord1i5(void* ptr, int s)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoord1i(s);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoord1iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoord1iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoord1s5(void* ptr, short s)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoord1s(s);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoord1sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoord1sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoord2f5(void* ptr, float s, float t)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoord2f(s, t);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoord2fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoord2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoord2i5(void* ptr, int s, int t)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoord2i(s, t);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoord2iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoord2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoord2s5(void* ptr, short s, short t)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoord2s(s, t);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoord2sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoord2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoord3f5(void* ptr, float s, float t, float r)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoord3f(s, t, r);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoord3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoord3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoord3i5(void* ptr, int s, int t, int r)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoord3i(s, t, r);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoord3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoord3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoord3s5(void* ptr, short s, short t, short r)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoord3s(s, t, r);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoord3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoord3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoord4f5(void* ptr, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoord4f(s, t, r, q);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoord4fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoord4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoord4i5(void* ptr, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoord4i(s, t, r, q);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoord4iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoord4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoord4s5(void* ptr, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoord4s(s, t, r, q);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoord4sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoord4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoordP1ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoordP1ui(ty, coords);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoordP1uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoordP1uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoordP2ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoordP2ui(ty, coords);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoordP2uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoordP2uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoordP3ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoordP3ui(ty, coords);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoordP3uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoordP3uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoordP4ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoordP4ui(ty, coords);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoordP4uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoordP4uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_4_Compatibility_GlTexCoordPointer5(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexCoordPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexEnvf5(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexEnvf(target, pname, param);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexEnvfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexEnvfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_4_Compatibility_GlTexEnvi5(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexEnvi(target, pname, param);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexEnviv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexEnviv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_4_Compatibility_GlTexGenf5(void* ptr, unsigned int coord, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexGenf(coord, pname, param);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexGenfv5(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexGenfv(coord, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_4_Compatibility_GlTexGeni5(void* ptr, unsigned int coord, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexGeni(coord, pname, param);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexGeniv5(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexGeniv(coord, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_4_Compatibility_GlTexImage1D5(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexImage2D5(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexImage2DMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexImage3D5(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexImage3DMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexParameterIiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexParameterIiv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_4_Compatibility_GlTexParameterIuiv5(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexParameterIuiv(target, pname, const_cast<const GLuint*>(&params));
}
void QOpenGLFunctions_4_4_Compatibility_GlTexParameterf5(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_4_Compatibility_GlTexParameteri5(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_4_Compatibility_GlTexStorage1D5(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexStorage1D(target, levels, internalformat, width);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexStorage2D5(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexStorage2D(target, levels, internalformat, width, height);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexStorage2DMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexStorage3D5(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width, int height, int depth)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexStorage3D(target, levels, internalformat, width, height, depth);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexStorage3DMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_4_Compatibility_GlTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_4_4_Compatibility_GlTextureView5(void* ptr, unsigned int texture, unsigned int target, unsigned int origtexture, unsigned int internalformat, unsigned int minlevel, unsigned int numlevels, unsigned int minlayer, unsigned int numlayers)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
}
void QOpenGLFunctions_4_4_Compatibility_GlTranslatef5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glTranslatef(x, y, z);
}
void QOpenGLFunctions_4_4_Compatibility_GlUniform1f5(void* ptr, int location, float v0)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniform1f(location, v0);
}
void QOpenGLFunctions_4_4_Compatibility_GlUniform1fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniform1fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlUniform1i5(void* ptr, int location, int v0)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniform1i(location, v0);
}
void QOpenGLFunctions_4_4_Compatibility_GlUniform1iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniform1iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlUniform1ui5(void* ptr, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniform1ui(location, v0);
}
void QOpenGLFunctions_4_4_Compatibility_GlUniform1uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniform1uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlUniform2f5(void* ptr, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniform2f(location, v0, v1);
}
void QOpenGLFunctions_4_4_Compatibility_GlUniform2fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniform2fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlUniform2i5(void* ptr, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniform2i(location, v0, v1);
}
void QOpenGLFunctions_4_4_Compatibility_GlUniform2iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniform2iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlUniform2ui5(void* ptr, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniform2ui(location, v0, v1);
}
void QOpenGLFunctions_4_4_Compatibility_GlUniform2uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniform2uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlUniform3f5(void* ptr, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniform3f(location, v0, v1, v2);
}
void QOpenGLFunctions_4_4_Compatibility_GlUniform3fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniform3fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlUniform3i5(void* ptr, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniform3i(location, v0, v1, v2);
}
void QOpenGLFunctions_4_4_Compatibility_GlUniform3iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniform3iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlUniform3ui5(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniform3ui(location, v0, v1, v2);
}
void QOpenGLFunctions_4_4_Compatibility_GlUniform3uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniform3uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlUniform4f5(void* ptr, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniform4f(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_4_Compatibility_GlUniform4fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniform4fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlUniform4i5(void* ptr, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniform4i(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_4_Compatibility_GlUniform4iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniform4iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlUniform4ui5(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniform4ui(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_4_Compatibility_GlUniform4uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniform4uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlUniformBlockBinding5(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int uniformBlockBinding)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}
void QOpenGLFunctions_4_4_Compatibility_GlUniformMatrix2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniformMatrix2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlUniformMatrix2x3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniformMatrix2x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlUniformMatrix2x4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniformMatrix2x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlUniformMatrix3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniformMatrix3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlUniformMatrix3x2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniformMatrix3x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlUniformMatrix3x4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniformMatrix3x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlUniformMatrix4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniformMatrix4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlUniformMatrix4x2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniformMatrix4x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlUniformMatrix4x3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniformMatrix4x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlUniformSubroutinesuiv5(void* ptr, unsigned int shadertype, int count, unsigned int indices)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUniformSubroutinesuiv(shadertype, count, const_cast<const GLuint*>(&indices));
}
void QOpenGLFunctions_4_4_Compatibility_GlUseProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUseProgram(program);
}
void QOpenGLFunctions_4_4_Compatibility_GlUseProgramStages5(void* ptr, unsigned int pipeline, unsigned int stages, unsigned int program)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glUseProgramStages(pipeline, stages, program);
}
void QOpenGLFunctions_4_4_Compatibility_GlValidateProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glValidateProgram(program);
}
void QOpenGLFunctions_4_4_Compatibility_GlValidateProgramPipeline5(void* ptr, unsigned int pipeline)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glValidateProgramPipeline(pipeline);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertex2f5(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertex2f(x, y);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertex2fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertex2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertex2i5(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertex2i(x, y);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertex2iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertex2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertex2s5(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertex2s(x, y);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertex2sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertex2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertex3f5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertex3f(x, y, z);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertex3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertex3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertex3i5(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertex3i(x, y, z);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertex3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertex3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertex3s5(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertex3s(x, y, z);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertex3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertex3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertex4f5(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertex4f(x, y, z, w);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertex4fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertex4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertex4i5(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertex4i(x, y, z, w);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertex4iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertex4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertex4s5(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertex4s(x, y, z, w);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertex4sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertex4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib1f5(void* ptr, unsigned int index, float x)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib1f(index, x);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib1fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib1fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib1s5(void* ptr, unsigned int index, short x)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib1s(index, x);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib1sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib1sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib2f5(void* ptr, unsigned int index, float x, float y)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib2f(index, x, y);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib2fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib2fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib2s5(void* ptr, unsigned int index, short x, short y)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib2s(index, x, y);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib2sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib2sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib3f5(void* ptr, unsigned int index, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib3f(index, x, y, z);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib3fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib3fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib3s5(void* ptr, unsigned int index, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib3s(index, x, y, z);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib3sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib3sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib4Niv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib4Niv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib4Nsv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib4Nsv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib4Nub5(void* ptr, unsigned int index, char* x, char* y, char* z, char* w)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib4Nub(index, *static_cast<GLubyte*>(static_cast<void*>(x)), *static_cast<GLubyte*>(static_cast<void*>(y)), *static_cast<GLubyte*>(static_cast<void*>(z)), *static_cast<GLubyte*>(static_cast<void*>(w)));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib4Nubv5(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib4Nubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib4Nuiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib4Nuiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib4Nusv5(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib4Nusv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib4f5(void* ptr, unsigned int index, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib4f(index, x, y, z, w);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib4fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib4fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib4iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib4s5(void* ptr, unsigned int index, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib4s(index, x, y, z, w);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib4sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib4sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib4ubv5(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib4ubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib4uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttrib4usv5(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttrib4usv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribBinding5(void* ptr, unsigned int attribindex, unsigned int bindingindex)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribBinding(attribindex, bindingindex);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribDivisor5(void* ptr, unsigned int index, unsigned int divisor)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribDivisor(index, divisor);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribFormat5(void* ptr, unsigned int attribindex, int size, unsigned int ty, char normalized, unsigned int relativeoffset)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribFormat(attribindex, size, ty, normalized != 0, relativeoffset);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribI1i5(void* ptr, unsigned int index, int x)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribI1i(index, x);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribI1iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribI1iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribI1ui5(void* ptr, unsigned int index, unsigned int x)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribI1ui(index, x);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribI1uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribI1uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribI2i5(void* ptr, unsigned int index, int x, int y)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribI2i(index, x, y);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribI2iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribI2iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribI2ui5(void* ptr, unsigned int index, unsigned int x, unsigned int y)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribI2ui(index, x, y);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribI2uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribI2uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribI3i5(void* ptr, unsigned int index, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribI3i(index, x, y, z);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribI3iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribI3iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribI3ui5(void* ptr, unsigned int index, unsigned int x, unsigned int y, unsigned int z)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribI3ui(index, x, y, z);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribI3uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribI3uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribI4i5(void* ptr, unsigned int index, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribI4i(index, x, y, z, w);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribI4iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribI4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribI4sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribI4sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribI4ubv5(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribI4ubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribI4ui5(void* ptr, unsigned int index, unsigned int x, unsigned int y, unsigned int z, unsigned int w)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribI4ui(index, x, y, z, w);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribI4uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribI4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribI4usv5(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribI4usv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribIFormat5(void* ptr, unsigned int attribindex, int size, unsigned int ty, unsigned int relativeoffset)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribIFormat(attribindex, size, ty, relativeoffset);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribIPointer5(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribIPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribLFormat5(void* ptr, unsigned int attribindex, int size, unsigned int ty, unsigned int relativeoffset)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribLFormat(attribindex, size, ty, relativeoffset);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribLPointer5(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribLPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribP1ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribP1ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribP1uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribP1uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribP2ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribP2ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribP2uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribP2uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribP3ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribP3ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribP3uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribP3uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribP4ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribP4ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribP4uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribP4uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexAttribPointer5(void* ptr, unsigned int index, int size, unsigned int ty, char normalized, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexAttribPointer(index, size, ty, normalized != 0, stride, pointer);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexBindingDivisor5(void* ptr, unsigned int bindingindex, unsigned int divisor)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexBindingDivisor(bindingindex, divisor);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexP2ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexP2ui(ty, value);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexP2uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexP2uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexP3ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexP3ui(ty, value);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexP3uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexP3uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexP4ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexP4ui(ty, value);
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexP4uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexP4uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Compatibility_GlVertexPointer5(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glVertexPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_4_4_Compatibility_GlViewport5(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_4_4_Compatibility_GlViewportArrayv5(void* ptr, unsigned int first, int count, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glViewportArrayv(first, count, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlViewportIndexedf5(void* ptr, unsigned int index, float x, float y, float w, float h)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glViewportIndexedf(index, x, y, w, h);
}
void QOpenGLFunctions_4_4_Compatibility_GlViewportIndexedfv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glViewportIndexedfv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlWindowPos2f5(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glWindowPos2f(x, y);
}
void QOpenGLFunctions_4_4_Compatibility_GlWindowPos2fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glWindowPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlWindowPos2i5(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glWindowPos2i(x, y);
}
void QOpenGLFunctions_4_4_Compatibility_GlWindowPos2iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glWindowPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlWindowPos2s5(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glWindowPos2s(x, y);
}
void QOpenGLFunctions_4_4_Compatibility_GlWindowPos2sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glWindowPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlWindowPos3f5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glWindowPos3f(x, y, z);
}
void QOpenGLFunctions_4_4_Compatibility_GlWindowPos3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glWindowPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlWindowPos3i5(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glWindowPos3i(x, y, z);
}
void QOpenGLFunctions_4_4_Compatibility_GlWindowPos3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glWindowPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_GlWindowPos3s5(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glWindowPos3s(x, y, z);
}
void QOpenGLFunctions_4_4_Compatibility_GlWindowPos3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glWindowPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Compatibility_DestroyQOpenGLFunctions_4_4_Compatibility5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->~QOpenGLFunctions_4_4_Compatibility();
}
void QOpenGLFunctions_4_4_Compatibility_DestroyQOpenGLFunctions_4_4_Compatibility5Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_4_4_Core: public QOpenGLFunctions_4_4_Core
{
public:
MyQOpenGLFunctions_4_4_Core() : QOpenGLFunctions_4_4_Core() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_4_4_Core_InitializeOpenGLFunctions5(this) != 0; };
~MyQOpenGLFunctions_4_4_Core() { callbackQOpenGLFunctions_4_4_Core_DestroyQOpenGLFunctions_4_4_Core5(this); };
};
char QOpenGLFunctions_4_4_Core_GlIsBuffer5(void* ptr, unsigned int buffer)
{
return static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glIsBuffer(buffer);
}
char QOpenGLFunctions_4_4_Core_GlIsEnabled5(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_4_4_Core_GlIsEnabledi5(void* ptr, unsigned int target, unsigned int index)
{
return static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glIsEnabledi(target, index);
}
char QOpenGLFunctions_4_4_Core_GlIsFramebuffer5(void* ptr, unsigned int framebuffer)
{
return static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glIsFramebuffer(framebuffer);
}
char QOpenGLFunctions_4_4_Core_GlIsProgram5(void* ptr, unsigned int program)
{
return static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glIsProgram(program);
}
char QOpenGLFunctions_4_4_Core_GlIsProgramPipeline5(void* ptr, unsigned int pipeline)
{
return static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glIsProgramPipeline(pipeline);
}
char QOpenGLFunctions_4_4_Core_GlIsQuery5(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glIsQuery(id);
}
char QOpenGLFunctions_4_4_Core_GlIsRenderbuffer5(void* ptr, unsigned int renderbuffer)
{
return static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glIsRenderbuffer(renderbuffer);
}
char QOpenGLFunctions_4_4_Core_GlIsSampler5(void* ptr, unsigned int sampler)
{
return static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glIsSampler(sampler);
}
char QOpenGLFunctions_4_4_Core_GlIsShader5(void* ptr, unsigned int shader)
{
return static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glIsShader(shader);
}
char QOpenGLFunctions_4_4_Core_GlIsTexture5(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glIsTexture(texture);
}
char QOpenGLFunctions_4_4_Core_GlIsTransformFeedback5(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glIsTransformFeedback(id);
}
char QOpenGLFunctions_4_4_Core_GlIsVertexArray5(void* ptr, unsigned int array)
{
return static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glIsVertexArray(array);
}
char QOpenGLFunctions_4_4_Core_GlUnmapBuffer5(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUnmapBuffer(target);
}
unsigned int QOpenGLFunctions_4_4_Core_GlCheckFramebufferStatus5(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glCheckFramebufferStatus(target);
}
unsigned int QOpenGLFunctions_4_4_Core_GlGetError5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetError();
}
unsigned int QOpenGLFunctions_4_4_Core_GlCreateProgram5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glCreateProgram();
}
unsigned int QOpenGLFunctions_4_4_Core_GlCreateShader5(void* ptr, unsigned int ty)
{
return static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glCreateShader(ty);
}
void* QOpenGLFunctions_4_4_Core_NewQOpenGLFunctions_4_4_Core5()
{
return new MyQOpenGLFunctions_4_4_Core();
}
char QOpenGLFunctions_4_4_Core_InitializeOpenGLFunctions5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_4_4_Core_InitializeOpenGLFunctions5Default(void* ptr)
{
return static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->QOpenGLFunctions_4_4_Core::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_4_4_Core_GlGetString5(void* ptr, unsigned int name)
{
return ({ char* tba7ddf = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetString(name)))); QtGui_PackedString { tba7ddf, -1 }; });
}
struct QtGui_PackedString QOpenGLFunctions_4_4_Core_GlGetStringi5(void* ptr, unsigned int name, unsigned int index)
{
return ({ char* t408efa = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetStringi(name, index)))); QtGui_PackedString { t408efa, -1 }; });
}
void* QOpenGLFunctions_4_4_Core_GlMapBuffer5(void* ptr, unsigned int target, unsigned int access)
{
return static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glMapBuffer(target, access);
}
void QOpenGLFunctions_4_4_Core_GlActiveShaderProgram5(void* ptr, unsigned int pipeline, unsigned int program)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glActiveShaderProgram(pipeline, program);
}
void QOpenGLFunctions_4_4_Core_GlActiveTexture5(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glActiveTexture(texture);
}
void QOpenGLFunctions_4_4_Core_GlAttachShader5(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glAttachShader(program, shader);
}
void QOpenGLFunctions_4_4_Core_GlBeginConditionalRender5(void* ptr, unsigned int id, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBeginConditionalRender(id, mode);
}
void QOpenGLFunctions_4_4_Core_GlBeginQuery5(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBeginQuery(target, id);
}
void QOpenGLFunctions_4_4_Core_GlBeginQueryIndexed5(void* ptr, unsigned int target, unsigned int index, unsigned int id)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBeginQueryIndexed(target, index, id);
}
void QOpenGLFunctions_4_4_Core_GlBeginTransformFeedback5(void* ptr, unsigned int primitiveMode)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBeginTransformFeedback(primitiveMode);
}
void QOpenGLFunctions_4_4_Core_GlBindBuffer5(void* ptr, unsigned int target, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBindBuffer(target, buffer);
}
void QOpenGLFunctions_4_4_Core_GlBindBufferBase5(void* ptr, unsigned int target, unsigned int index, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBindBufferBase(target, index, buffer);
}
void QOpenGLFunctions_4_4_Core_GlBindBuffersBase5(void* ptr, unsigned int target, unsigned int first, int count, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBindBuffersBase(target, first, count, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_4_4_Core_GlBindFramebuffer5(void* ptr, unsigned int target, unsigned int framebuffer)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBindFramebuffer(target, framebuffer);
}
void QOpenGLFunctions_4_4_Core_GlBindImageTexture5(void* ptr, unsigned int unit, unsigned int texture, int level, char layered, int layer, unsigned int access, unsigned int format)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBindImageTexture(unit, texture, level, layered != 0, layer, access, format);
}
void QOpenGLFunctions_4_4_Core_GlBindImageTextures5(void* ptr, unsigned int first, int count, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBindImageTextures(first, count, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_4_4_Core_GlBindProgramPipeline5(void* ptr, unsigned int pipeline)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBindProgramPipeline(pipeline);
}
void QOpenGLFunctions_4_4_Core_GlBindRenderbuffer5(void* ptr, unsigned int target, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBindRenderbuffer(target, renderbuffer);
}
void QOpenGLFunctions_4_4_Core_GlBindSampler5(void* ptr, unsigned int unit, unsigned int sampler)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBindSampler(unit, sampler);
}
void QOpenGLFunctions_4_4_Core_GlBindSamplers5(void* ptr, unsigned int first, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBindSamplers(first, count, const_cast<const GLuint*>(&samplers));
}
void QOpenGLFunctions_4_4_Core_GlBindTexture5(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_4_4_Core_GlBindTextures5(void* ptr, unsigned int first, int count, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBindTextures(first, count, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_4_4_Core_GlBindTransformFeedback5(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBindTransformFeedback(target, id);
}
void QOpenGLFunctions_4_4_Core_GlBindVertexArray5(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBindVertexArray(array);
}
void QOpenGLFunctions_4_4_Core_GlBlendColor5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_4_4_Core_GlBlendEquation5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_4_4_Core_GlBlendEquationSeparate5(void* ptr, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBlendEquationSeparate(modeRGB, modeAlpha);
}
void QOpenGLFunctions_4_4_Core_GlBlendEquationSeparatei5(void* ptr, unsigned int buf, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBlendEquationSeparatei(buf, modeRGB, modeAlpha);
}
void QOpenGLFunctions_4_4_Core_GlBlendEquationi5(void* ptr, unsigned int buf, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBlendEquationi(buf, mode);
}
void QOpenGLFunctions_4_4_Core_GlBlendFunc5(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_4_4_Core_GlBlendFuncSeparate5(void* ptr, unsigned int sfactorRGB, unsigned int dfactorRGB, unsigned int sfactorAlpha, unsigned int dfactorAlpha)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void QOpenGLFunctions_4_4_Core_GlBlendFuncSeparatei5(void* ptr, unsigned int buf, unsigned int srcRGB, unsigned int dstRGB, unsigned int srcAlpha, unsigned int dstAlpha)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
void QOpenGLFunctions_4_4_Core_GlBlendFunci5(void* ptr, unsigned int buf, unsigned int src, unsigned int dst)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBlendFunci(buf, src, dst);
}
void QOpenGLFunctions_4_4_Core_GlBlitFramebuffer5(void* ptr, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, unsigned int mask, unsigned int filter)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
void QOpenGLFunctions_4_4_Core_GlClampColor5(void* ptr, unsigned int target, unsigned int clamp)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glClampColor(target, clamp);
}
void QOpenGLFunctions_4_4_Core_GlClear5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_4_4_Core_GlClearBufferData5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glClearBufferData(target, internalformat, format, ty, data);
}
void QOpenGLFunctions_4_4_Core_GlClearBufferfi5(void* ptr, unsigned int buffer, int drawbuffer, float depth, int stencil)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glClearBufferfi(buffer, drawbuffer, depth, stencil);
}
void QOpenGLFunctions_4_4_Core_GlClearBufferfv5(void* ptr, unsigned int buffer, int drawbuffer, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glClearBufferfv(buffer, drawbuffer, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlClearBufferiv5(void* ptr, unsigned int buffer, int drawbuffer, int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glClearBufferiv(buffer, drawbuffer, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlClearBufferuiv5(void* ptr, unsigned int buffer, int drawbuffer, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glClearBufferuiv(buffer, drawbuffer, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlClearColor5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_4_4_Core_GlClearDepthf5(void* ptr, float dd)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glClearDepthf(dd);
}
void QOpenGLFunctions_4_4_Core_GlClearStencil5(void* ptr, int s)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_4_4_Core_GlClearTexImage5(void* ptr, unsigned int texture, int level, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glClearTexImage(texture, level, format, ty, data);
}
void QOpenGLFunctions_4_4_Core_GlClearTexSubImage5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, data);
}
void QOpenGLFunctions_4_4_Core_GlColorMask5(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_4_4_Core_GlColorMaski5(void* ptr, unsigned int index, char r, char g, char b, char a)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glColorMaski(index, r != 0, g != 0, b != 0, a != 0);
}
void QOpenGLFunctions_4_4_Core_GlCompileShader5(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glCompileShader(shader);
}
void QOpenGLFunctions_4_4_Core_GlCompressedTexImage1D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
void QOpenGLFunctions_4_4_Core_GlCompressedTexImage2D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void QOpenGLFunctions_4_4_Core_GlCompressedTexImage3D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int depth, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void QOpenGLFunctions_4_4_Core_GlCompressedTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_4_4_Core_GlCompressedTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_4_4_Core_GlCompressedTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_4_4_Core_GlCopyImageSubData5(void* ptr, unsigned int srcName, unsigned int srcTarget, int srcLevel, int srcX, int srcY, int srcZ, unsigned int dstName, unsigned int dstTarget, int dstLevel, int dstX, int dstY, int dstZ, int srcWidth, int srcHeight, int srcDepth)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
}
void QOpenGLFunctions_4_4_Core_GlCopyTexImage1D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_4_4_Core_GlCopyTexImage2D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_4_4_Core_GlCopyTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_4_4_Core_GlCopyTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_4_4_Core_GlCopyTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_4_4_Core_GlCullFace5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_4_4_Core_GlDebugMessageControl5(void* ptr, unsigned int source, unsigned int ty, unsigned int severity, int count, unsigned int ids, char enabled)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDebugMessageControl(source, ty, severity, count, const_cast<const GLuint*>(&ids), enabled != 0);
}
void QOpenGLFunctions_4_4_Core_GlDeleteBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDeleteBuffers(n, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_4_4_Core_GlDeleteFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDeleteFramebuffers(n, const_cast<const GLuint*>(&framebuffers));
}
void QOpenGLFunctions_4_4_Core_GlDeleteProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDeleteProgram(program);
}
void QOpenGLFunctions_4_4_Core_GlDeleteProgramPipelines5(void* ptr, int n, unsigned int pipelines)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDeleteProgramPipelines(n, const_cast<const GLuint*>(&pipelines));
}
void QOpenGLFunctions_4_4_Core_GlDeleteQueries5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDeleteQueries(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_4_4_Core_GlDeleteRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDeleteRenderbuffers(n, const_cast<const GLuint*>(&renderbuffers));
}
void QOpenGLFunctions_4_4_Core_GlDeleteSamplers5(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDeleteSamplers(count, const_cast<const GLuint*>(&samplers));
}
void QOpenGLFunctions_4_4_Core_GlDeleteShader5(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDeleteShader(shader);
}
void QOpenGLFunctions_4_4_Core_GlDeleteTextures5(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_4_4_Core_GlDeleteTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDeleteTransformFeedbacks(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_4_4_Core_GlDeleteVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDeleteVertexArrays(n, const_cast<const GLuint*>(&arrays));
}
void QOpenGLFunctions_4_4_Core_GlDepthFunc5(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_4_4_Core_GlDepthMask5(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_4_4_Core_GlDepthRangef5(void* ptr, float n, float fo)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDepthRangef(n, fo);
}
void QOpenGLFunctions_4_4_Core_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDetachShader(program, shader);
}
void QOpenGLFunctions_4_4_Core_GlDisable5(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_4_4_Core_GlDisableVertexAttribArray5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDisableVertexAttribArray(index);
}
void QOpenGLFunctions_4_4_Core_GlDisablei5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDisablei(target, index);
}
void QOpenGLFunctions_4_4_Core_GlDispatchCompute5(void* ptr, unsigned int num_groups_x, unsigned int num_groups_y, unsigned int num_groups_z)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
}
void QOpenGLFunctions_4_4_Core_GlDrawArrays5(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_4_4_Core_GlDrawArraysIndirect5(void* ptr, unsigned int mode, void* indirect)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDrawArraysIndirect(mode, indirect);
}
void QOpenGLFunctions_4_4_Core_GlDrawArraysInstanced5(void* ptr, unsigned int mode, int first, int count, int instancecount)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDrawArraysInstanced(mode, first, count, instancecount);
}
void QOpenGLFunctions_4_4_Core_GlDrawArraysInstancedBaseInstance5(void* ptr, unsigned int mode, int first, int count, int instancecount, unsigned int baseinstance)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
}
void QOpenGLFunctions_4_4_Core_GlDrawBuffer5(void* ptr, unsigned int buf)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDrawBuffer(buf);
}
void QOpenGLFunctions_4_4_Core_GlDrawBuffers5(void* ptr, int n, unsigned int bufs)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDrawBuffers(n, const_cast<const GLenum*>(&bufs));
}
void QOpenGLFunctions_4_4_Core_GlDrawElements5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_4_4_Core_GlDrawElementsBaseVertex5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDrawElementsBaseVertex(mode, count, ty, indices, basevertex);
}
void QOpenGLFunctions_4_4_Core_GlDrawElementsIndirect5(void* ptr, unsigned int mode, unsigned int ty, void* indirect)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDrawElementsIndirect(mode, ty, indirect);
}
void QOpenGLFunctions_4_4_Core_GlDrawElementsInstanced5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDrawElementsInstanced(mode, count, ty, indices, instancecount);
}
void QOpenGLFunctions_4_4_Core_GlDrawElementsInstancedBaseInstance5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, unsigned int baseinstance)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDrawElementsInstancedBaseInstance(mode, count, ty, indices, instancecount, baseinstance);
}
void QOpenGLFunctions_4_4_Core_GlDrawElementsInstancedBaseVertex5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDrawElementsInstancedBaseVertex(mode, count, ty, indices, instancecount, basevertex);
}
void QOpenGLFunctions_4_4_Core_GlDrawElementsInstancedBaseVertexBaseInstance5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex, unsigned int baseinstance)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDrawElementsInstancedBaseVertexBaseInstance(mode, count, ty, indices, instancecount, basevertex, baseinstance);
}
void QOpenGLFunctions_4_4_Core_GlDrawRangeElements5(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLFunctions_4_4_Core_GlDrawRangeElementsBaseVertex5(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDrawRangeElementsBaseVertex(mode, start, end, count, ty, indices, basevertex);
}
void QOpenGLFunctions_4_4_Core_GlDrawTransformFeedback5(void* ptr, unsigned int mode, unsigned int id)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDrawTransformFeedback(mode, id);
}
void QOpenGLFunctions_4_4_Core_GlDrawTransformFeedbackInstanced5(void* ptr, unsigned int mode, unsigned int id, int instancecount)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDrawTransformFeedbackInstanced(mode, id, instancecount);
}
void QOpenGLFunctions_4_4_Core_GlDrawTransformFeedbackStream5(void* ptr, unsigned int mode, unsigned int id, unsigned int stream)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDrawTransformFeedbackStream(mode, id, stream);
}
void QOpenGLFunctions_4_4_Core_GlDrawTransformFeedbackStreamInstanced5(void* ptr, unsigned int mode, unsigned int id, unsigned int stream, int instancecount)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
}
void QOpenGLFunctions_4_4_Core_GlEnable5(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_4_4_Core_GlEnableVertexAttribArray5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glEnableVertexAttribArray(index);
}
void QOpenGLFunctions_4_4_Core_GlEnablei5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glEnablei(target, index);
}
void QOpenGLFunctions_4_4_Core_GlEndConditionalRender5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glEndConditionalRender();
}
void QOpenGLFunctions_4_4_Core_GlEndQuery5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glEndQuery(target);
}
void QOpenGLFunctions_4_4_Core_GlEndQueryIndexed5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glEndQueryIndexed(target, index);
}
void QOpenGLFunctions_4_4_Core_GlEndTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glEndTransformFeedback();
}
void QOpenGLFunctions_4_4_Core_GlFinish5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glFinish();
}
void QOpenGLFunctions_4_4_Core_GlFlush5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glFlush();
}
void QOpenGLFunctions_4_4_Core_GlFramebufferParameteri5(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glFramebufferParameteri(target, pname, param);
}
void QOpenGLFunctions_4_4_Core_GlFramebufferRenderbuffer5(void* ptr, unsigned int target, unsigned int attachment, unsigned int renderbuffertarget, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
void QOpenGLFunctions_4_4_Core_GlFramebufferTexture5(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glFramebufferTexture(target, attachment, texture, level);
}
void QOpenGLFunctions_4_4_Core_GlFramebufferTexture1D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glFramebufferTexture1D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_4_4_Core_GlFramebufferTexture2D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_4_4_Core_GlFramebufferTexture3D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level, int zoffset)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}
void QOpenGLFunctions_4_4_Core_GlFramebufferTextureLayer5(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level, int layer)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glFramebufferTextureLayer(target, attachment, texture, level, layer);
}
void QOpenGLFunctions_4_4_Core_GlFrontFace5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_4_4_Core_GlGenBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGenBuffers(n, &buffers);
}
void QOpenGLFunctions_4_4_Core_GlGenFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGenFramebuffers(n, &framebuffers);
}
void QOpenGLFunctions_4_4_Core_GlGenProgramPipelines5(void* ptr, int n, unsigned int pipelines)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGenProgramPipelines(n, &pipelines);
}
void QOpenGLFunctions_4_4_Core_GlGenQueries5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGenQueries(n, &ids);
}
void QOpenGLFunctions_4_4_Core_GlGenRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGenRenderbuffers(n, &renderbuffers);
}
void QOpenGLFunctions_4_4_Core_GlGenSamplers5(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGenSamplers(count, &samplers);
}
void QOpenGLFunctions_4_4_Core_GlGenTextures5(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_4_4_Core_GlGenTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGenTransformFeedbacks(n, &ids);
}
void QOpenGLFunctions_4_4_Core_GlGenVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGenVertexArrays(n, &arrays);
}
void QOpenGLFunctions_4_4_Core_GlGenerateMipmap5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGenerateMipmap(target);
}
void QOpenGLFunctions_4_4_Core_GlGetActiveAtomicCounterBufferiv5(void* ptr, unsigned int program, unsigned int bufferIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetActiveAtomicCounterBufferiv(program, bufferIndex, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetActiveSubroutineUniformiv5(void* ptr, unsigned int program, unsigned int shadertype, unsigned int index, unsigned int pname, int values)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetActiveSubroutineUniformiv(program, shadertype, index, pname, &values);
}
void QOpenGLFunctions_4_4_Core_GlGetActiveUniformBlockiv5(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetActiveUniformsiv5(void* ptr, unsigned int program, int uniformCount, unsigned int uniformIndices, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetActiveUniformsiv(program, uniformCount, const_cast<const GLuint*>(&uniformIndices), pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetAttachedShaders5(void* ptr, unsigned int program, int maxCount, int count, unsigned int shaders)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetAttachedShaders(program, maxCount, &count, &shaders);
}
void QOpenGLFunctions_4_4_Core_GlGetBooleani_v5(void* ptr, unsigned int target, unsigned int index, char data)
{
Q_UNUSED(data);
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetBooleani_v(target, index, NULL);
}
void QOpenGLFunctions_4_4_Core_GlGetBooleanv5(void* ptr, unsigned int pname, char data)
{
Q_UNUSED(data);
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_4_4_Core_GlGetBufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetBufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetBufferPointerv5(void* ptr, unsigned int target, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetBufferPointerv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetCompressedTexImage5(void* ptr, unsigned int target, int level, void* img)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetCompressedTexImage(target, level, img);
}
void QOpenGLFunctions_4_4_Core_GlGetFloati_v5(void* ptr, unsigned int target, unsigned int index, float data)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetFloati_v(target, index, &data);
}
void QOpenGLFunctions_4_4_Core_GlGetFloatv5(void* ptr, unsigned int pname, float data)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetFloatv(pname, &data);
}
void QOpenGLFunctions_4_4_Core_GlGetFramebufferAttachmentParameteriv5(void* ptr, unsigned int target, unsigned int attachment, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetFramebufferAttachmentParameteriv(target, attachment, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetFramebufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetFramebufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetIntegeri_v5(void* ptr, unsigned int target, unsigned int index, int data)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetIntegeri_v(target, index, &data);
}
void QOpenGLFunctions_4_4_Core_GlGetIntegerv5(void* ptr, unsigned int pname, int data)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetIntegerv(pname, &data);
}
void QOpenGLFunctions_4_4_Core_GlGetInternalformativ5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int pname, int bufSize, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetInternalformativ(target, internalformat, pname, bufSize, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetMultisamplefv5(void* ptr, unsigned int pname, unsigned int index, float val)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetMultisamplefv(pname, index, &val);
}
void QOpenGLFunctions_4_4_Core_GlGetProgramBinary5(void* ptr, unsigned int program, int bufSize, int length, unsigned int binaryFormat, void* binary)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetProgramBinary(program, bufSize, &length, &binaryFormat, binary);
}
void QOpenGLFunctions_4_4_Core_GlGetProgramInterfaceiv5(void* ptr, unsigned int program, unsigned int programInterface, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetProgramInterfaceiv(program, programInterface, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetProgramPipelineiv5(void* ptr, unsigned int pipeline, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetProgramPipelineiv(pipeline, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetProgramResourceiv5(void* ptr, unsigned int program, unsigned int programInterface, unsigned int index, int propCount, unsigned int props, int bufSize, int length, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetProgramResourceiv(program, programInterface, index, propCount, const_cast<const GLenum*>(&props), bufSize, &length, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetProgramStageiv5(void* ptr, unsigned int program, unsigned int shadertype, unsigned int pname, int values)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetProgramStageiv(program, shadertype, pname, &values);
}
void QOpenGLFunctions_4_4_Core_GlGetProgramiv5(void* ptr, unsigned int program, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetProgramiv(program, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetQueryIndexediv5(void* ptr, unsigned int target, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetQueryIndexediv(target, index, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetQueryObjectiv5(void* ptr, unsigned int id, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetQueryObjectiv(id, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetQueryObjectuiv5(void* ptr, unsigned int id, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetQueryObjectuiv(id, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetQueryiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetQueryiv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetRenderbufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetRenderbufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetSamplerParameterIiv5(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetSamplerParameterIiv(sampler, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetSamplerParameterIuiv5(void* ptr, unsigned int sampler, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetSamplerParameterIuiv(sampler, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetSamplerParameterfv5(void* ptr, unsigned int sampler, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetSamplerParameterfv(sampler, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetSamplerParameteriv5(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetSamplerParameteriv(sampler, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetShaderPrecisionFormat5(void* ptr, unsigned int shadertype, unsigned int precisiontype, int ran, int precision)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetShaderPrecisionFormat(shadertype, precisiontype, &ran, &precision);
}
void QOpenGLFunctions_4_4_Core_GlGetShaderiv5(void* ptr, unsigned int shader, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetShaderiv(shader, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetTexImage5(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_4_4_Core_GlGetTexLevelParameterfv5(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetTexLevelParameteriv5(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetTexParameterIiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetTexParameterIiv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetTexParameterIuiv5(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetTexParameterIuiv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetTexParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetTexParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetUniformSubroutineuiv5(void* ptr, unsigned int shadertype, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetUniformSubroutineuiv(shadertype, location, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetUniformfv5(void* ptr, unsigned int program, int location, float params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetUniformfv(program, location, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetUniformiv5(void* ptr, unsigned int program, int location, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetUniformiv(program, location, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetUniformuiv5(void* ptr, unsigned int program, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetUniformuiv(program, location, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetVertexAttribIiv5(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetVertexAttribIiv(index, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetVertexAttribIuiv5(void* ptr, unsigned int index, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetVertexAttribIuiv(index, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetVertexAttribPointerv5(void* ptr, unsigned int index, unsigned int pname, void* pointer)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetVertexAttribPointerv(index, pname, &pointer);
}
void QOpenGLFunctions_4_4_Core_GlGetVertexAttribfv5(void* ptr, unsigned int index, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetVertexAttribfv(index, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlGetVertexAttribiv5(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glGetVertexAttribiv(index, pname, &params);
}
void QOpenGLFunctions_4_4_Core_GlHint5(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_4_4_Core_GlInvalidateBufferData5(void* ptr, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glInvalidateBufferData(buffer);
}
void QOpenGLFunctions_4_4_Core_GlInvalidateFramebuffer5(void* ptr, unsigned int target, int numAttachments, unsigned int attachments)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glInvalidateFramebuffer(target, numAttachments, const_cast<const GLenum*>(&attachments));
}
void QOpenGLFunctions_4_4_Core_GlInvalidateSubFramebuffer5(void* ptr, unsigned int target, int numAttachments, unsigned int attachments, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glInvalidateSubFramebuffer(target, numAttachments, const_cast<const GLenum*>(&attachments), x, y, width, height);
}
void QOpenGLFunctions_4_4_Core_GlInvalidateTexImage5(void* ptr, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glInvalidateTexImage(texture, level);
}
void QOpenGLFunctions_4_4_Core_GlInvalidateTexSubImage5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glInvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
}
void QOpenGLFunctions_4_4_Core_GlLineWidth5(void* ptr, float width)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_4_4_Core_GlLinkProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glLinkProgram(program);
}
void QOpenGLFunctions_4_4_Core_GlLogicOp5(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_4_4_Core_GlMemoryBarrier5(void* ptr, unsigned int barriers)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glMemoryBarrier(barriers);
}
void QOpenGLFunctions_4_4_Core_GlMinSampleShading5(void* ptr, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glMinSampleShading(value);
}
void QOpenGLFunctions_4_4_Core_GlMultiDrawArrays5(void* ptr, unsigned int mode, int first, int count, int drawcount)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glMultiDrawArrays(mode, const_cast<const GLint*>(&first), const_cast<const GLsizei*>(&count), drawcount);
}
void QOpenGLFunctions_4_4_Core_GlMultiDrawArraysIndirect5(void* ptr, unsigned int mode, void* indirect, int drawcount, int stride)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glMultiDrawArraysIndirect(mode, indirect, drawcount, stride);
}
void QOpenGLFunctions_4_4_Core_GlMultiDrawElementsIndirect5(void* ptr, unsigned int mode, unsigned int ty, void* indirect, int drawcount, int stride)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glMultiDrawElementsIndirect(mode, ty, indirect, drawcount, stride);
}
void QOpenGLFunctions_4_4_Core_GlPatchParameterfv5(void* ptr, unsigned int pname, float values)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glPatchParameterfv(pname, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_4_4_Core_GlPatchParameteri5(void* ptr, unsigned int pname, int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glPatchParameteri(pname, value);
}
void QOpenGLFunctions_4_4_Core_GlPauseTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glPauseTransformFeedback();
}
void QOpenGLFunctions_4_4_Core_GlPixelStoref5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_4_4_Core_GlPixelStorei5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_4_4_Core_GlPointParameterf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glPointParameterf(pname, param);
}
void QOpenGLFunctions_4_4_Core_GlPointParameterfv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glPointParameterfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_4_Core_GlPointParameteri5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glPointParameteri(pname, param);
}
void QOpenGLFunctions_4_4_Core_GlPointParameteriv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glPointParameteriv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_4_Core_GlPointSize5(void* ptr, float size)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_4_4_Core_GlPolygonMode5(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_4_4_Core_GlPolygonOffset5(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_4_4_Core_GlPopDebugGroup5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glPopDebugGroup();
}
void QOpenGLFunctions_4_4_Core_GlPrimitiveRestartIndex5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glPrimitiveRestartIndex(index);
}
void QOpenGLFunctions_4_4_Core_GlProgramBinary5(void* ptr, unsigned int program, unsigned int binaryFormat, void* binary, int length)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramBinary(program, binaryFormat, binary, length);
}
void QOpenGLFunctions_4_4_Core_GlProgramParameteri5(void* ptr, unsigned int program, unsigned int pname, int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramParameteri(program, pname, value);
}
void QOpenGLFunctions_4_4_Core_GlProgramUniform1f5(void* ptr, unsigned int program, int location, float v0)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniform1f(program, location, v0);
}
void QOpenGLFunctions_4_4_Core_GlProgramUniform1fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniform1fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlProgramUniform1i5(void* ptr, unsigned int program, int location, int v0)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniform1i(program, location, v0);
}
void QOpenGLFunctions_4_4_Core_GlProgramUniform1iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniform1iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlProgramUniform1ui5(void* ptr, unsigned int program, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniform1ui(program, location, v0);
}
void QOpenGLFunctions_4_4_Core_GlProgramUniform1uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniform1uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlProgramUniform2f5(void* ptr, unsigned int program, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniform2f(program, location, v0, v1);
}
void QOpenGLFunctions_4_4_Core_GlProgramUniform2fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniform2fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlProgramUniform2i5(void* ptr, unsigned int program, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniform2i(program, location, v0, v1);
}
void QOpenGLFunctions_4_4_Core_GlProgramUniform2iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniform2iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlProgramUniform2ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniform2ui(program, location, v0, v1);
}
void QOpenGLFunctions_4_4_Core_GlProgramUniform2uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniform2uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlProgramUniform3f5(void* ptr, unsigned int program, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniform3f(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_4_Core_GlProgramUniform3fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniform3fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlProgramUniform3i5(void* ptr, unsigned int program, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniform3i(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_4_Core_GlProgramUniform3iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniform3iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlProgramUniform3ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniform3ui(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_4_Core_GlProgramUniform3uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniform3uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlProgramUniform4f5(void* ptr, unsigned int program, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniform4f(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_4_Core_GlProgramUniform4fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniform4fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlProgramUniform4i5(void* ptr, unsigned int program, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniform4i(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_4_Core_GlProgramUniform4iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniform4iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlProgramUniform4ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniform4ui(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_4_Core_GlProgramUniform4uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniform4uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlProgramUniformMatrix2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniformMatrix2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlProgramUniformMatrix2x3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniformMatrix2x3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlProgramUniformMatrix2x4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniformMatrix2x4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlProgramUniformMatrix3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniformMatrix3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlProgramUniformMatrix3x2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniformMatrix3x2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlProgramUniformMatrix3x4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniformMatrix3x4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlProgramUniformMatrix4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniformMatrix4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlProgramUniformMatrix4x2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniformMatrix4x2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlProgramUniformMatrix4x3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProgramUniformMatrix4x3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlProvokingVertex5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glProvokingVertex(mode);
}
void QOpenGLFunctions_4_4_Core_GlQueryCounter5(void* ptr, unsigned int id, unsigned int target)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glQueryCounter(id, target);
}
void QOpenGLFunctions_4_4_Core_GlReadBuffer5(void* ptr, unsigned int src)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glReadBuffer(src);
}
void QOpenGLFunctions_4_4_Core_GlReadPixels5(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_4_Core_GlReleaseShaderCompiler5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glReleaseShaderCompiler();
}
void QOpenGLFunctions_4_4_Core_GlRenderbufferStorage5(void* ptr, unsigned int target, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glRenderbufferStorage(target, internalformat, width, height);
}
void QOpenGLFunctions_4_4_Core_GlRenderbufferStorageMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
}
void QOpenGLFunctions_4_4_Core_GlResumeTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glResumeTransformFeedback();
}
void QOpenGLFunctions_4_4_Core_GlSampleCoverage5(void* ptr, float value, char invert)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glSampleCoverage(value, invert != 0);
}
void QOpenGLFunctions_4_4_Core_GlSampleMaski5(void* ptr, unsigned int maskNumber, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glSampleMaski(maskNumber, mask);
}
void QOpenGLFunctions_4_4_Core_GlSamplerParameterIiv5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glSamplerParameterIiv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_4_Core_GlSamplerParameterIuiv5(void* ptr, unsigned int sampler, unsigned int pname, unsigned int param)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glSamplerParameterIuiv(sampler, pname, const_cast<const GLuint*>(&param));
}
void QOpenGLFunctions_4_4_Core_GlSamplerParameterf5(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glSamplerParameterf(sampler, pname, param);
}
void QOpenGLFunctions_4_4_Core_GlSamplerParameterfv5(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glSamplerParameterfv(sampler, pname, const_cast<const GLfloat*>(&param));
}
void QOpenGLFunctions_4_4_Core_GlSamplerParameteri5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glSamplerParameteri(sampler, pname, param);
}
void QOpenGLFunctions_4_4_Core_GlSamplerParameteriv5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glSamplerParameteriv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_4_Core_GlScissor5(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_4_4_Core_GlScissorArrayv5(void* ptr, unsigned int first, int count, int v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glScissorArrayv(first, count, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlScissorIndexed5(void* ptr, unsigned int index, int left, int bottom, int width, int height)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glScissorIndexed(index, left, bottom, width, height);
}
void QOpenGLFunctions_4_4_Core_GlScissorIndexedv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glScissorIndexedv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlShaderBinary5(void* ptr, int count, unsigned int shaders, unsigned int binaryformat, void* binary, int length)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glShaderBinary(count, const_cast<const GLuint*>(&shaders), binaryformat, binary, length);
}
void QOpenGLFunctions_4_4_Core_GlShaderStorageBlockBinding5(void* ptr, unsigned int program, unsigned int storageBlockIndex, unsigned int storageBlockBinding)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
}
void QOpenGLFunctions_4_4_Core_GlStencilFunc5(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_4_4_Core_GlStencilFuncSeparate5(void* ptr, unsigned int face, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glStencilFuncSeparate(face, fu, ref, mask);
}
void QOpenGLFunctions_4_4_Core_GlStencilMask5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_4_4_Core_GlStencilMaskSeparate5(void* ptr, unsigned int face, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glStencilMaskSeparate(face, mask);
}
void QOpenGLFunctions_4_4_Core_GlStencilOp5(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_4_4_Core_GlStencilOpSeparate5(void* ptr, unsigned int face, unsigned int sfail, unsigned int dpfail, unsigned int dppass)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glStencilOpSeparate(face, sfail, dpfail, dppass);
}
void QOpenGLFunctions_4_4_Core_GlTexBuffer5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glTexBuffer(target, internalformat, buffer);
}
void QOpenGLFunctions_4_4_Core_GlTexImage1D5(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_4_4_Core_GlTexImage2D5(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_4_4_Core_GlTexImage2DMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_4_Core_GlTexImage3D5(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLFunctions_4_4_Core_GlTexImage3DMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_4_Core_GlTexParameterIiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glTexParameterIiv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_4_Core_GlTexParameterIuiv5(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glTexParameterIuiv(target, pname, const_cast<const GLuint*>(&params));
}
void QOpenGLFunctions_4_4_Core_GlTexParameterf5(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_4_4_Core_GlTexParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_4_Core_GlTexParameteri5(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_4_4_Core_GlTexParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_4_Core_GlTexStorage1D5(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glTexStorage1D(target, levels, internalformat, width);
}
void QOpenGLFunctions_4_4_Core_GlTexStorage2D5(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glTexStorage2D(target, levels, internalformat, width, height);
}
void QOpenGLFunctions_4_4_Core_GlTexStorage2DMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glTexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_4_Core_GlTexStorage3D5(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width, int height, int depth)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glTexStorage3D(target, levels, internalformat, width, height, depth);
}
void QOpenGLFunctions_4_4_Core_GlTexStorage3DMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glTexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_4_Core_GlTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_4_4_Core_GlTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_4_Core_GlTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_4_4_Core_GlTextureView5(void* ptr, unsigned int texture, unsigned int target, unsigned int origtexture, unsigned int internalformat, unsigned int minlevel, unsigned int numlevels, unsigned int minlayer, unsigned int numlayers)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glTextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
}
void QOpenGLFunctions_4_4_Core_GlUniform1f5(void* ptr, int location, float v0)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniform1f(location, v0);
}
void QOpenGLFunctions_4_4_Core_GlUniform1fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniform1fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlUniform1i5(void* ptr, int location, int v0)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniform1i(location, v0);
}
void QOpenGLFunctions_4_4_Core_GlUniform1iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniform1iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlUniform1ui5(void* ptr, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniform1ui(location, v0);
}
void QOpenGLFunctions_4_4_Core_GlUniform1uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniform1uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlUniform2f5(void* ptr, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniform2f(location, v0, v1);
}
void QOpenGLFunctions_4_4_Core_GlUniform2fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniform2fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlUniform2i5(void* ptr, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniform2i(location, v0, v1);
}
void QOpenGLFunctions_4_4_Core_GlUniform2iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniform2iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlUniform2ui5(void* ptr, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniform2ui(location, v0, v1);
}
void QOpenGLFunctions_4_4_Core_GlUniform2uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniform2uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlUniform3f5(void* ptr, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniform3f(location, v0, v1, v2);
}
void QOpenGLFunctions_4_4_Core_GlUniform3fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniform3fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlUniform3i5(void* ptr, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniform3i(location, v0, v1, v2);
}
void QOpenGLFunctions_4_4_Core_GlUniform3iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniform3iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlUniform3ui5(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniform3ui(location, v0, v1, v2);
}
void QOpenGLFunctions_4_4_Core_GlUniform3uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniform3uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlUniform4f5(void* ptr, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniform4f(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_4_Core_GlUniform4fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniform4fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlUniform4i5(void* ptr, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniform4i(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_4_Core_GlUniform4iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniform4iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlUniform4ui5(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniform4ui(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_4_Core_GlUniform4uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniform4uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlUniformBlockBinding5(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int uniformBlockBinding)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}
void QOpenGLFunctions_4_4_Core_GlUniformMatrix2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniformMatrix2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlUniformMatrix2x3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniformMatrix2x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlUniformMatrix2x4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniformMatrix2x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlUniformMatrix3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniformMatrix3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlUniformMatrix3x2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniformMatrix3x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlUniformMatrix3x4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniformMatrix3x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlUniformMatrix4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniformMatrix4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlUniformMatrix4x2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniformMatrix4x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlUniformMatrix4x3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniformMatrix4x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlUniformSubroutinesuiv5(void* ptr, unsigned int shadertype, int count, unsigned int indices)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUniformSubroutinesuiv(shadertype, count, const_cast<const GLuint*>(&indices));
}
void QOpenGLFunctions_4_4_Core_GlUseProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUseProgram(program);
}
void QOpenGLFunctions_4_4_Core_GlUseProgramStages5(void* ptr, unsigned int pipeline, unsigned int stages, unsigned int program)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glUseProgramStages(pipeline, stages, program);
}
void QOpenGLFunctions_4_4_Core_GlValidateProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glValidateProgram(program);
}
void QOpenGLFunctions_4_4_Core_GlValidateProgramPipeline5(void* ptr, unsigned int pipeline)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glValidateProgramPipeline(pipeline);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib1f5(void* ptr, unsigned int index, float x)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib1f(index, x);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib1fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib1fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib1s5(void* ptr, unsigned int index, short x)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib1s(index, x);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib1sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib1sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib2f5(void* ptr, unsigned int index, float x, float y)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib2f(index, x, y);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib2fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib2fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib2s5(void* ptr, unsigned int index, short x, short y)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib2s(index, x, y);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib2sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib2sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib3f5(void* ptr, unsigned int index, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib3f(index, x, y, z);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib3fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib3fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib3s5(void* ptr, unsigned int index, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib3s(index, x, y, z);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib3sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib3sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib4Niv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib4Niv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib4Nsv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib4Nsv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib4Nub5(void* ptr, unsigned int index, char* x, char* y, char* z, char* w)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib4Nub(index, *static_cast<GLubyte*>(static_cast<void*>(x)), *static_cast<GLubyte*>(static_cast<void*>(y)), *static_cast<GLubyte*>(static_cast<void*>(z)), *static_cast<GLubyte*>(static_cast<void*>(w)));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib4Nubv5(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib4Nubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib4Nuiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib4Nuiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib4Nusv5(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib4Nusv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib4f5(void* ptr, unsigned int index, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib4f(index, x, y, z, w);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib4fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib4fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib4iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib4s5(void* ptr, unsigned int index, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib4s(index, x, y, z, w);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib4sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib4sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib4ubv5(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib4ubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib4uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttrib4usv5(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttrib4usv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribBinding5(void* ptr, unsigned int attribindex, unsigned int bindingindex)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribBinding(attribindex, bindingindex);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribDivisor5(void* ptr, unsigned int index, unsigned int divisor)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribDivisor(index, divisor);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribFormat5(void* ptr, unsigned int attribindex, int size, unsigned int ty, char normalized, unsigned int relativeoffset)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribFormat(attribindex, size, ty, normalized != 0, relativeoffset);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribI1i5(void* ptr, unsigned int index, int x)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribI1i(index, x);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribI1iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribI1iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribI1ui5(void* ptr, unsigned int index, unsigned int x)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribI1ui(index, x);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribI1uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribI1uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribI2i5(void* ptr, unsigned int index, int x, int y)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribI2i(index, x, y);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribI2iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribI2iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribI2ui5(void* ptr, unsigned int index, unsigned int x, unsigned int y)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribI2ui(index, x, y);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribI2uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribI2uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribI3i5(void* ptr, unsigned int index, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribI3i(index, x, y, z);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribI3iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribI3iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribI3ui5(void* ptr, unsigned int index, unsigned int x, unsigned int y, unsigned int z)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribI3ui(index, x, y, z);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribI3uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribI3uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribI4i5(void* ptr, unsigned int index, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribI4i(index, x, y, z, w);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribI4iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribI4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribI4sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribI4sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribI4ubv5(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribI4ubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribI4ui5(void* ptr, unsigned int index, unsigned int x, unsigned int y, unsigned int z, unsigned int w)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribI4ui(index, x, y, z, w);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribI4uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribI4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribI4usv5(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribI4usv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribIFormat5(void* ptr, unsigned int attribindex, int size, unsigned int ty, unsigned int relativeoffset)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribIFormat(attribindex, size, ty, relativeoffset);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribIPointer5(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribIPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribLFormat5(void* ptr, unsigned int attribindex, int size, unsigned int ty, unsigned int relativeoffset)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribLFormat(attribindex, size, ty, relativeoffset);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribLPointer5(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribLPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribP1ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribP1ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribP1uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribP1uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribP2ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribP2ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribP2uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribP2uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribP3ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribP3ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribP3uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribP3uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribP4ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribP4ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribP4uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribP4uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_4_Core_GlVertexAttribPointer5(void* ptr, unsigned int index, int size, unsigned int ty, char normalized, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexAttribPointer(index, size, ty, normalized != 0, stride, pointer);
}
void QOpenGLFunctions_4_4_Core_GlVertexBindingDivisor5(void* ptr, unsigned int bindingindex, unsigned int divisor)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glVertexBindingDivisor(bindingindex, divisor);
}
void QOpenGLFunctions_4_4_Core_GlViewport5(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_4_4_Core_GlViewportArrayv5(void* ptr, unsigned int first, int count, float v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glViewportArrayv(first, count, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Core_GlViewportIndexedf5(void* ptr, unsigned int index, float x, float y, float w, float h)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glViewportIndexedf(index, x, y, w, h);
}
void QOpenGLFunctions_4_4_Core_GlViewportIndexedfv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glViewportIndexedfv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_4_Core_DestroyQOpenGLFunctions_4_4_Core5(void* ptr)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->~QOpenGLFunctions_4_4_Core();
}
void QOpenGLFunctions_4_4_Core_DestroyQOpenGLFunctions_4_4_Core5Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_4_5_Compatibility: public QOpenGLFunctions_4_5_Compatibility
{
public:
MyQOpenGLFunctions_4_5_Compatibility() : QOpenGLFunctions_4_5_Compatibility() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_4_5_Compatibility_InitializeOpenGLFunctions5(this) != 0; };
~MyQOpenGLFunctions_4_5_Compatibility() { callbackQOpenGLFunctions_4_5_Compatibility_DestroyQOpenGLFunctions_4_5_Compatibility5(this); };
};
char QOpenGLFunctions_4_5_Compatibility_GlAreTexturesResident5(void* ptr, int n, unsigned int textures, char residences)
{
Q_UNUSED(residences);
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glAreTexturesResident(n, const_cast<const GLuint*>(&textures), NULL);
}
char QOpenGLFunctions_4_5_Compatibility_GlIsBuffer5(void* ptr, unsigned int buffer)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glIsBuffer(buffer);
}
char QOpenGLFunctions_4_5_Compatibility_GlIsEnabled5(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_4_5_Compatibility_GlIsEnabledi5(void* ptr, unsigned int target, unsigned int index)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glIsEnabledi(target, index);
}
char QOpenGLFunctions_4_5_Compatibility_GlIsFramebuffer5(void* ptr, unsigned int framebuffer)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glIsFramebuffer(framebuffer);
}
char QOpenGLFunctions_4_5_Compatibility_GlIsList5(void* ptr, unsigned int list)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glIsList(list);
}
char QOpenGLFunctions_4_5_Compatibility_GlIsProgram5(void* ptr, unsigned int program)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glIsProgram(program);
}
char QOpenGLFunctions_4_5_Compatibility_GlIsProgramPipeline5(void* ptr, unsigned int pipeline)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glIsProgramPipeline(pipeline);
}
char QOpenGLFunctions_4_5_Compatibility_GlIsQuery5(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glIsQuery(id);
}
char QOpenGLFunctions_4_5_Compatibility_GlIsRenderbuffer5(void* ptr, unsigned int renderbuffer)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glIsRenderbuffer(renderbuffer);
}
char QOpenGLFunctions_4_5_Compatibility_GlIsSampler5(void* ptr, unsigned int sampler)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glIsSampler(sampler);
}
char QOpenGLFunctions_4_5_Compatibility_GlIsShader5(void* ptr, unsigned int shader)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glIsShader(shader);
}
char QOpenGLFunctions_4_5_Compatibility_GlIsTexture5(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glIsTexture(texture);
}
char QOpenGLFunctions_4_5_Compatibility_GlIsTransformFeedback5(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glIsTransformFeedback(id);
}
char QOpenGLFunctions_4_5_Compatibility_GlIsVertexArray5(void* ptr, unsigned int array)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glIsVertexArray(array);
}
char QOpenGLFunctions_4_5_Compatibility_GlUnmapBuffer5(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUnmapBuffer(target);
}
char QOpenGLFunctions_4_5_Compatibility_GlUnmapNamedBuffer5(void* ptr, unsigned int buffer)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUnmapNamedBuffer(buffer);
}
unsigned int QOpenGLFunctions_4_5_Compatibility_GlCheckFramebufferStatus5(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCheckFramebufferStatus(target);
}
unsigned int QOpenGLFunctions_4_5_Compatibility_GlCheckNamedFramebufferStatus5(void* ptr, unsigned int framebuffer, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCheckNamedFramebufferStatus(framebuffer, target);
}
unsigned int QOpenGLFunctions_4_5_Compatibility_GlGetError5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetError();
}
unsigned int QOpenGLFunctions_4_5_Compatibility_GlGetGraphicsResetStatus5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetGraphicsResetStatus();
}
int QOpenGLFunctions_4_5_Compatibility_GlRenderMode5(void* ptr, unsigned int mode)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRenderMode(mode);
}
unsigned int QOpenGLFunctions_4_5_Compatibility_GlCreateProgram5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCreateProgram();
}
unsigned int QOpenGLFunctions_4_5_Compatibility_GlCreateShader5(void* ptr, unsigned int ty)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCreateShader(ty);
}
unsigned int QOpenGLFunctions_4_5_Compatibility_GlGenLists5(void* ptr, int ran)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGenLists(ran);
}
void* QOpenGLFunctions_4_5_Compatibility_NewQOpenGLFunctions_4_5_Compatibility5()
{
return new MyQOpenGLFunctions_4_5_Compatibility();
}
char QOpenGLFunctions_4_5_Compatibility_InitializeOpenGLFunctions5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_4_5_Compatibility_InitializeOpenGLFunctions5Default(void* ptr)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->QOpenGLFunctions_4_5_Compatibility::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_4_5_Compatibility_GlGetString5(void* ptr, unsigned int name)
{
return ({ char* teb9175 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetString(name)))); QtGui_PackedString { teb9175, -1 }; });
}
struct QtGui_PackedString QOpenGLFunctions_4_5_Compatibility_GlGetStringi5(void* ptr, unsigned int name, unsigned int index)
{
return ({ char* tec4d1f = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetStringi(name, index)))); QtGui_PackedString { tec4d1f, -1 }; });
}
void* QOpenGLFunctions_4_5_Compatibility_GlMapBuffer5(void* ptr, unsigned int target, unsigned int access)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMapBuffer(target, access);
}
void* QOpenGLFunctions_4_5_Compatibility_GlMapNamedBuffer5(void* ptr, unsigned int buffer, unsigned int access)
{
return static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMapNamedBuffer(buffer, access);
}
void QOpenGLFunctions_4_5_Compatibility_GlAccum5(void* ptr, unsigned int op, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glAccum(op, value);
}
void QOpenGLFunctions_4_5_Compatibility_GlActiveShaderProgram5(void* ptr, unsigned int pipeline, unsigned int program)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glActiveShaderProgram(pipeline, program);
}
void QOpenGLFunctions_4_5_Compatibility_GlActiveTexture5(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glActiveTexture(texture);
}
void QOpenGLFunctions_4_5_Compatibility_GlAlphaFunc5(void* ptr, unsigned int fu, float ref)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glAlphaFunc(fu, ref);
}
void QOpenGLFunctions_4_5_Compatibility_GlArrayElement5(void* ptr, int i)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glArrayElement(i);
}
void QOpenGLFunctions_4_5_Compatibility_GlAttachShader5(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glAttachShader(program, shader);
}
void QOpenGLFunctions_4_5_Compatibility_GlBegin5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBegin(mode);
}
void QOpenGLFunctions_4_5_Compatibility_GlBeginConditionalRender5(void* ptr, unsigned int id, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBeginConditionalRender(id, mode);
}
void QOpenGLFunctions_4_5_Compatibility_GlBeginQuery5(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBeginQuery(target, id);
}
void QOpenGLFunctions_4_5_Compatibility_GlBeginQueryIndexed5(void* ptr, unsigned int target, unsigned int index, unsigned int id)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBeginQueryIndexed(target, index, id);
}
void QOpenGLFunctions_4_5_Compatibility_GlBeginTransformFeedback5(void* ptr, unsigned int primitiveMode)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBeginTransformFeedback(primitiveMode);
}
void QOpenGLFunctions_4_5_Compatibility_GlBindBuffer5(void* ptr, unsigned int target, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBindBuffer(target, buffer);
}
void QOpenGLFunctions_4_5_Compatibility_GlBindBufferBase5(void* ptr, unsigned int target, unsigned int index, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBindBufferBase(target, index, buffer);
}
void QOpenGLFunctions_4_5_Compatibility_GlBindBuffersBase5(void* ptr, unsigned int target, unsigned int first, int count, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBindBuffersBase(target, first, count, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_4_5_Compatibility_GlBindFramebuffer5(void* ptr, unsigned int target, unsigned int framebuffer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBindFramebuffer(target, framebuffer);
}
void QOpenGLFunctions_4_5_Compatibility_GlBindImageTexture5(void* ptr, unsigned int unit, unsigned int texture, int level, char layered, int layer, unsigned int access, unsigned int format)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBindImageTexture(unit, texture, level, layered != 0, layer, access, format);
}
void QOpenGLFunctions_4_5_Compatibility_GlBindImageTextures5(void* ptr, unsigned int first, int count, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBindImageTextures(first, count, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_4_5_Compatibility_GlBindProgramPipeline5(void* ptr, unsigned int pipeline)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBindProgramPipeline(pipeline);
}
void QOpenGLFunctions_4_5_Compatibility_GlBindRenderbuffer5(void* ptr, unsigned int target, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBindRenderbuffer(target, renderbuffer);
}
void QOpenGLFunctions_4_5_Compatibility_GlBindSampler5(void* ptr, unsigned int unit, unsigned int sampler)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBindSampler(unit, sampler);
}
void QOpenGLFunctions_4_5_Compatibility_GlBindSamplers5(void* ptr, unsigned int first, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBindSamplers(first, count, const_cast<const GLuint*>(&samplers));
}
void QOpenGLFunctions_4_5_Compatibility_GlBindTexture5(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_4_5_Compatibility_GlBindTextureUnit5(void* ptr, unsigned int unit, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBindTextureUnit(unit, texture);
}
void QOpenGLFunctions_4_5_Compatibility_GlBindTextures5(void* ptr, unsigned int first, int count, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBindTextures(first, count, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_4_5_Compatibility_GlBindTransformFeedback5(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBindTransformFeedback(target, id);
}
void QOpenGLFunctions_4_5_Compatibility_GlBindVertexArray5(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBindVertexArray(array);
}
void QOpenGLFunctions_4_5_Compatibility_GlBitmap5(void* ptr, int width, int height, float xorig, float yorig, float xmove, float ymove, char* bitmap)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBitmap(width, height, xorig, yorig, xmove, ymove, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(bitmap))));
}
void QOpenGLFunctions_4_5_Compatibility_GlBlendColor5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_4_5_Compatibility_GlBlendEquation5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_4_5_Compatibility_GlBlendEquationSeparate5(void* ptr, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBlendEquationSeparate(modeRGB, modeAlpha);
}
void QOpenGLFunctions_4_5_Compatibility_GlBlendEquationSeparatei5(void* ptr, unsigned int buf, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBlendEquationSeparatei(buf, modeRGB, modeAlpha);
}
void QOpenGLFunctions_4_5_Compatibility_GlBlendEquationi5(void* ptr, unsigned int buf, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBlendEquationi(buf, mode);
}
void QOpenGLFunctions_4_5_Compatibility_GlBlendFunc5(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_4_5_Compatibility_GlBlendFuncSeparate5(void* ptr, unsigned int sfactorRGB, unsigned int dfactorRGB, unsigned int sfactorAlpha, unsigned int dfactorAlpha)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void QOpenGLFunctions_4_5_Compatibility_GlBlendFuncSeparatei5(void* ptr, unsigned int buf, unsigned int srcRGB, unsigned int dstRGB, unsigned int srcAlpha, unsigned int dstAlpha)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
void QOpenGLFunctions_4_5_Compatibility_GlBlendFunci5(void* ptr, unsigned int buf, unsigned int src, unsigned int dst)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBlendFunci(buf, src, dst);
}
void QOpenGLFunctions_4_5_Compatibility_GlBlitFramebuffer5(void* ptr, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, unsigned int mask, unsigned int filter)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
void QOpenGLFunctions_4_5_Compatibility_GlBlitNamedFramebuffer5(void* ptr, unsigned int readFramebuffer, unsigned int drawFramebuffer, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, unsigned int mask, unsigned int filter)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glBlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
void QOpenGLFunctions_4_5_Compatibility_GlCallList5(void* ptr, unsigned int list)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCallList(list);
}
void QOpenGLFunctions_4_5_Compatibility_GlCallLists5(void* ptr, int n, unsigned int ty, void* lists)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCallLists(n, ty, lists);
}
void QOpenGLFunctions_4_5_Compatibility_GlClampColor5(void* ptr, unsigned int target, unsigned int clamp)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glClampColor(target, clamp);
}
void QOpenGLFunctions_4_5_Compatibility_GlClear5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_4_5_Compatibility_GlClearAccum5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glClearAccum(red, green, blue, alpha);
}
void QOpenGLFunctions_4_5_Compatibility_GlClearBufferData5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glClearBufferData(target, internalformat, format, ty, data);
}
void QOpenGLFunctions_4_5_Compatibility_GlClearBufferfi5(void* ptr, unsigned int buffer, int drawbuffer, float depth, int stencil)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glClearBufferfi(buffer, drawbuffer, depth, stencil);
}
void QOpenGLFunctions_4_5_Compatibility_GlClearBufferfv5(void* ptr, unsigned int buffer, int drawbuffer, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glClearBufferfv(buffer, drawbuffer, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlClearBufferiv5(void* ptr, unsigned int buffer, int drawbuffer, int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glClearBufferiv(buffer, drawbuffer, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlClearBufferuiv5(void* ptr, unsigned int buffer, int drawbuffer, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glClearBufferuiv(buffer, drawbuffer, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlClearColor5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_4_5_Compatibility_GlClearDepthf5(void* ptr, float dd)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glClearDepthf(dd);
}
void QOpenGLFunctions_4_5_Compatibility_GlClearIndex5(void* ptr, float c)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glClearIndex(c);
}
void QOpenGLFunctions_4_5_Compatibility_GlClearNamedBufferData5(void* ptr, unsigned int buffer, unsigned int internalformat, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glClearNamedBufferData(buffer, internalformat, format, ty, data);
}
void QOpenGLFunctions_4_5_Compatibility_GlClearNamedFramebufferfi5(void* ptr, unsigned int framebuffer, unsigned int buffer, float depth, int stencil)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glClearNamedFramebufferfi(framebuffer, buffer, depth, stencil);
}
void QOpenGLFunctions_4_5_Compatibility_GlClearNamedFramebufferfv5(void* ptr, unsigned int framebuffer, unsigned int buffer, int drawbuffer, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glClearNamedFramebufferfv(framebuffer, buffer, drawbuffer, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlClearNamedFramebufferiv5(void* ptr, unsigned int framebuffer, unsigned int buffer, int drawbuffer, int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glClearNamedFramebufferiv(framebuffer, buffer, drawbuffer, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlClearNamedFramebufferuiv5(void* ptr, unsigned int framebuffer, unsigned int buffer, int drawbuffer, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glClearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlClearStencil5(void* ptr, int s)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_4_5_Compatibility_GlClearTexImage5(void* ptr, unsigned int texture, int level, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glClearTexImage(texture, level, format, ty, data);
}
void QOpenGLFunctions_4_5_Compatibility_GlClearTexSubImage5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, data);
}
void QOpenGLFunctions_4_5_Compatibility_GlClientActiveTexture5(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glClientActiveTexture(texture);
}
void QOpenGLFunctions_4_5_Compatibility_GlClipControl5(void* ptr, unsigned int origin, unsigned int depth)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glClipControl(origin, depth);
}
void QOpenGLFunctions_4_5_Compatibility_GlColor3f5(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColor3f(red, green, blue);
}
void QOpenGLFunctions_4_5_Compatibility_GlColor3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlColor3i5(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColor3i(red, green, blue);
}
void QOpenGLFunctions_4_5_Compatibility_GlColor3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlColor3s5(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColor3s(red, green, blue);
}
void QOpenGLFunctions_4_5_Compatibility_GlColor3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlColor3ub5(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_4_5_Compatibility_GlColor3ubv5(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_5_Compatibility_GlColor3ui5(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColor3ui(red, green, blue);
}
void QOpenGLFunctions_4_5_Compatibility_GlColor3uiv5(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlColor3us5(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColor3us(red, green, blue);
}
void QOpenGLFunctions_4_5_Compatibility_GlColor3usv5(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlColor4f5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColor4f(red, green, blue, alpha);
}
void QOpenGLFunctions_4_5_Compatibility_GlColor4fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColor4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlColor4i5(void* ptr, int red, int green, int blue, int alpha)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColor4i(red, green, blue, alpha);
}
void QOpenGLFunctions_4_5_Compatibility_GlColor4iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColor4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlColor4s5(void* ptr, short red, short green, short blue, short alpha)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColor4s(red, green, blue, alpha);
}
void QOpenGLFunctions_4_5_Compatibility_GlColor4sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColor4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlColor4ub5(void* ptr, char* red, char* green, char* blue, char* alpha)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColor4ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)), *static_cast<GLubyte*>(static_cast<void*>(alpha)));
}
void QOpenGLFunctions_4_5_Compatibility_GlColor4ubv5(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColor4ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_5_Compatibility_GlColor4ui5(void* ptr, unsigned int red, unsigned int green, unsigned int blue, unsigned int alpha)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColor4ui(red, green, blue, alpha);
}
void QOpenGLFunctions_4_5_Compatibility_GlColor4uiv5(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColor4uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlColor4us5(void* ptr, unsigned short red, unsigned short green, unsigned short blue, unsigned short alpha)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColor4us(red, green, blue, alpha);
}
void QOpenGLFunctions_4_5_Compatibility_GlColor4usv5(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColor4usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlColorMask5(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_4_5_Compatibility_GlColorMaski5(void* ptr, unsigned int index, char r, char g, char b, char a)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColorMaski(index, r != 0, g != 0, b != 0, a != 0);
}
void QOpenGLFunctions_4_5_Compatibility_GlColorMaterial5(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColorMaterial(face, mode);
}
void QOpenGLFunctions_4_5_Compatibility_GlColorP3ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColorP3ui(ty, color);
}
void QOpenGLFunctions_4_5_Compatibility_GlColorP3uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColorP3uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_5_Compatibility_GlColorP4ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColorP4ui(ty, color);
}
void QOpenGLFunctions_4_5_Compatibility_GlColorP4uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColorP4uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_5_Compatibility_GlColorPointer5(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_4_5_Compatibility_GlColorSubTable5(void* ptr, unsigned int target, int start, int count, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColorSubTable(target, start, count, format, ty, data);
}
void QOpenGLFunctions_4_5_Compatibility_GlColorTable5(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColorTable(target, internalformat, width, format, ty, table);
}
void QOpenGLFunctions_4_5_Compatibility_GlColorTableParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColorTableParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_5_Compatibility_GlColorTableParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glColorTableParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_5_Compatibility_GlCompileShader5(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCompileShader(shader);
}
void QOpenGLFunctions_4_5_Compatibility_GlCompressedTexImage1D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
void QOpenGLFunctions_4_5_Compatibility_GlCompressedTexImage2D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void QOpenGLFunctions_4_5_Compatibility_GlCompressedTexImage3D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int depth, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void QOpenGLFunctions_4_5_Compatibility_GlCompressedTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_4_5_Compatibility_GlCompressedTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_4_5_Compatibility_GlCompressedTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_4_5_Compatibility_GlCompressedTextureSubImage1D5(void* ptr, unsigned int texture, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_4_5_Compatibility_GlCompressedTextureSubImage2D5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_4_5_Compatibility_GlCompressedTextureSubImage3D5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_4_5_Compatibility_GlConvolutionFilter1D5(void* ptr, unsigned int target, unsigned int internalformat, int width, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glConvolutionFilter1D(target, internalformat, width, format, ty, image);
}
void QOpenGLFunctions_4_5_Compatibility_GlConvolutionFilter2D5(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glConvolutionFilter2D(target, internalformat, width, height, format, ty, image);
}
void QOpenGLFunctions_4_5_Compatibility_GlConvolutionParameterf5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glConvolutionParameterf(target, pname, params);
}
void QOpenGLFunctions_4_5_Compatibility_GlConvolutionParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glConvolutionParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_5_Compatibility_GlConvolutionParameteri5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glConvolutionParameteri(target, pname, params);
}
void QOpenGLFunctions_4_5_Compatibility_GlConvolutionParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glConvolutionParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_5_Compatibility_GlCopyColorSubTable5(void* ptr, unsigned int target, int start, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCopyColorSubTable(target, start, x, y, width);
}
void QOpenGLFunctions_4_5_Compatibility_GlCopyColorTable5(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCopyColorTable(target, internalformat, x, y, width);
}
void QOpenGLFunctions_4_5_Compatibility_GlCopyConvolutionFilter1D5(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCopyConvolutionFilter1D(target, internalformat, x, y, width);
}
void QOpenGLFunctions_4_5_Compatibility_GlCopyConvolutionFilter2D5(void* ptr, unsigned int target, unsigned int internalformat, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);
}
void QOpenGLFunctions_4_5_Compatibility_GlCopyImageSubData5(void* ptr, unsigned int srcName, unsigned int srcTarget, int srcLevel, int srcX, int srcY, int srcZ, unsigned int dstName, unsigned int dstTarget, int dstLevel, int dstX, int dstY, int dstZ, int srcWidth, int srcHeight, int srcDepth)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
}
void QOpenGLFunctions_4_5_Compatibility_GlCopyPixels5(void* ptr, int x, int y, int width, int height, unsigned int ty)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCopyPixels(x, y, width, height, ty);
}
void QOpenGLFunctions_4_5_Compatibility_GlCopyTexImage1D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_4_5_Compatibility_GlCopyTexImage2D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_4_5_Compatibility_GlCopyTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_4_5_Compatibility_GlCopyTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_4_5_Compatibility_GlCopyTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_4_5_Compatibility_GlCopyTextureSubImage1D5(void* ptr, unsigned int texture, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCopyTextureSubImage1D(texture, level, xoffset, x, y, width);
}
void QOpenGLFunctions_4_5_Compatibility_GlCopyTextureSubImage2D5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_4_5_Compatibility_GlCopyTextureSubImage3D5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_4_5_Compatibility_GlCreateBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCreateBuffers(n, &buffers);
}
void QOpenGLFunctions_4_5_Compatibility_GlCreateFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCreateFramebuffers(n, &framebuffers);
}
void QOpenGLFunctions_4_5_Compatibility_GlCreateProgramPipelines5(void* ptr, int n, unsigned int pipelines)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCreateProgramPipelines(n, &pipelines);
}
void QOpenGLFunctions_4_5_Compatibility_GlCreateQueries5(void* ptr, unsigned int target, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCreateQueries(target, n, &ids);
}
void QOpenGLFunctions_4_5_Compatibility_GlCreateRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCreateRenderbuffers(n, &renderbuffers);
}
void QOpenGLFunctions_4_5_Compatibility_GlCreateSamplers5(void* ptr, int n, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCreateSamplers(n, &samplers);
}
void QOpenGLFunctions_4_5_Compatibility_GlCreateTextures5(void* ptr, unsigned int target, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCreateTextures(target, n, &textures);
}
void QOpenGLFunctions_4_5_Compatibility_GlCreateTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCreateTransformFeedbacks(n, &ids);
}
void QOpenGLFunctions_4_5_Compatibility_GlCreateVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCreateVertexArrays(n, &arrays);
}
void QOpenGLFunctions_4_5_Compatibility_GlCullFace5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_4_5_Compatibility_GlDebugMessageControl5(void* ptr, unsigned int source, unsigned int ty, unsigned int severity, int count, unsigned int ids, char enabled)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDebugMessageControl(source, ty, severity, count, const_cast<const GLuint*>(&ids), enabled != 0);
}
void QOpenGLFunctions_4_5_Compatibility_GlDeleteBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDeleteBuffers(n, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_4_5_Compatibility_GlDeleteFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDeleteFramebuffers(n, const_cast<const GLuint*>(&framebuffers));
}
void QOpenGLFunctions_4_5_Compatibility_GlDeleteLists5(void* ptr, unsigned int list, int ran)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDeleteLists(list, ran);
}
void QOpenGLFunctions_4_5_Compatibility_GlDeleteProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDeleteProgram(program);
}
void QOpenGLFunctions_4_5_Compatibility_GlDeleteProgramPipelines5(void* ptr, int n, unsigned int pipelines)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDeleteProgramPipelines(n, const_cast<const GLuint*>(&pipelines));
}
void QOpenGLFunctions_4_5_Compatibility_GlDeleteQueries5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDeleteQueries(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_4_5_Compatibility_GlDeleteRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDeleteRenderbuffers(n, const_cast<const GLuint*>(&renderbuffers));
}
void QOpenGLFunctions_4_5_Compatibility_GlDeleteSamplers5(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDeleteSamplers(count, const_cast<const GLuint*>(&samplers));
}
void QOpenGLFunctions_4_5_Compatibility_GlDeleteShader5(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDeleteShader(shader);
}
void QOpenGLFunctions_4_5_Compatibility_GlDeleteTextures5(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_4_5_Compatibility_GlDeleteTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDeleteTransformFeedbacks(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_4_5_Compatibility_GlDeleteVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDeleteVertexArrays(n, const_cast<const GLuint*>(&arrays));
}
void QOpenGLFunctions_4_5_Compatibility_GlDepthFunc5(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_4_5_Compatibility_GlDepthMask5(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_4_5_Compatibility_GlDepthRangef5(void* ptr, float n, float fo)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDepthRangef(n, fo);
}
void QOpenGLFunctions_4_5_Compatibility_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDetachShader(program, shader);
}
void QOpenGLFunctions_4_5_Compatibility_GlDisable5(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_4_5_Compatibility_GlDisableClientState5(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDisableClientState(array);
}
void QOpenGLFunctions_4_5_Compatibility_GlDisableVertexArrayAttrib5(void* ptr, unsigned int vaobj, unsigned int index)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDisableVertexArrayAttrib(vaobj, index);
}
void QOpenGLFunctions_4_5_Compatibility_GlDisableVertexAttribArray5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDisableVertexAttribArray(index);
}
void QOpenGLFunctions_4_5_Compatibility_GlDisablei5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDisablei(target, index);
}
void QOpenGLFunctions_4_5_Compatibility_GlDispatchCompute5(void* ptr, unsigned int num_groups_x, unsigned int num_groups_y, unsigned int num_groups_z)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
}
void QOpenGLFunctions_4_5_Compatibility_GlDrawArrays5(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_4_5_Compatibility_GlDrawArraysIndirect5(void* ptr, unsigned int mode, void* indirect)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDrawArraysIndirect(mode, indirect);
}
void QOpenGLFunctions_4_5_Compatibility_GlDrawArraysInstanced5(void* ptr, unsigned int mode, int first, int count, int instancecount)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDrawArraysInstanced(mode, first, count, instancecount);
}
void QOpenGLFunctions_4_5_Compatibility_GlDrawArraysInstancedBaseInstance5(void* ptr, unsigned int mode, int first, int count, int instancecount, unsigned int baseinstance)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
}
void QOpenGLFunctions_4_5_Compatibility_GlDrawBuffer5(void* ptr, unsigned int buf)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDrawBuffer(buf);
}
void QOpenGLFunctions_4_5_Compatibility_GlDrawBuffers5(void* ptr, int n, unsigned int bufs)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDrawBuffers(n, const_cast<const GLenum*>(&bufs));
}
void QOpenGLFunctions_4_5_Compatibility_GlDrawElements5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_4_5_Compatibility_GlDrawElementsBaseVertex5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDrawElementsBaseVertex(mode, count, ty, indices, basevertex);
}
void QOpenGLFunctions_4_5_Compatibility_GlDrawElementsIndirect5(void* ptr, unsigned int mode, unsigned int ty, void* indirect)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDrawElementsIndirect(mode, ty, indirect);
}
void QOpenGLFunctions_4_5_Compatibility_GlDrawElementsInstanced5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDrawElementsInstanced(mode, count, ty, indices, instancecount);
}
void QOpenGLFunctions_4_5_Compatibility_GlDrawElementsInstancedBaseInstance5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, unsigned int baseinstance)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDrawElementsInstancedBaseInstance(mode, count, ty, indices, instancecount, baseinstance);
}
void QOpenGLFunctions_4_5_Compatibility_GlDrawElementsInstancedBaseVertex5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDrawElementsInstancedBaseVertex(mode, count, ty, indices, instancecount, basevertex);
}
void QOpenGLFunctions_4_5_Compatibility_GlDrawElementsInstancedBaseVertexBaseInstance5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex, unsigned int baseinstance)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDrawElementsInstancedBaseVertexBaseInstance(mode, count, ty, indices, instancecount, basevertex, baseinstance);
}
void QOpenGLFunctions_4_5_Compatibility_GlDrawPixels5(void* ptr, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDrawPixels(width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_5_Compatibility_GlDrawRangeElements5(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLFunctions_4_5_Compatibility_GlDrawRangeElementsBaseVertex5(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDrawRangeElementsBaseVertex(mode, start, end, count, ty, indices, basevertex);
}
void QOpenGLFunctions_4_5_Compatibility_GlDrawTransformFeedback5(void* ptr, unsigned int mode, unsigned int id)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDrawTransformFeedback(mode, id);
}
void QOpenGLFunctions_4_5_Compatibility_GlDrawTransformFeedbackInstanced5(void* ptr, unsigned int mode, unsigned int id, int instancecount)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDrawTransformFeedbackInstanced(mode, id, instancecount);
}
void QOpenGLFunctions_4_5_Compatibility_GlDrawTransformFeedbackStream5(void* ptr, unsigned int mode, unsigned int id, unsigned int stream)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDrawTransformFeedbackStream(mode, id, stream);
}
void QOpenGLFunctions_4_5_Compatibility_GlDrawTransformFeedbackStreamInstanced5(void* ptr, unsigned int mode, unsigned int id, unsigned int stream, int instancecount)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
}
void QOpenGLFunctions_4_5_Compatibility_GlEdgeFlag5(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glEdgeFlag(flag != 0);
}
void QOpenGLFunctions_4_5_Compatibility_GlEdgeFlagPointer5(void* ptr, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glEdgeFlagPointer(stride, pointer);
}
void QOpenGLFunctions_4_5_Compatibility_GlEdgeFlagv5(void* ptr, char flag)
{
Q_UNUSED(flag);
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glEdgeFlagv(NULL);
}
void QOpenGLFunctions_4_5_Compatibility_GlEnable5(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_4_5_Compatibility_GlEnableClientState5(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glEnableClientState(array);
}
void QOpenGLFunctions_4_5_Compatibility_GlEnableVertexArrayAttrib5(void* ptr, unsigned int vaobj, unsigned int index)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glEnableVertexArrayAttrib(vaobj, index);
}
void QOpenGLFunctions_4_5_Compatibility_GlEnableVertexAttribArray5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glEnableVertexAttribArray(index);
}
void QOpenGLFunctions_4_5_Compatibility_GlEnablei5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glEnablei(target, index);
}
void QOpenGLFunctions_4_5_Compatibility_GlEnd5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glEnd();
}
void QOpenGLFunctions_4_5_Compatibility_GlEndConditionalRender5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glEndConditionalRender();
}
void QOpenGLFunctions_4_5_Compatibility_GlEndList5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glEndList();
}
void QOpenGLFunctions_4_5_Compatibility_GlEndQuery5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glEndQuery(target);
}
void QOpenGLFunctions_4_5_Compatibility_GlEndQueryIndexed5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glEndQueryIndexed(target, index);
}
void QOpenGLFunctions_4_5_Compatibility_GlEndTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glEndTransformFeedback();
}
void QOpenGLFunctions_4_5_Compatibility_GlEvalCoord1f5(void* ptr, float u)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glEvalCoord1f(u);
}
void QOpenGLFunctions_4_5_Compatibility_GlEvalCoord1fv5(void* ptr, float u)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glEvalCoord1fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_4_5_Compatibility_GlEvalCoord2f5(void* ptr, float u, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glEvalCoord2f(u, v);
}
void QOpenGLFunctions_4_5_Compatibility_GlEvalCoord2fv5(void* ptr, float u)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glEvalCoord2fv(const_cast<const GLfloat*>(&u));
}
void QOpenGLFunctions_4_5_Compatibility_GlEvalMesh15(void* ptr, unsigned int mode, int i1, int i2)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glEvalMesh1(mode, i1, i2);
}
void QOpenGLFunctions_4_5_Compatibility_GlEvalMesh25(void* ptr, unsigned int mode, int i1, int i2, int j1, int j2)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glEvalMesh2(mode, i1, i2, j1, j2);
}
void QOpenGLFunctions_4_5_Compatibility_GlEvalPoint15(void* ptr, int i)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glEvalPoint1(i);
}
void QOpenGLFunctions_4_5_Compatibility_GlEvalPoint25(void* ptr, int i, int j)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glEvalPoint2(i, j);
}
void QOpenGLFunctions_4_5_Compatibility_GlFeedbackBuffer5(void* ptr, int size, unsigned int ty, float buffer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glFeedbackBuffer(size, ty, &buffer);
}
void QOpenGLFunctions_4_5_Compatibility_GlFinish5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glFinish();
}
void QOpenGLFunctions_4_5_Compatibility_GlFlush5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glFlush();
}
void QOpenGLFunctions_4_5_Compatibility_GlFogCoordPointer5(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glFogCoordPointer(ty, stride, pointer);
}
void QOpenGLFunctions_4_5_Compatibility_GlFogCoordf5(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glFogCoordf(coord);
}
void QOpenGLFunctions_4_5_Compatibility_GlFogCoordfv5(void* ptr, float coord)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glFogCoordfv(const_cast<const GLfloat*>(&coord));
}
void QOpenGLFunctions_4_5_Compatibility_GlFogf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glFogf(pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlFogfv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glFogfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_5_Compatibility_GlFogi5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glFogi(pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlFogiv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glFogiv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_5_Compatibility_GlFramebufferParameteri5(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glFramebufferParameteri(target, pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlFramebufferRenderbuffer5(void* ptr, unsigned int target, unsigned int attachment, unsigned int renderbuffertarget, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
void QOpenGLFunctions_4_5_Compatibility_GlFramebufferTexture5(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glFramebufferTexture(target, attachment, texture, level);
}
void QOpenGLFunctions_4_5_Compatibility_GlFramebufferTexture1D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glFramebufferTexture1D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_4_5_Compatibility_GlFramebufferTexture2D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_4_5_Compatibility_GlFramebufferTexture3D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level, int zoffset)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}
void QOpenGLFunctions_4_5_Compatibility_GlFramebufferTextureLayer5(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level, int layer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glFramebufferTextureLayer(target, attachment, texture, level, layer);
}
void QOpenGLFunctions_4_5_Compatibility_GlFrontFace5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_4_5_Compatibility_GlGenBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGenBuffers(n, &buffers);
}
void QOpenGLFunctions_4_5_Compatibility_GlGenFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGenFramebuffers(n, &framebuffers);
}
void QOpenGLFunctions_4_5_Compatibility_GlGenProgramPipelines5(void* ptr, int n, unsigned int pipelines)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGenProgramPipelines(n, &pipelines);
}
void QOpenGLFunctions_4_5_Compatibility_GlGenQueries5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGenQueries(n, &ids);
}
void QOpenGLFunctions_4_5_Compatibility_GlGenRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGenRenderbuffers(n, &renderbuffers);
}
void QOpenGLFunctions_4_5_Compatibility_GlGenSamplers5(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGenSamplers(count, &samplers);
}
void QOpenGLFunctions_4_5_Compatibility_GlGenTextures5(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_4_5_Compatibility_GlGenTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGenTransformFeedbacks(n, &ids);
}
void QOpenGLFunctions_4_5_Compatibility_GlGenVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGenVertexArrays(n, &arrays);
}
void QOpenGLFunctions_4_5_Compatibility_GlGenerateMipmap5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGenerateMipmap(target);
}
void QOpenGLFunctions_4_5_Compatibility_GlGenerateTextureMipmap5(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGenerateTextureMipmap(texture);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetActiveAtomicCounterBufferiv5(void* ptr, unsigned int program, unsigned int bufferIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetActiveAtomicCounterBufferiv(program, bufferIndex, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetActiveSubroutineUniformiv5(void* ptr, unsigned int program, unsigned int shadertype, unsigned int index, unsigned int pname, int values)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetActiveSubroutineUniformiv(program, shadertype, index, pname, &values);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetActiveUniformBlockiv5(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetActiveUniformsiv5(void* ptr, unsigned int program, int uniformCount, unsigned int uniformIndices, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetActiveUniformsiv(program, uniformCount, const_cast<const GLuint*>(&uniformIndices), pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetAttachedShaders5(void* ptr, unsigned int program, int maxCount, int count, unsigned int shaders)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetAttachedShaders(program, maxCount, &count, &shaders);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetBooleani_v5(void* ptr, unsigned int target, unsigned int index, char data)
{
Q_UNUSED(data);
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetBooleani_v(target, index, NULL);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetBooleanv5(void* ptr, unsigned int pname, char data)
{
Q_UNUSED(data);
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetBufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetBufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetBufferPointerv5(void* ptr, unsigned int target, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetBufferPointerv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetColorTable5(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* table)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetColorTable(target, format, ty, table);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetColorTableParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetColorTableParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetColorTableParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetColorTableParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetCompressedTexImage5(void* ptr, unsigned int target, int level, void* img)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetCompressedTexImage(target, level, img);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetCompressedTextureImage5(void* ptr, unsigned int texture, int level, int bufSize, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetCompressedTextureImage(texture, level, bufSize, pixels);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetCompressedTextureSubImage5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, int bufSize, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetConvolutionFilter5(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* image)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetConvolutionFilter(target, format, ty, image);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetConvolutionParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetConvolutionParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetConvolutionParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetConvolutionParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetFloati_v5(void* ptr, unsigned int target, unsigned int index, float data)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetFloati_v(target, index, &data);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetFloatv5(void* ptr, unsigned int pname, float data)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetFloatv(pname, &data);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetFramebufferAttachmentParameteriv5(void* ptr, unsigned int target, unsigned int attachment, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetFramebufferAttachmentParameteriv(target, attachment, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetFramebufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetFramebufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetHistogram5(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetHistogram(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetHistogramParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetHistogramParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetHistogramParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetHistogramParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetIntegeri_v5(void* ptr, unsigned int target, unsigned int index, int data)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetIntegeri_v(target, index, &data);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetIntegerv5(void* ptr, unsigned int pname, int data)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetIntegerv(pname, &data);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetInternalformativ5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int pname, int bufSize, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetInternalformativ(target, internalformat, pname, bufSize, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetLightfv5(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetLightfv(light, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetLightiv5(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetLightiv(light, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetMapfv5(void* ptr, unsigned int target, unsigned int query, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetMapfv(target, query, &v);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetMapiv5(void* ptr, unsigned int target, unsigned int query, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetMapiv(target, query, &v);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetMaterialfv5(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetMaterialfv(face, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetMaterialiv5(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetMaterialiv(face, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetMinmax5(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, void* values)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetMinmax(target, reset != 0, format, ty, values);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetMinmaxParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetMinmaxParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetMinmaxParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetMinmaxParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetMultisamplefv5(void* ptr, unsigned int pname, unsigned int index, float val)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetMultisamplefv(pname, index, &val);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetNamedBufferParameteriv5(void* ptr, unsigned int buffer, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetNamedBufferParameteriv(buffer, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetNamedBufferPointerv5(void* ptr, unsigned int buffer, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetNamedBufferPointerv(buffer, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetNamedFramebufferAttachmentParameteriv5(void* ptr, unsigned int framebuffer, unsigned int attachment, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetNamedFramebufferParameteriv5(void* ptr, unsigned int framebuffer, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetNamedFramebufferParameteriv(framebuffer, pname, &param);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetNamedRenderbufferParameteriv5(void* ptr, unsigned int renderbuffer, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetNamedRenderbufferParameteriv(renderbuffer, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetPixelMapfv5(void* ptr, unsigned int m, float values)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetPixelMapfv(m, &values);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetPixelMapuiv5(void* ptr, unsigned int m, unsigned int values)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetPixelMapuiv(m, &values);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetPixelMapusv5(void* ptr, unsigned int m, unsigned short values)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetPixelMapusv(m, &values);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetPointerv5(void* ptr, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetPointerv(pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetPolygonStipple5(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetPolygonStipple(static_cast<GLubyte*>(static_cast<void*>(mask)));
}
void QOpenGLFunctions_4_5_Compatibility_GlGetProgramBinary5(void* ptr, unsigned int program, int bufSize, int length, unsigned int binaryFormat, void* binary)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetProgramBinary(program, bufSize, &length, &binaryFormat, binary);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetProgramInterfaceiv5(void* ptr, unsigned int program, unsigned int programInterface, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetProgramInterfaceiv(program, programInterface, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetProgramPipelineiv5(void* ptr, unsigned int pipeline, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetProgramPipelineiv(pipeline, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetProgramResourceiv5(void* ptr, unsigned int program, unsigned int programInterface, unsigned int index, int propCount, unsigned int props, int bufSize, int length, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetProgramResourceiv(program, programInterface, index, propCount, const_cast<const GLenum*>(&props), bufSize, &length, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetProgramStageiv5(void* ptr, unsigned int program, unsigned int shadertype, unsigned int pname, int values)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetProgramStageiv(program, shadertype, pname, &values);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetProgramiv5(void* ptr, unsigned int program, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetProgramiv(program, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetQueryIndexediv5(void* ptr, unsigned int target, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetQueryIndexediv(target, index, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetQueryObjectiv5(void* ptr, unsigned int id, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetQueryObjectiv(id, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetQueryObjectuiv5(void* ptr, unsigned int id, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetQueryObjectuiv(id, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetQueryiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetQueryiv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetRenderbufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetRenderbufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetSamplerParameterIiv5(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetSamplerParameterIiv(sampler, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetSamplerParameterIuiv5(void* ptr, unsigned int sampler, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetSamplerParameterIuiv(sampler, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetSamplerParameterfv5(void* ptr, unsigned int sampler, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetSamplerParameterfv(sampler, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetSamplerParameteriv5(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetSamplerParameteriv(sampler, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetSeparableFilter5(void* ptr, unsigned int target, unsigned int format, unsigned int ty, void* row, void* column, void* span)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetSeparableFilter(target, format, ty, row, column, span);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetShaderPrecisionFormat5(void* ptr, unsigned int shadertype, unsigned int precisiontype, int ran, int precision)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetShaderPrecisionFormat(shadertype, precisiontype, &ran, &precision);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetShaderiv5(void* ptr, unsigned int shader, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetShaderiv(shader, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetTexEnvfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetTexEnvfv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetTexEnviv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetTexEnviv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetTexGenfv5(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetTexGenfv(coord, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetTexGeniv5(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetTexGeniv(coord, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetTexImage5(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetTexLevelParameterfv5(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetTexLevelParameteriv5(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetTexParameterIiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetTexParameterIiv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetTexParameterIuiv5(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetTexParameterIuiv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetTexParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetTexParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetTextureImage5(void* ptr, unsigned int texture, int level, unsigned int format, unsigned int ty, int bufSize, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetTextureImage(texture, level, format, ty, bufSize, pixels);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetTextureLevelParameterfv5(void* ptr, unsigned int texture, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetTextureLevelParameterfv(texture, level, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetTextureLevelParameteriv5(void* ptr, unsigned int texture, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetTextureLevelParameteriv(texture, level, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetTextureParameterIiv5(void* ptr, unsigned int texture, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetTextureParameterIiv(texture, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetTextureParameterIuiv5(void* ptr, unsigned int texture, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetTextureParameterIuiv(texture, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetTextureParameterfv5(void* ptr, unsigned int texture, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetTextureParameterfv(texture, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetTextureParameteriv5(void* ptr, unsigned int texture, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetTextureParameteriv(texture, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetTextureSubImage5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, int bufSize, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, bufSize, pixels);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetTransformFeedbacki_v5(void* ptr, unsigned int xfb, unsigned int pname, unsigned int index, int param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetTransformFeedbacki_v(xfb, pname, index, &param);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetTransformFeedbackiv5(void* ptr, unsigned int xfb, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetTransformFeedbackiv(xfb, pname, &param);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetUniformSubroutineuiv5(void* ptr, unsigned int shadertype, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetUniformSubroutineuiv(shadertype, location, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetUniformfv5(void* ptr, unsigned int program, int location, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetUniformfv(program, location, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetUniformiv5(void* ptr, unsigned int program, int location, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetUniformiv(program, location, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetUniformuiv5(void* ptr, unsigned int program, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetUniformuiv(program, location, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetVertexArrayIndexediv5(void* ptr, unsigned int vaobj, unsigned int index, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetVertexArrayIndexediv(vaobj, index, pname, &param);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetVertexArrayiv5(void* ptr, unsigned int vaobj, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetVertexArrayiv(vaobj, pname, &param);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetVertexAttribIiv5(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetVertexAttribIiv(index, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetVertexAttribIuiv5(void* ptr, unsigned int index, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetVertexAttribIuiv(index, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetVertexAttribPointerv5(void* ptr, unsigned int index, unsigned int pname, void* pointer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetVertexAttribPointerv(index, pname, &pointer);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetVertexAttribfv5(void* ptr, unsigned int index, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetVertexAttribfv(index, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetVertexAttribiv5(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetVertexAttribiv(index, pname, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetnColorTable5(void* ptr, unsigned int target, unsigned int format, unsigned int ty, int bufSize, void* table)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetnColorTable(target, format, ty, bufSize, table);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetnCompressedTexImage5(void* ptr, unsigned int target, int lod, int bufSize, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetnCompressedTexImage(target, lod, bufSize, pixels);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetnConvolutionFilter5(void* ptr, unsigned int target, unsigned int format, unsigned int ty, int bufSize, void* image)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetnConvolutionFilter(target, format, ty, bufSize, image);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetnHistogram5(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, int bufSize, void* values)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetnHistogram(target, reset != 0, format, ty, bufSize, values);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetnMapfv5(void* ptr, unsigned int target, unsigned int query, int bufSize, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetnMapfv(target, query, bufSize, &v);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetnMapiv5(void* ptr, unsigned int target, unsigned int query, int bufSize, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetnMapiv(target, query, bufSize, &v);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetnMinmax5(void* ptr, unsigned int target, char reset, unsigned int format, unsigned int ty, int bufSize, void* values)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetnMinmax(target, reset != 0, format, ty, bufSize, values);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetnPixelMapfv5(void* ptr, unsigned int m, int bufSize, float values)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetnPixelMapfv(m, bufSize, &values);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetnPixelMapuiv5(void* ptr, unsigned int m, int bufSize, unsigned int values)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetnPixelMapuiv(m, bufSize, &values);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetnPixelMapusv5(void* ptr, unsigned int m, int bufSize, unsigned short values)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetnPixelMapusv(m, bufSize, &values);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetnPolygonStipple5(void* ptr, int bufSize, char* pattern)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetnPolygonStipple(bufSize, static_cast<GLubyte*>(static_cast<void*>(pattern)));
}
void QOpenGLFunctions_4_5_Compatibility_GlGetnSeparableFilter5(void* ptr, unsigned int target, unsigned int format, unsigned int ty, int rowBufSize, void* row, int columnBufSize, void* column, void* span)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetnSeparableFilter(target, format, ty, rowBufSize, row, columnBufSize, column, span);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetnTexImage5(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, int bufSize, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetnTexImage(target, level, format, ty, bufSize, pixels);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetnUniformfv5(void* ptr, unsigned int program, int location, int bufSize, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetnUniformfv(program, location, bufSize, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetnUniformiv5(void* ptr, unsigned int program, int location, int bufSize, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetnUniformiv(program, location, bufSize, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlGetnUniformuiv5(void* ptr, unsigned int program, int location, int bufSize, unsigned int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glGetnUniformuiv(program, location, bufSize, &params);
}
void QOpenGLFunctions_4_5_Compatibility_GlHint5(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_4_5_Compatibility_GlHistogram5(void* ptr, unsigned int target, int width, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glHistogram(target, width, internalformat, sink != 0);
}
void QOpenGLFunctions_4_5_Compatibility_GlIndexMask5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glIndexMask(mask);
}
void QOpenGLFunctions_4_5_Compatibility_GlIndexPointer5(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glIndexPointer(ty, stride, pointer);
}
void QOpenGLFunctions_4_5_Compatibility_GlIndexf5(void* ptr, float c)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glIndexf(c);
}
void QOpenGLFunctions_4_5_Compatibility_GlIndexfv5(void* ptr, float c)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glIndexfv(const_cast<const GLfloat*>(&c));
}
void QOpenGLFunctions_4_5_Compatibility_GlIndexi5(void* ptr, int c)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glIndexi(c);
}
void QOpenGLFunctions_4_5_Compatibility_GlIndexiv5(void* ptr, int c)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glIndexiv(const_cast<const GLint*>(&c));
}
void QOpenGLFunctions_4_5_Compatibility_GlIndexs5(void* ptr, short c)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glIndexs(c);
}
void QOpenGLFunctions_4_5_Compatibility_GlIndexsv5(void* ptr, short c)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glIndexsv(const_cast<const GLshort*>(&c));
}
void QOpenGLFunctions_4_5_Compatibility_GlIndexub5(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glIndexub(*static_cast<GLubyte*>(static_cast<void*>(c)));
}
void QOpenGLFunctions_4_5_Compatibility_GlIndexubv5(void* ptr, char* c)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glIndexubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(c))));
}
void QOpenGLFunctions_4_5_Compatibility_GlInitNames5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glInitNames();
}
void QOpenGLFunctions_4_5_Compatibility_GlInterleavedArrays5(void* ptr, unsigned int format, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glInterleavedArrays(format, stride, pointer);
}
void QOpenGLFunctions_4_5_Compatibility_GlInvalidateBufferData5(void* ptr, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glInvalidateBufferData(buffer);
}
void QOpenGLFunctions_4_5_Compatibility_GlInvalidateFramebuffer5(void* ptr, unsigned int target, int numAttachments, unsigned int attachments)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glInvalidateFramebuffer(target, numAttachments, const_cast<const GLenum*>(&attachments));
}
void QOpenGLFunctions_4_5_Compatibility_GlInvalidateNamedFramebufferData5(void* ptr, unsigned int framebuffer, int numAttachments, unsigned int attachments)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glInvalidateNamedFramebufferData(framebuffer, numAttachments, const_cast<const GLenum*>(&attachments));
}
void QOpenGLFunctions_4_5_Compatibility_GlInvalidateNamedFramebufferSubData5(void* ptr, unsigned int framebuffer, int numAttachments, unsigned int attachments, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glInvalidateNamedFramebufferSubData(framebuffer, numAttachments, const_cast<const GLenum*>(&attachments), x, y, width, height);
}
void QOpenGLFunctions_4_5_Compatibility_GlInvalidateSubFramebuffer5(void* ptr, unsigned int target, int numAttachments, unsigned int attachments, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glInvalidateSubFramebuffer(target, numAttachments, const_cast<const GLenum*>(&attachments), x, y, width, height);
}
void QOpenGLFunctions_4_5_Compatibility_GlInvalidateTexImage5(void* ptr, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glInvalidateTexImage(texture, level);
}
void QOpenGLFunctions_4_5_Compatibility_GlInvalidateTexSubImage5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glInvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
}
void QOpenGLFunctions_4_5_Compatibility_GlLightModelf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glLightModelf(pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlLightModelfv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glLightModelfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_5_Compatibility_GlLightModeli5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glLightModeli(pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlLightModeliv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glLightModeliv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_5_Compatibility_GlLightf5(void* ptr, unsigned int light, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glLightf(light, pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlLightfv5(void* ptr, unsigned int light, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glLightfv(light, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_5_Compatibility_GlLighti5(void* ptr, unsigned int light, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glLighti(light, pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlLightiv5(void* ptr, unsigned int light, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glLightiv(light, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_5_Compatibility_GlLineStipple5(void* ptr, int factor, unsigned short pattern)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glLineStipple(factor, pattern);
}
void QOpenGLFunctions_4_5_Compatibility_GlLineWidth5(void* ptr, float width)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_4_5_Compatibility_GlLinkProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glLinkProgram(program);
}
void QOpenGLFunctions_4_5_Compatibility_GlListBase5(void* ptr, unsigned int base)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glListBase(base);
}
void QOpenGLFunctions_4_5_Compatibility_GlLoadIdentity5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glLoadIdentity();
}
void QOpenGLFunctions_4_5_Compatibility_GlLoadMatrixf5(void* ptr, float m)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glLoadMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_4_5_Compatibility_GlLoadName5(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glLoadName(name);
}
void QOpenGLFunctions_4_5_Compatibility_GlLoadTransposeMatrixf5(void* ptr, float m)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glLoadTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_4_5_Compatibility_GlLogicOp5(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_4_5_Compatibility_GlMap1f5(void* ptr, unsigned int target, float u1, float u2, int stride, int order, float points)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMap1f(target, u1, u2, stride, order, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_4_5_Compatibility_GlMap2f5(void* ptr, unsigned int target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float points)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, const_cast<const GLfloat*>(&points));
}
void QOpenGLFunctions_4_5_Compatibility_GlMapGrid1f5(void* ptr, int un, float u1, float u2)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMapGrid1f(un, u1, u2);
}
void QOpenGLFunctions_4_5_Compatibility_GlMapGrid2f5(void* ptr, int un, float u1, float u2, int vn, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMapGrid2f(un, u1, u2, vn, v1, v2);
}
void QOpenGLFunctions_4_5_Compatibility_GlMaterialf5(void* ptr, unsigned int face, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMaterialf(face, pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlMaterialfv5(void* ptr, unsigned int face, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMaterialfv(face, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_5_Compatibility_GlMateriali5(void* ptr, unsigned int face, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMateriali(face, pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlMaterialiv5(void* ptr, unsigned int face, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMaterialiv(face, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_5_Compatibility_GlMatrixMode5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMatrixMode(mode);
}
void QOpenGLFunctions_4_5_Compatibility_GlMemoryBarrier5(void* ptr, unsigned int barriers)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMemoryBarrier(barriers);
}
void QOpenGLFunctions_4_5_Compatibility_GlMemoryBarrierByRegion5(void* ptr, unsigned int barriers)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMemoryBarrierByRegion(barriers);
}
void QOpenGLFunctions_4_5_Compatibility_GlMinSampleShading5(void* ptr, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMinSampleShading(value);
}
void QOpenGLFunctions_4_5_Compatibility_GlMinmax5(void* ptr, unsigned int target, unsigned int internalformat, char sink)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMinmax(target, internalformat, sink != 0);
}
void QOpenGLFunctions_4_5_Compatibility_GlMultMatrixf5(void* ptr, float m)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_4_5_Compatibility_GlMultTransposeMatrixf5(void* ptr, float m)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultTransposeMatrixf(const_cast<const GLfloat*>(&m));
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiDrawArrays5(void* ptr, unsigned int mode, int first, int count, int drawcount)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiDrawArrays(mode, const_cast<const GLint*>(&first), const_cast<const GLsizei*>(&count), drawcount);
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiDrawArraysIndirect5(void* ptr, unsigned int mode, void* indirect, int drawcount, int stride)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiDrawArraysIndirect(mode, indirect, drawcount, stride);
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiDrawElementsIndirect5(void* ptr, unsigned int mode, unsigned int ty, void* indirect, int drawcount, int stride)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiDrawElementsIndirect(mode, ty, indirect, drawcount, stride);
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoord1f5(void* ptr, unsigned int target, float s)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoord1f(target, s);
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoord1fv5(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoord1fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoord1i5(void* ptr, unsigned int target, int s)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoord1i(target, s);
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoord1iv5(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoord1iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoord1s5(void* ptr, unsigned int target, short s)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoord1s(target, s);
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoord1sv5(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoord1sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoord2f5(void* ptr, unsigned int target, float s, float t)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoord2f(target, s, t);
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoord2fv5(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoord2fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoord2i5(void* ptr, unsigned int target, int s, int t)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoord2i(target, s, t);
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoord2iv5(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoord2iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoord2s5(void* ptr, unsigned int target, short s, short t)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoord2s(target, s, t);
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoord2sv5(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoord2sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoord3f5(void* ptr, unsigned int target, float s, float t, float r)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoord3f(target, s, t, r);
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoord3fv5(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoord3fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoord3i5(void* ptr, unsigned int target, int s, int t, int r)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoord3i(target, s, t, r);
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoord3iv5(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoord3iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoord3s5(void* ptr, unsigned int target, short s, short t, short r)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoord3s(target, s, t, r);
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoord3sv5(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoord3sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoord4f5(void* ptr, unsigned int target, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoord4f(target, s, t, r, q);
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoord4fv5(void* ptr, unsigned int target, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoord4fv(target, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoord4i5(void* ptr, unsigned int target, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoord4i(target, s, t, r, q);
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoord4iv5(void* ptr, unsigned int target, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoord4iv(target, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoord4s5(void* ptr, unsigned int target, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoord4s(target, s, t, r, q);
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoord4sv5(void* ptr, unsigned int target, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoord4sv(target, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoordP1ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoordP1ui(texture, ty, coords);
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoordP1uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoordP1uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoordP2ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoordP2ui(texture, ty, coords);
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoordP2uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoordP2uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoordP3ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoordP3ui(texture, ty, coords);
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoordP3uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoordP3uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoordP4ui5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoordP4ui(texture, ty, coords);
}
void QOpenGLFunctions_4_5_Compatibility_GlMultiTexCoordP4uiv5(void* ptr, unsigned int texture, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glMultiTexCoordP4uiv(texture, ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_5_Compatibility_GlNamedBufferData5(void* ptr, unsigned int buffer, int size, void* data, unsigned int usage)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glNamedBufferData(buffer, size, data, usage);
}
void QOpenGLFunctions_4_5_Compatibility_GlNamedBufferStorage5(void* ptr, unsigned int buffer, int size, void* data, unsigned int flags)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glNamedBufferStorage(buffer, size, data, flags);
}
void QOpenGLFunctions_4_5_Compatibility_GlNamedFramebufferDrawBuffer5(void* ptr, unsigned int framebuffer, unsigned int buf)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glNamedFramebufferDrawBuffer(framebuffer, buf);
}
void QOpenGLFunctions_4_5_Compatibility_GlNamedFramebufferDrawBuffers5(void* ptr, unsigned int framebuffer, int n, unsigned int bufs)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glNamedFramebufferDrawBuffers(framebuffer, n, const_cast<const GLenum*>(&bufs));
}
void QOpenGLFunctions_4_5_Compatibility_GlNamedFramebufferParameteri5(void* ptr, unsigned int framebuffer, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glNamedFramebufferParameteri(framebuffer, pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlNamedFramebufferReadBuffer5(void* ptr, unsigned int framebuffer, unsigned int src)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glNamedFramebufferReadBuffer(framebuffer, src);
}
void QOpenGLFunctions_4_5_Compatibility_GlNamedFramebufferRenderbuffer5(void* ptr, unsigned int framebuffer, unsigned int attachment, unsigned int renderbuffertarget, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glNamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer);
}
void QOpenGLFunctions_4_5_Compatibility_GlNamedFramebufferTexture5(void* ptr, unsigned int framebuffer, unsigned int attachment, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glNamedFramebufferTexture(framebuffer, attachment, texture, level);
}
void QOpenGLFunctions_4_5_Compatibility_GlNamedFramebufferTextureLayer5(void* ptr, unsigned int framebuffer, unsigned int attachment, unsigned int texture, int level, int layer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glNamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer);
}
void QOpenGLFunctions_4_5_Compatibility_GlNamedRenderbufferStorage5(void* ptr, unsigned int renderbuffer, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glNamedRenderbufferStorage(renderbuffer, internalformat, width, height);
}
void QOpenGLFunctions_4_5_Compatibility_GlNamedRenderbufferStorageMultisample5(void* ptr, unsigned int renderbuffer, int samples, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glNamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height);
}
void QOpenGLFunctions_4_5_Compatibility_GlNewList5(void* ptr, unsigned int list, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glNewList(list, mode);
}
void QOpenGLFunctions_4_5_Compatibility_GlNormal3f5(void* ptr, float nx, float ny, float nz)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glNormal3f(nx, ny, nz);
}
void QOpenGLFunctions_4_5_Compatibility_GlNormal3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glNormal3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlNormal3i5(void* ptr, int nx, int ny, int nz)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glNormal3i(nx, ny, nz);
}
void QOpenGLFunctions_4_5_Compatibility_GlNormal3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glNormal3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlNormal3s5(void* ptr, short nx, short ny, short nz)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glNormal3s(nx, ny, nz);
}
void QOpenGLFunctions_4_5_Compatibility_GlNormal3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glNormal3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlNormalP3ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glNormalP3ui(ty, coords);
}
void QOpenGLFunctions_4_5_Compatibility_GlNormalP3uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glNormalP3uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_5_Compatibility_GlNormalPointer5(void* ptr, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glNormalPointer(ty, stride, pointer);
}
void QOpenGLFunctions_4_5_Compatibility_GlPassThrough5(void* ptr, float token)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPassThrough(token);
}
void QOpenGLFunctions_4_5_Compatibility_GlPatchParameterfv5(void* ptr, unsigned int pname, float values)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPatchParameterfv(pname, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_4_5_Compatibility_GlPatchParameteri5(void* ptr, unsigned int pname, int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPatchParameteri(pname, value);
}
void QOpenGLFunctions_4_5_Compatibility_GlPauseTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPauseTransformFeedback();
}
void QOpenGLFunctions_4_5_Compatibility_GlPixelMapfv5(void* ptr, unsigned int m, int mapsize, float values)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPixelMapfv(m, mapsize, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_4_5_Compatibility_GlPixelMapuiv5(void* ptr, unsigned int m, int mapsize, unsigned int values)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPixelMapuiv(m, mapsize, const_cast<const GLuint*>(&values));
}
void QOpenGLFunctions_4_5_Compatibility_GlPixelMapusv5(void* ptr, unsigned int m, int mapsize, unsigned short values)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPixelMapusv(m, mapsize, const_cast<const GLushort*>(&values));
}
void QOpenGLFunctions_4_5_Compatibility_GlPixelStoref5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlPixelStorei5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlPixelTransferf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPixelTransferf(pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlPixelTransferi5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPixelTransferi(pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlPixelZoom5(void* ptr, float xfactor, float yfactor)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPixelZoom(xfactor, yfactor);
}
void QOpenGLFunctions_4_5_Compatibility_GlPointParameterf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPointParameterf(pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlPointParameterfv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPointParameterfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_5_Compatibility_GlPointParameteri5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPointParameteri(pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlPointParameteriv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPointParameteriv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_5_Compatibility_GlPointSize5(void* ptr, float size)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_4_5_Compatibility_GlPolygonMode5(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_4_5_Compatibility_GlPolygonOffset5(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_4_5_Compatibility_GlPolygonStipple5(void* ptr, char* mask)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPolygonStipple(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(mask))));
}
void QOpenGLFunctions_4_5_Compatibility_GlPopAttrib5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPopAttrib();
}
void QOpenGLFunctions_4_5_Compatibility_GlPopClientAttrib5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPopClientAttrib();
}
void QOpenGLFunctions_4_5_Compatibility_GlPopDebugGroup5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPopDebugGroup();
}
void QOpenGLFunctions_4_5_Compatibility_GlPopMatrix5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPopMatrix();
}
void QOpenGLFunctions_4_5_Compatibility_GlPopName5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPopName();
}
void QOpenGLFunctions_4_5_Compatibility_GlPrimitiveRestartIndex5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPrimitiveRestartIndex(index);
}
void QOpenGLFunctions_4_5_Compatibility_GlPrioritizeTextures5(void* ptr, int n, unsigned int textures, float priorities)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPrioritizeTextures(n, const_cast<const GLuint*>(&textures), const_cast<const GLfloat*>(&priorities));
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramBinary5(void* ptr, unsigned int program, unsigned int binaryFormat, void* binary, int length)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramBinary(program, binaryFormat, binary, length);
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramParameteri5(void* ptr, unsigned int program, unsigned int pname, int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramParameteri(program, pname, value);
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniform1f5(void* ptr, unsigned int program, int location, float v0)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniform1f(program, location, v0);
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniform1fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniform1fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniform1i5(void* ptr, unsigned int program, int location, int v0)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniform1i(program, location, v0);
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniform1iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniform1iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniform1ui5(void* ptr, unsigned int program, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniform1ui(program, location, v0);
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniform1uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniform1uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniform2f5(void* ptr, unsigned int program, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniform2f(program, location, v0, v1);
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniform2fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniform2fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniform2i5(void* ptr, unsigned int program, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniform2i(program, location, v0, v1);
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniform2iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniform2iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniform2ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniform2ui(program, location, v0, v1);
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniform2uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniform2uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniform3f5(void* ptr, unsigned int program, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniform3f(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniform3fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniform3fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniform3i5(void* ptr, unsigned int program, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniform3i(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniform3iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniform3iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniform3ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniform3ui(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniform3uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniform3uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniform4f5(void* ptr, unsigned int program, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniform4f(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniform4fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniform4fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniform4i5(void* ptr, unsigned int program, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniform4i(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniform4iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniform4iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniform4ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniform4ui(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniform4uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniform4uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniformMatrix2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniformMatrix2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniformMatrix2x3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniformMatrix2x3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniformMatrix2x4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniformMatrix2x4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniformMatrix3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniformMatrix3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniformMatrix3x2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniformMatrix3x2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniformMatrix3x4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniformMatrix3x4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniformMatrix4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniformMatrix4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniformMatrix4x2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniformMatrix4x2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlProgramUniformMatrix4x3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProgramUniformMatrix4x3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlProvokingVertex5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glProvokingVertex(mode);
}
void QOpenGLFunctions_4_5_Compatibility_GlPushAttrib5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPushAttrib(mask);
}
void QOpenGLFunctions_4_5_Compatibility_GlPushClientAttrib5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPushClientAttrib(mask);
}
void QOpenGLFunctions_4_5_Compatibility_GlPushMatrix5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPushMatrix();
}
void QOpenGLFunctions_4_5_Compatibility_GlPushName5(void* ptr, unsigned int name)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glPushName(name);
}
void QOpenGLFunctions_4_5_Compatibility_GlQueryCounter5(void* ptr, unsigned int id, unsigned int target)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glQueryCounter(id, target);
}
void QOpenGLFunctions_4_5_Compatibility_GlRasterPos2f5(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRasterPos2f(x, y);
}
void QOpenGLFunctions_4_5_Compatibility_GlRasterPos2fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRasterPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlRasterPos2i5(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRasterPos2i(x, y);
}
void QOpenGLFunctions_4_5_Compatibility_GlRasterPos2iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRasterPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlRasterPos2s5(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRasterPos2s(x, y);
}
void QOpenGLFunctions_4_5_Compatibility_GlRasterPos2sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRasterPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlRasterPos3f5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRasterPos3f(x, y, z);
}
void QOpenGLFunctions_4_5_Compatibility_GlRasterPos3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRasterPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlRasterPos3i5(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRasterPos3i(x, y, z);
}
void QOpenGLFunctions_4_5_Compatibility_GlRasterPos3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRasterPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlRasterPos3s5(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRasterPos3s(x, y, z);
}
void QOpenGLFunctions_4_5_Compatibility_GlRasterPos3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRasterPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlRasterPos4f5(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRasterPos4f(x, y, z, w);
}
void QOpenGLFunctions_4_5_Compatibility_GlRasterPos4fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRasterPos4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlRasterPos4i5(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRasterPos4i(x, y, z, w);
}
void QOpenGLFunctions_4_5_Compatibility_GlRasterPos4iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRasterPos4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlRasterPos4s5(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRasterPos4s(x, y, z, w);
}
void QOpenGLFunctions_4_5_Compatibility_GlRasterPos4sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRasterPos4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlReadBuffer5(void* ptr, unsigned int src)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glReadBuffer(src);
}
void QOpenGLFunctions_4_5_Compatibility_GlReadPixels5(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_5_Compatibility_GlReadnPixels5(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, int bufSize, void* data)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glReadnPixels(x, y, width, height, format, ty, bufSize, data);
}
void QOpenGLFunctions_4_5_Compatibility_GlRectf5(void* ptr, float x1, float y1, float x2, float y2)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRectf(x1, y1, x2, y2);
}
void QOpenGLFunctions_4_5_Compatibility_GlRectfv5(void* ptr, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRectfv(const_cast<const GLfloat*>(&v1), const_cast<const GLfloat*>(&v2));
}
void QOpenGLFunctions_4_5_Compatibility_GlRecti5(void* ptr, int x1, int y1, int x2, int y2)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRecti(x1, y1, x2, y2);
}
void QOpenGLFunctions_4_5_Compatibility_GlRectiv5(void* ptr, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRectiv(const_cast<const GLint*>(&v1), const_cast<const GLint*>(&v2));
}
void QOpenGLFunctions_4_5_Compatibility_GlRects5(void* ptr, short x1, short y1, short x2, short y2)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRects(x1, y1, x2, y2);
}
void QOpenGLFunctions_4_5_Compatibility_GlRectsv5(void* ptr, short v1, short v2)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRectsv(const_cast<const GLshort*>(&v1), const_cast<const GLshort*>(&v2));
}
void QOpenGLFunctions_4_5_Compatibility_GlReleaseShaderCompiler5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glReleaseShaderCompiler();
}
void QOpenGLFunctions_4_5_Compatibility_GlRenderbufferStorage5(void* ptr, unsigned int target, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRenderbufferStorage(target, internalformat, width, height);
}
void QOpenGLFunctions_4_5_Compatibility_GlRenderbufferStorageMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
}
void QOpenGLFunctions_4_5_Compatibility_GlResetHistogram5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glResetHistogram(target);
}
void QOpenGLFunctions_4_5_Compatibility_GlResetMinmax5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glResetMinmax(target);
}
void QOpenGLFunctions_4_5_Compatibility_GlResumeTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glResumeTransformFeedback();
}
void QOpenGLFunctions_4_5_Compatibility_GlRotatef5(void* ptr, float angle, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glRotatef(angle, x, y, z);
}
void QOpenGLFunctions_4_5_Compatibility_GlSampleCoverage5(void* ptr, float value, char invert)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSampleCoverage(value, invert != 0);
}
void QOpenGLFunctions_4_5_Compatibility_GlSampleMaski5(void* ptr, unsigned int maskNumber, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSampleMaski(maskNumber, mask);
}
void QOpenGLFunctions_4_5_Compatibility_GlSamplerParameterIiv5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSamplerParameterIiv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_5_Compatibility_GlSamplerParameterIuiv5(void* ptr, unsigned int sampler, unsigned int pname, unsigned int param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSamplerParameterIuiv(sampler, pname, const_cast<const GLuint*>(&param));
}
void QOpenGLFunctions_4_5_Compatibility_GlSamplerParameterf5(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSamplerParameterf(sampler, pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlSamplerParameterfv5(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSamplerParameterfv(sampler, pname, const_cast<const GLfloat*>(&param));
}
void QOpenGLFunctions_4_5_Compatibility_GlSamplerParameteri5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSamplerParameteri(sampler, pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlSamplerParameteriv5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSamplerParameteriv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_5_Compatibility_GlScalef5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glScalef(x, y, z);
}
void QOpenGLFunctions_4_5_Compatibility_GlScissor5(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_4_5_Compatibility_GlScissorArrayv5(void* ptr, unsigned int first, int count, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glScissorArrayv(first, count, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlScissorIndexed5(void* ptr, unsigned int index, int left, int bottom, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glScissorIndexed(index, left, bottom, width, height);
}
void QOpenGLFunctions_4_5_Compatibility_GlScissorIndexedv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glScissorIndexedv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlSecondaryColor3f5(void* ptr, float red, float green, float blue)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSecondaryColor3f(red, green, blue);
}
void QOpenGLFunctions_4_5_Compatibility_GlSecondaryColor3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSecondaryColor3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlSecondaryColor3i5(void* ptr, int red, int green, int blue)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSecondaryColor3i(red, green, blue);
}
void QOpenGLFunctions_4_5_Compatibility_GlSecondaryColor3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSecondaryColor3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlSecondaryColor3s5(void* ptr, short red, short green, short blue)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSecondaryColor3s(red, green, blue);
}
void QOpenGLFunctions_4_5_Compatibility_GlSecondaryColor3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSecondaryColor3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlSecondaryColor3ub5(void* ptr, char* red, char* green, char* blue)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSecondaryColor3ub(*static_cast<GLubyte*>(static_cast<void*>(red)), *static_cast<GLubyte*>(static_cast<void*>(green)), *static_cast<GLubyte*>(static_cast<void*>(blue)));
}
void QOpenGLFunctions_4_5_Compatibility_GlSecondaryColor3ubv5(void* ptr, char* v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSecondaryColor3ubv(const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_5_Compatibility_GlSecondaryColor3ui5(void* ptr, unsigned int red, unsigned int green, unsigned int blue)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSecondaryColor3ui(red, green, blue);
}
void QOpenGLFunctions_4_5_Compatibility_GlSecondaryColor3uiv5(void* ptr, unsigned int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSecondaryColor3uiv(const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlSecondaryColor3us5(void* ptr, unsigned short red, unsigned short green, unsigned short blue)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSecondaryColor3us(red, green, blue);
}
void QOpenGLFunctions_4_5_Compatibility_GlSecondaryColor3usv5(void* ptr, unsigned short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSecondaryColor3usv(const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlSecondaryColorP3ui5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSecondaryColorP3ui(ty, color);
}
void QOpenGLFunctions_4_5_Compatibility_GlSecondaryColorP3uiv5(void* ptr, unsigned int ty, unsigned int color)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSecondaryColorP3uiv(ty, const_cast<const GLuint*>(&color));
}
void QOpenGLFunctions_4_5_Compatibility_GlSecondaryColorPointer5(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSecondaryColorPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_4_5_Compatibility_GlSelectBuffer5(void* ptr, int size, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSelectBuffer(size, &buffer);
}
void QOpenGLFunctions_4_5_Compatibility_GlSeparableFilter2D5(void* ptr, unsigned int target, unsigned int internalformat, int width, int height, unsigned int format, unsigned int ty, void* row, void* column)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glSeparableFilter2D(target, internalformat, width, height, format, ty, row, column);
}
void QOpenGLFunctions_4_5_Compatibility_GlShadeModel5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glShadeModel(mode);
}
void QOpenGLFunctions_4_5_Compatibility_GlShaderBinary5(void* ptr, int count, unsigned int shaders, unsigned int binaryformat, void* binary, int length)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glShaderBinary(count, const_cast<const GLuint*>(&shaders), binaryformat, binary, length);
}
void QOpenGLFunctions_4_5_Compatibility_GlShaderStorageBlockBinding5(void* ptr, unsigned int program, unsigned int storageBlockIndex, unsigned int storageBlockBinding)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
}
void QOpenGLFunctions_4_5_Compatibility_GlStencilFunc5(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_4_5_Compatibility_GlStencilFuncSeparate5(void* ptr, unsigned int face, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glStencilFuncSeparate(face, fu, ref, mask);
}
void QOpenGLFunctions_4_5_Compatibility_GlStencilMask5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_4_5_Compatibility_GlStencilMaskSeparate5(void* ptr, unsigned int face, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glStencilMaskSeparate(face, mask);
}
void QOpenGLFunctions_4_5_Compatibility_GlStencilOp5(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_4_5_Compatibility_GlStencilOpSeparate5(void* ptr, unsigned int face, unsigned int sfail, unsigned int dpfail, unsigned int dppass)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glStencilOpSeparate(face, sfail, dpfail, dppass);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexBuffer5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexBuffer(target, internalformat, buffer);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoord1f5(void* ptr, float s)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoord1f(s);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoord1fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoord1fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoord1i5(void* ptr, int s)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoord1i(s);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoord1iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoord1iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoord1s5(void* ptr, short s)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoord1s(s);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoord1sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoord1sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoord2f5(void* ptr, float s, float t)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoord2f(s, t);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoord2fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoord2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoord2i5(void* ptr, int s, int t)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoord2i(s, t);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoord2iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoord2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoord2s5(void* ptr, short s, short t)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoord2s(s, t);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoord2sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoord2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoord3f5(void* ptr, float s, float t, float r)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoord3f(s, t, r);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoord3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoord3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoord3i5(void* ptr, int s, int t, int r)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoord3i(s, t, r);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoord3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoord3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoord3s5(void* ptr, short s, short t, short r)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoord3s(s, t, r);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoord3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoord3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoord4f5(void* ptr, float s, float t, float r, float q)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoord4f(s, t, r, q);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoord4fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoord4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoord4i5(void* ptr, int s, int t, int r, int q)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoord4i(s, t, r, q);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoord4iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoord4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoord4s5(void* ptr, short s, short t, short r, short q)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoord4s(s, t, r, q);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoord4sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoord4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoordP1ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoordP1ui(ty, coords);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoordP1uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoordP1uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoordP2ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoordP2ui(ty, coords);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoordP2uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoordP2uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoordP3ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoordP3ui(ty, coords);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoordP3uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoordP3uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoordP4ui5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoordP4ui(ty, coords);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoordP4uiv5(void* ptr, unsigned int ty, unsigned int coords)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoordP4uiv(ty, const_cast<const GLuint*>(&coords));
}
void QOpenGLFunctions_4_5_Compatibility_GlTexCoordPointer5(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexCoordPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexEnvf5(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexEnvf(target, pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexEnvfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexEnvfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_5_Compatibility_GlTexEnvi5(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexEnvi(target, pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexEnviv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexEnviv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_5_Compatibility_GlTexGenf5(void* ptr, unsigned int coord, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexGenf(coord, pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexGenfv5(void* ptr, unsigned int coord, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexGenfv(coord, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_5_Compatibility_GlTexGeni5(void* ptr, unsigned int coord, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexGeni(coord, pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexGeniv5(void* ptr, unsigned int coord, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexGeniv(coord, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_5_Compatibility_GlTexImage1D5(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexImage2D5(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexImage2DMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexImage3D5(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexImage3DMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexParameterIiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexParameterIiv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_5_Compatibility_GlTexParameterIuiv5(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexParameterIuiv(target, pname, const_cast<const GLuint*>(&params));
}
void QOpenGLFunctions_4_5_Compatibility_GlTexParameterf5(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_5_Compatibility_GlTexParameteri5(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_5_Compatibility_GlTexStorage1D5(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexStorage1D(target, levels, internalformat, width);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexStorage2D5(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexStorage2D(target, levels, internalformat, width, height);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexStorage2DMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexStorage3D5(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width, int height, int depth)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexStorage3D(target, levels, internalformat, width, height, depth);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexStorage3DMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_5_Compatibility_GlTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_4_5_Compatibility_GlTextureBarrier5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTextureBarrier();
}
void QOpenGLFunctions_4_5_Compatibility_GlTextureBuffer5(void* ptr, unsigned int texture, unsigned int internalformat, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTextureBuffer(texture, internalformat, buffer);
}
void QOpenGLFunctions_4_5_Compatibility_GlTextureParameterIiv5(void* ptr, unsigned int texture, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTextureParameterIiv(texture, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_5_Compatibility_GlTextureParameterIuiv5(void* ptr, unsigned int texture, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTextureParameterIuiv(texture, pname, const_cast<const GLuint*>(&params));
}
void QOpenGLFunctions_4_5_Compatibility_GlTextureParameterf5(void* ptr, unsigned int texture, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTextureParameterf(texture, pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlTextureParameterfv5(void* ptr, unsigned int texture, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTextureParameterfv(texture, pname, const_cast<const GLfloat*>(&param));
}
void QOpenGLFunctions_4_5_Compatibility_GlTextureParameteri5(void* ptr, unsigned int texture, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTextureParameteri(texture, pname, param);
}
void QOpenGLFunctions_4_5_Compatibility_GlTextureParameteriv5(void* ptr, unsigned int texture, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTextureParameteriv(texture, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_5_Compatibility_GlTextureStorage1D5(void* ptr, unsigned int texture, int levels, unsigned int internalformat, int width)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTextureStorage1D(texture, levels, internalformat, width);
}
void QOpenGLFunctions_4_5_Compatibility_GlTextureStorage2D5(void* ptr, unsigned int texture, int levels, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTextureStorage2D(texture, levels, internalformat, width, height);
}
void QOpenGLFunctions_4_5_Compatibility_GlTextureStorage2DMultisample5(void* ptr, unsigned int texture, int samples, unsigned int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_5_Compatibility_GlTextureStorage3D5(void* ptr, unsigned int texture, int levels, unsigned int internalformat, int width, int height, int depth)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTextureStorage3D(texture, levels, internalformat, width, height, depth);
}
void QOpenGLFunctions_4_5_Compatibility_GlTextureStorage3DMultisample5(void* ptr, unsigned int texture, int samples, unsigned int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_5_Compatibility_GlTextureSubImage1D5(void* ptr, unsigned int texture, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTextureSubImage1D(texture, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_4_5_Compatibility_GlTextureSubImage2D5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_5_Compatibility_GlTextureSubImage3D5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_4_5_Compatibility_GlTextureView5(void* ptr, unsigned int texture, unsigned int target, unsigned int origtexture, unsigned int internalformat, unsigned int minlevel, unsigned int numlevels, unsigned int minlayer, unsigned int numlayers)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
}
void QOpenGLFunctions_4_5_Compatibility_GlTransformFeedbackBufferBase5(void* ptr, unsigned int xfb, unsigned int index, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTransformFeedbackBufferBase(xfb, index, buffer);
}
void QOpenGLFunctions_4_5_Compatibility_GlTranslatef5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glTranslatef(x, y, z);
}
void QOpenGLFunctions_4_5_Compatibility_GlUniform1f5(void* ptr, int location, float v0)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniform1f(location, v0);
}
void QOpenGLFunctions_4_5_Compatibility_GlUniform1fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniform1fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlUniform1i5(void* ptr, int location, int v0)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniform1i(location, v0);
}
void QOpenGLFunctions_4_5_Compatibility_GlUniform1iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniform1iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlUniform1ui5(void* ptr, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniform1ui(location, v0);
}
void QOpenGLFunctions_4_5_Compatibility_GlUniform1uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniform1uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlUniform2f5(void* ptr, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniform2f(location, v0, v1);
}
void QOpenGLFunctions_4_5_Compatibility_GlUniform2fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniform2fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlUniform2i5(void* ptr, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniform2i(location, v0, v1);
}
void QOpenGLFunctions_4_5_Compatibility_GlUniform2iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniform2iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlUniform2ui5(void* ptr, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniform2ui(location, v0, v1);
}
void QOpenGLFunctions_4_5_Compatibility_GlUniform2uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniform2uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlUniform3f5(void* ptr, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniform3f(location, v0, v1, v2);
}
void QOpenGLFunctions_4_5_Compatibility_GlUniform3fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniform3fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlUniform3i5(void* ptr, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniform3i(location, v0, v1, v2);
}
void QOpenGLFunctions_4_5_Compatibility_GlUniform3iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniform3iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlUniform3ui5(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniform3ui(location, v0, v1, v2);
}
void QOpenGLFunctions_4_5_Compatibility_GlUniform3uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniform3uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlUniform4f5(void* ptr, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniform4f(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_5_Compatibility_GlUniform4fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniform4fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlUniform4i5(void* ptr, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniform4i(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_5_Compatibility_GlUniform4iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniform4iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlUniform4ui5(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniform4ui(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_5_Compatibility_GlUniform4uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniform4uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlUniformBlockBinding5(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int uniformBlockBinding)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}
void QOpenGLFunctions_4_5_Compatibility_GlUniformMatrix2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniformMatrix2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlUniformMatrix2x3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniformMatrix2x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlUniformMatrix2x4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniformMatrix2x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlUniformMatrix3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniformMatrix3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlUniformMatrix3x2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniformMatrix3x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlUniformMatrix3x4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniformMatrix3x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlUniformMatrix4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniformMatrix4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlUniformMatrix4x2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniformMatrix4x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlUniformMatrix4x3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniformMatrix4x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlUniformSubroutinesuiv5(void* ptr, unsigned int shadertype, int count, unsigned int indices)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUniformSubroutinesuiv(shadertype, count, const_cast<const GLuint*>(&indices));
}
void QOpenGLFunctions_4_5_Compatibility_GlUseProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUseProgram(program);
}
void QOpenGLFunctions_4_5_Compatibility_GlUseProgramStages5(void* ptr, unsigned int pipeline, unsigned int stages, unsigned int program)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glUseProgramStages(pipeline, stages, program);
}
void QOpenGLFunctions_4_5_Compatibility_GlValidateProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glValidateProgram(program);
}
void QOpenGLFunctions_4_5_Compatibility_GlValidateProgramPipeline5(void* ptr, unsigned int pipeline)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glValidateProgramPipeline(pipeline);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertex2f5(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertex2f(x, y);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertex2fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertex2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertex2i5(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertex2i(x, y);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertex2iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertex2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertex2s5(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertex2s(x, y);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertex2sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertex2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertex3f5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertex3f(x, y, z);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertex3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertex3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertex3i5(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertex3i(x, y, z);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertex3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertex3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertex3s5(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertex3s(x, y, z);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertex3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertex3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertex4f5(void* ptr, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertex4f(x, y, z, w);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertex4fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertex4fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertex4i5(void* ptr, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertex4i(x, y, z, w);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertex4iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertex4iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertex4s5(void* ptr, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertex4s(x, y, z, w);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertex4sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertex4sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexArrayAttribBinding5(void* ptr, unsigned int vaobj, unsigned int attribindex, unsigned int bindingindex)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexArrayAttribBinding(vaobj, attribindex, bindingindex);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexArrayAttribFormat5(void* ptr, unsigned int vaobj, unsigned int attribindex, int size, unsigned int ty, char normalized, unsigned int relativeoffset)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexArrayAttribFormat(vaobj, attribindex, size, ty, normalized != 0, relativeoffset);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexArrayAttribIFormat5(void* ptr, unsigned int vaobj, unsigned int attribindex, int size, unsigned int ty, unsigned int relativeoffset)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexArrayAttribIFormat(vaobj, attribindex, size, ty, relativeoffset);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexArrayAttribLFormat5(void* ptr, unsigned int vaobj, unsigned int attribindex, int size, unsigned int ty, unsigned int relativeoffset)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexArrayAttribLFormat(vaobj, attribindex, size, ty, relativeoffset);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexArrayBindingDivisor5(void* ptr, unsigned int vaobj, unsigned int bindingindex, unsigned int divisor)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexArrayBindingDivisor(vaobj, bindingindex, divisor);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexArrayElementBuffer5(void* ptr, unsigned int vaobj, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexArrayElementBuffer(vaobj, buffer);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib1f5(void* ptr, unsigned int index, float x)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib1f(index, x);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib1fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib1fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib1s5(void* ptr, unsigned int index, short x)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib1s(index, x);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib1sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib1sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib2f5(void* ptr, unsigned int index, float x, float y)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib2f(index, x, y);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib2fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib2fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib2s5(void* ptr, unsigned int index, short x, short y)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib2s(index, x, y);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib2sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib2sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib3f5(void* ptr, unsigned int index, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib3f(index, x, y, z);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib3fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib3fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib3s5(void* ptr, unsigned int index, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib3s(index, x, y, z);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib3sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib3sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib4Niv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib4Niv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib4Nsv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib4Nsv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib4Nub5(void* ptr, unsigned int index, char* x, char* y, char* z, char* w)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib4Nub(index, *static_cast<GLubyte*>(static_cast<void*>(x)), *static_cast<GLubyte*>(static_cast<void*>(y)), *static_cast<GLubyte*>(static_cast<void*>(z)), *static_cast<GLubyte*>(static_cast<void*>(w)));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib4Nubv5(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib4Nubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib4Nuiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib4Nuiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib4Nusv5(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib4Nusv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib4f5(void* ptr, unsigned int index, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib4f(index, x, y, z, w);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib4fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib4fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib4iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib4s5(void* ptr, unsigned int index, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib4s(index, x, y, z, w);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib4sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib4sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib4ubv5(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib4ubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib4uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttrib4usv5(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttrib4usv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribBinding5(void* ptr, unsigned int attribindex, unsigned int bindingindex)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribBinding(attribindex, bindingindex);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribDivisor5(void* ptr, unsigned int index, unsigned int divisor)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribDivisor(index, divisor);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribFormat5(void* ptr, unsigned int attribindex, int size, unsigned int ty, char normalized, unsigned int relativeoffset)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribFormat(attribindex, size, ty, normalized != 0, relativeoffset);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribI1i5(void* ptr, unsigned int index, int x)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribI1i(index, x);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribI1iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribI1iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribI1ui5(void* ptr, unsigned int index, unsigned int x)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribI1ui(index, x);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribI1uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribI1uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribI2i5(void* ptr, unsigned int index, int x, int y)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribI2i(index, x, y);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribI2iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribI2iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribI2ui5(void* ptr, unsigned int index, unsigned int x, unsigned int y)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribI2ui(index, x, y);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribI2uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribI2uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribI3i5(void* ptr, unsigned int index, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribI3i(index, x, y, z);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribI3iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribI3iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribI3ui5(void* ptr, unsigned int index, unsigned int x, unsigned int y, unsigned int z)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribI3ui(index, x, y, z);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribI3uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribI3uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribI4i5(void* ptr, unsigned int index, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribI4i(index, x, y, z, w);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribI4iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribI4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribI4sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribI4sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribI4ubv5(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribI4ubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribI4ui5(void* ptr, unsigned int index, unsigned int x, unsigned int y, unsigned int z, unsigned int w)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribI4ui(index, x, y, z, w);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribI4uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribI4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribI4usv5(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribI4usv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribIFormat5(void* ptr, unsigned int attribindex, int size, unsigned int ty, unsigned int relativeoffset)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribIFormat(attribindex, size, ty, relativeoffset);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribIPointer5(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribIPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribLFormat5(void* ptr, unsigned int attribindex, int size, unsigned int ty, unsigned int relativeoffset)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribLFormat(attribindex, size, ty, relativeoffset);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribLPointer5(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribLPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribP1ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribP1ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribP1uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribP1uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribP2ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribP2ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribP2uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribP2uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribP3ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribP3ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribP3uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribP3uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribP4ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribP4ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribP4uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribP4uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexAttribPointer5(void* ptr, unsigned int index, int size, unsigned int ty, char normalized, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexAttribPointer(index, size, ty, normalized != 0, stride, pointer);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexBindingDivisor5(void* ptr, unsigned int bindingindex, unsigned int divisor)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexBindingDivisor(bindingindex, divisor);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexP2ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexP2ui(ty, value);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexP2uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexP2uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexP3ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexP3ui(ty, value);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexP3uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexP3uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexP4ui5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexP4ui(ty, value);
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexP4uiv5(void* ptr, unsigned int ty, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexP4uiv(ty, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Compatibility_GlVertexPointer5(void* ptr, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glVertexPointer(size, ty, stride, pointer);
}
void QOpenGLFunctions_4_5_Compatibility_GlViewport5(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_4_5_Compatibility_GlViewportArrayv5(void* ptr, unsigned int first, int count, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glViewportArrayv(first, count, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlViewportIndexedf5(void* ptr, unsigned int index, float x, float y, float w, float h)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glViewportIndexedf(index, x, y, w, h);
}
void QOpenGLFunctions_4_5_Compatibility_GlViewportIndexedfv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glViewportIndexedfv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlWindowPos2f5(void* ptr, float x, float y)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glWindowPos2f(x, y);
}
void QOpenGLFunctions_4_5_Compatibility_GlWindowPos2fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glWindowPos2fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlWindowPos2i5(void* ptr, int x, int y)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glWindowPos2i(x, y);
}
void QOpenGLFunctions_4_5_Compatibility_GlWindowPos2iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glWindowPos2iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlWindowPos2s5(void* ptr, short x, short y)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glWindowPos2s(x, y);
}
void QOpenGLFunctions_4_5_Compatibility_GlWindowPos2sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glWindowPos2sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlWindowPos3f5(void* ptr, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glWindowPos3f(x, y, z);
}
void QOpenGLFunctions_4_5_Compatibility_GlWindowPos3fv5(void* ptr, float v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glWindowPos3fv(const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlWindowPos3i5(void* ptr, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glWindowPos3i(x, y, z);
}
void QOpenGLFunctions_4_5_Compatibility_GlWindowPos3iv5(void* ptr, int v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glWindowPos3iv(const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_GlWindowPos3s5(void* ptr, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glWindowPos3s(x, y, z);
}
void QOpenGLFunctions_4_5_Compatibility_GlWindowPos3sv5(void* ptr, short v)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glWindowPos3sv(const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Compatibility_DestroyQOpenGLFunctions_4_5_Compatibility5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->~QOpenGLFunctions_4_5_Compatibility();
}
void QOpenGLFunctions_4_5_Compatibility_DestroyQOpenGLFunctions_4_5_Compatibility5Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLFunctions_4_5_Core: public QOpenGLFunctions_4_5_Core
{
public:
MyQOpenGLFunctions_4_5_Core() : QOpenGLFunctions_4_5_Core() {};
bool initializeOpenGLFunctions() { return callbackQOpenGLFunctions_4_5_Core_InitializeOpenGLFunctions5(this) != 0; };
~MyQOpenGLFunctions_4_5_Core() { callbackQOpenGLFunctions_4_5_Core_DestroyQOpenGLFunctions_4_5_Core5(this); };
};
char QOpenGLFunctions_4_5_Core_GlIsBuffer5(void* ptr, unsigned int buffer)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glIsBuffer(buffer);
}
char QOpenGLFunctions_4_5_Core_GlIsEnabled5(void* ptr, unsigned int cap)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glIsEnabled(cap);
}
char QOpenGLFunctions_4_5_Core_GlIsEnabledi5(void* ptr, unsigned int target, unsigned int index)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glIsEnabledi(target, index);
}
char QOpenGLFunctions_4_5_Core_GlIsFramebuffer5(void* ptr, unsigned int framebuffer)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glIsFramebuffer(framebuffer);
}
char QOpenGLFunctions_4_5_Core_GlIsProgram5(void* ptr, unsigned int program)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glIsProgram(program);
}
char QOpenGLFunctions_4_5_Core_GlIsProgramPipeline5(void* ptr, unsigned int pipeline)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glIsProgramPipeline(pipeline);
}
char QOpenGLFunctions_4_5_Core_GlIsQuery5(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glIsQuery(id);
}
char QOpenGLFunctions_4_5_Core_GlIsRenderbuffer5(void* ptr, unsigned int renderbuffer)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glIsRenderbuffer(renderbuffer);
}
char QOpenGLFunctions_4_5_Core_GlIsSampler5(void* ptr, unsigned int sampler)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glIsSampler(sampler);
}
char QOpenGLFunctions_4_5_Core_GlIsShader5(void* ptr, unsigned int shader)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glIsShader(shader);
}
char QOpenGLFunctions_4_5_Core_GlIsTexture5(void* ptr, unsigned int texture)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glIsTexture(texture);
}
char QOpenGLFunctions_4_5_Core_GlIsTransformFeedback5(void* ptr, unsigned int id)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glIsTransformFeedback(id);
}
char QOpenGLFunctions_4_5_Core_GlIsVertexArray5(void* ptr, unsigned int array)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glIsVertexArray(array);
}
char QOpenGLFunctions_4_5_Core_GlUnmapBuffer5(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUnmapBuffer(target);
}
char QOpenGLFunctions_4_5_Core_GlUnmapNamedBuffer5(void* ptr, unsigned int buffer)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUnmapNamedBuffer(buffer);
}
unsigned int QOpenGLFunctions_4_5_Core_GlCheckFramebufferStatus5(void* ptr, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCheckFramebufferStatus(target);
}
unsigned int QOpenGLFunctions_4_5_Core_GlCheckNamedFramebufferStatus5(void* ptr, unsigned int framebuffer, unsigned int target)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCheckNamedFramebufferStatus(framebuffer, target);
}
unsigned int QOpenGLFunctions_4_5_Core_GlGetError5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetError();
}
unsigned int QOpenGLFunctions_4_5_Core_GlGetGraphicsResetStatus5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetGraphicsResetStatus();
}
unsigned int QOpenGLFunctions_4_5_Core_GlCreateProgram5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCreateProgram();
}
unsigned int QOpenGLFunctions_4_5_Core_GlCreateShader5(void* ptr, unsigned int ty)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCreateShader(ty);
}
void* QOpenGLFunctions_4_5_Core_NewQOpenGLFunctions_4_5_Core5()
{
return new MyQOpenGLFunctions_4_5_Core();
}
char QOpenGLFunctions_4_5_Core_InitializeOpenGLFunctions5(void* ptr)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->initializeOpenGLFunctions();
}
char QOpenGLFunctions_4_5_Core_InitializeOpenGLFunctions5Default(void* ptr)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->QOpenGLFunctions_4_5_Core::initializeOpenGLFunctions();
}
struct QtGui_PackedString QOpenGLFunctions_4_5_Core_GlGetString5(void* ptr, unsigned int name)
{
return ({ char* t3541e9 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetString(name)))); QtGui_PackedString { t3541e9, -1 }; });
}
struct QtGui_PackedString QOpenGLFunctions_4_5_Core_GlGetStringi5(void* ptr, unsigned int name, unsigned int index)
{
return ({ char* t90e688 = static_cast<char*>(static_cast<void*>(const_cast<GLubyte*>(static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetStringi(name, index)))); QtGui_PackedString { t90e688, -1 }; });
}
void* QOpenGLFunctions_4_5_Core_GlMapBuffer5(void* ptr, unsigned int target, unsigned int access)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glMapBuffer(target, access);
}
void* QOpenGLFunctions_4_5_Core_GlMapNamedBuffer5(void* ptr, unsigned int buffer, unsigned int access)
{
return static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glMapNamedBuffer(buffer, access);
}
void QOpenGLFunctions_4_5_Core_GlActiveShaderProgram5(void* ptr, unsigned int pipeline, unsigned int program)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glActiveShaderProgram(pipeline, program);
}
void QOpenGLFunctions_4_5_Core_GlActiveTexture5(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glActiveTexture(texture);
}
void QOpenGLFunctions_4_5_Core_GlAttachShader5(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glAttachShader(program, shader);
}
void QOpenGLFunctions_4_5_Core_GlBeginConditionalRender5(void* ptr, unsigned int id, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBeginConditionalRender(id, mode);
}
void QOpenGLFunctions_4_5_Core_GlBeginQuery5(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBeginQuery(target, id);
}
void QOpenGLFunctions_4_5_Core_GlBeginQueryIndexed5(void* ptr, unsigned int target, unsigned int index, unsigned int id)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBeginQueryIndexed(target, index, id);
}
void QOpenGLFunctions_4_5_Core_GlBeginTransformFeedback5(void* ptr, unsigned int primitiveMode)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBeginTransformFeedback(primitiveMode);
}
void QOpenGLFunctions_4_5_Core_GlBindBuffer5(void* ptr, unsigned int target, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBindBuffer(target, buffer);
}
void QOpenGLFunctions_4_5_Core_GlBindBufferBase5(void* ptr, unsigned int target, unsigned int index, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBindBufferBase(target, index, buffer);
}
void QOpenGLFunctions_4_5_Core_GlBindBuffersBase5(void* ptr, unsigned int target, unsigned int first, int count, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBindBuffersBase(target, first, count, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_4_5_Core_GlBindFramebuffer5(void* ptr, unsigned int target, unsigned int framebuffer)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBindFramebuffer(target, framebuffer);
}
void QOpenGLFunctions_4_5_Core_GlBindImageTexture5(void* ptr, unsigned int unit, unsigned int texture, int level, char layered, int layer, unsigned int access, unsigned int format)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBindImageTexture(unit, texture, level, layered != 0, layer, access, format);
}
void QOpenGLFunctions_4_5_Core_GlBindImageTextures5(void* ptr, unsigned int first, int count, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBindImageTextures(first, count, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_4_5_Core_GlBindProgramPipeline5(void* ptr, unsigned int pipeline)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBindProgramPipeline(pipeline);
}
void QOpenGLFunctions_4_5_Core_GlBindRenderbuffer5(void* ptr, unsigned int target, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBindRenderbuffer(target, renderbuffer);
}
void QOpenGLFunctions_4_5_Core_GlBindSampler5(void* ptr, unsigned int unit, unsigned int sampler)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBindSampler(unit, sampler);
}
void QOpenGLFunctions_4_5_Core_GlBindSamplers5(void* ptr, unsigned int first, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBindSamplers(first, count, const_cast<const GLuint*>(&samplers));
}
void QOpenGLFunctions_4_5_Core_GlBindTexture5(void* ptr, unsigned int target, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBindTexture(target, texture);
}
void QOpenGLFunctions_4_5_Core_GlBindTextureUnit5(void* ptr, unsigned int unit, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBindTextureUnit(unit, texture);
}
void QOpenGLFunctions_4_5_Core_GlBindTextures5(void* ptr, unsigned int first, int count, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBindTextures(first, count, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_4_5_Core_GlBindTransformFeedback5(void* ptr, unsigned int target, unsigned int id)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBindTransformFeedback(target, id);
}
void QOpenGLFunctions_4_5_Core_GlBindVertexArray5(void* ptr, unsigned int array)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBindVertexArray(array);
}
void QOpenGLFunctions_4_5_Core_GlBlendColor5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBlendColor(red, green, blue, alpha);
}
void QOpenGLFunctions_4_5_Core_GlBlendEquation5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBlendEquation(mode);
}
void QOpenGLFunctions_4_5_Core_GlBlendEquationSeparate5(void* ptr, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBlendEquationSeparate(modeRGB, modeAlpha);
}
void QOpenGLFunctions_4_5_Core_GlBlendEquationSeparatei5(void* ptr, unsigned int buf, unsigned int modeRGB, unsigned int modeAlpha)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBlendEquationSeparatei(buf, modeRGB, modeAlpha);
}
void QOpenGLFunctions_4_5_Core_GlBlendEquationi5(void* ptr, unsigned int buf, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBlendEquationi(buf, mode);
}
void QOpenGLFunctions_4_5_Core_GlBlendFunc5(void* ptr, unsigned int sfactor, unsigned int dfactor)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBlendFunc(sfactor, dfactor);
}
void QOpenGLFunctions_4_5_Core_GlBlendFuncSeparate5(void* ptr, unsigned int sfactorRGB, unsigned int dfactorRGB, unsigned int sfactorAlpha, unsigned int dfactorAlpha)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void QOpenGLFunctions_4_5_Core_GlBlendFuncSeparatei5(void* ptr, unsigned int buf, unsigned int srcRGB, unsigned int dstRGB, unsigned int srcAlpha, unsigned int dstAlpha)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
void QOpenGLFunctions_4_5_Core_GlBlendFunci5(void* ptr, unsigned int buf, unsigned int src, unsigned int dst)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBlendFunci(buf, src, dst);
}
void QOpenGLFunctions_4_5_Core_GlBlitFramebuffer5(void* ptr, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, unsigned int mask, unsigned int filter)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
void QOpenGLFunctions_4_5_Core_GlBlitNamedFramebuffer5(void* ptr, unsigned int readFramebuffer, unsigned int drawFramebuffer, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, unsigned int mask, unsigned int filter)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glBlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
void QOpenGLFunctions_4_5_Core_GlClampColor5(void* ptr, unsigned int target, unsigned int clamp)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glClampColor(target, clamp);
}
void QOpenGLFunctions_4_5_Core_GlClear5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glClear(mask);
}
void QOpenGLFunctions_4_5_Core_GlClearBufferData5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glClearBufferData(target, internalformat, format, ty, data);
}
void QOpenGLFunctions_4_5_Core_GlClearBufferfi5(void* ptr, unsigned int buffer, int drawbuffer, float depth, int stencil)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glClearBufferfi(buffer, drawbuffer, depth, stencil);
}
void QOpenGLFunctions_4_5_Core_GlClearBufferfv5(void* ptr, unsigned int buffer, int drawbuffer, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glClearBufferfv(buffer, drawbuffer, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlClearBufferiv5(void* ptr, unsigned int buffer, int drawbuffer, int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glClearBufferiv(buffer, drawbuffer, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlClearBufferuiv5(void* ptr, unsigned int buffer, int drawbuffer, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glClearBufferuiv(buffer, drawbuffer, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlClearColor5(void* ptr, float red, float green, float blue, float alpha)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glClearColor(red, green, blue, alpha);
}
void QOpenGLFunctions_4_5_Core_GlClearDepthf5(void* ptr, float dd)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glClearDepthf(dd);
}
void QOpenGLFunctions_4_5_Core_GlClearNamedBufferData5(void* ptr, unsigned int buffer, unsigned int internalformat, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glClearNamedBufferData(buffer, internalformat, format, ty, data);
}
void QOpenGLFunctions_4_5_Core_GlClearNamedFramebufferfi5(void* ptr, unsigned int framebuffer, unsigned int buffer, float depth, int stencil)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glClearNamedFramebufferfi(framebuffer, buffer, depth, stencil);
}
void QOpenGLFunctions_4_5_Core_GlClearNamedFramebufferfv5(void* ptr, unsigned int framebuffer, unsigned int buffer, int drawbuffer, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glClearNamedFramebufferfv(framebuffer, buffer, drawbuffer, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlClearNamedFramebufferiv5(void* ptr, unsigned int framebuffer, unsigned int buffer, int drawbuffer, int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glClearNamedFramebufferiv(framebuffer, buffer, drawbuffer, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlClearNamedFramebufferuiv5(void* ptr, unsigned int framebuffer, unsigned int buffer, int drawbuffer, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glClearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlClearStencil5(void* ptr, int s)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glClearStencil(s);
}
void QOpenGLFunctions_4_5_Core_GlClearTexImage5(void* ptr, unsigned int texture, int level, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glClearTexImage(texture, level, format, ty, data);
}
void QOpenGLFunctions_4_5_Core_GlClearTexSubImage5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* data)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, data);
}
void QOpenGLFunctions_4_5_Core_GlClipControl5(void* ptr, unsigned int origin, unsigned int depth)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glClipControl(origin, depth);
}
void QOpenGLFunctions_4_5_Core_GlColorMask5(void* ptr, char red, char green, char blue, char alpha)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glColorMask(red != 0, green != 0, blue != 0, alpha != 0);
}
void QOpenGLFunctions_4_5_Core_GlColorMaski5(void* ptr, unsigned int index, char r, char g, char b, char a)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glColorMaski(index, r != 0, g != 0, b != 0, a != 0);
}
void QOpenGLFunctions_4_5_Core_GlCompileShader5(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCompileShader(shader);
}
void QOpenGLFunctions_4_5_Core_GlCompressedTexImage1D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
void QOpenGLFunctions_4_5_Core_GlCompressedTexImage2D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void QOpenGLFunctions_4_5_Core_GlCompressedTexImage3D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int width, int height, int depth, int border, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void QOpenGLFunctions_4_5_Core_GlCompressedTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_4_5_Core_GlCompressedTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_4_5_Core_GlCompressedTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_4_5_Core_GlCompressedTextureSubImage1D5(void* ptr, unsigned int texture, int level, int xoffset, int width, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data);
}
void QOpenGLFunctions_4_5_Core_GlCompressedTextureSubImage2D5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int width, int height, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void QOpenGLFunctions_4_5_Core_GlCompressedTextureSubImage3D5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, int imageSize, void* data)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void QOpenGLFunctions_4_5_Core_GlCopyImageSubData5(void* ptr, unsigned int srcName, unsigned int srcTarget, int srcLevel, int srcX, int srcY, int srcZ, unsigned int dstName, unsigned int dstTarget, int dstLevel, int dstX, int dstY, int dstZ, int srcWidth, int srcHeight, int srcDepth)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
}
void QOpenGLFunctions_4_5_Core_GlCopyTexImage1D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int border)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
void QOpenGLFunctions_4_5_Core_GlCopyTexImage2D5(void* ptr, unsigned int target, int level, unsigned int internalformat, int x, int y, int width, int height, int border)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void QOpenGLFunctions_4_5_Core_GlCopyTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
void QOpenGLFunctions_4_5_Core_GlCopyTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_4_5_Core_GlCopyTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_4_5_Core_GlCopyTextureSubImage1D5(void* ptr, unsigned int texture, int level, int xoffset, int x, int y, int width)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCopyTextureSubImage1D(texture, level, xoffset, x, y, width);
}
void QOpenGLFunctions_4_5_Core_GlCopyTextureSubImage2D5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height);
}
void QOpenGLFunctions_4_5_Core_GlCopyTextureSubImage3D5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void QOpenGLFunctions_4_5_Core_GlCreateBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCreateBuffers(n, &buffers);
}
void QOpenGLFunctions_4_5_Core_GlCreateFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCreateFramebuffers(n, &framebuffers);
}
void QOpenGLFunctions_4_5_Core_GlCreateProgramPipelines5(void* ptr, int n, unsigned int pipelines)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCreateProgramPipelines(n, &pipelines);
}
void QOpenGLFunctions_4_5_Core_GlCreateQueries5(void* ptr, unsigned int target, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCreateQueries(target, n, &ids);
}
void QOpenGLFunctions_4_5_Core_GlCreateRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCreateRenderbuffers(n, &renderbuffers);
}
void QOpenGLFunctions_4_5_Core_GlCreateSamplers5(void* ptr, int n, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCreateSamplers(n, &samplers);
}
void QOpenGLFunctions_4_5_Core_GlCreateTextures5(void* ptr, unsigned int target, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCreateTextures(target, n, &textures);
}
void QOpenGLFunctions_4_5_Core_GlCreateTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCreateTransformFeedbacks(n, &ids);
}
void QOpenGLFunctions_4_5_Core_GlCreateVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCreateVertexArrays(n, &arrays);
}
void QOpenGLFunctions_4_5_Core_GlCullFace5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glCullFace(mode);
}
void QOpenGLFunctions_4_5_Core_GlDebugMessageControl5(void* ptr, unsigned int source, unsigned int ty, unsigned int severity, int count, unsigned int ids, char enabled)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDebugMessageControl(source, ty, severity, count, const_cast<const GLuint*>(&ids), enabled != 0);
}
void QOpenGLFunctions_4_5_Core_GlDeleteBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDeleteBuffers(n, const_cast<const GLuint*>(&buffers));
}
void QOpenGLFunctions_4_5_Core_GlDeleteFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDeleteFramebuffers(n, const_cast<const GLuint*>(&framebuffers));
}
void QOpenGLFunctions_4_5_Core_GlDeleteProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDeleteProgram(program);
}
void QOpenGLFunctions_4_5_Core_GlDeleteProgramPipelines5(void* ptr, int n, unsigned int pipelines)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDeleteProgramPipelines(n, const_cast<const GLuint*>(&pipelines));
}
void QOpenGLFunctions_4_5_Core_GlDeleteQueries5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDeleteQueries(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_4_5_Core_GlDeleteRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDeleteRenderbuffers(n, const_cast<const GLuint*>(&renderbuffers));
}
void QOpenGLFunctions_4_5_Core_GlDeleteSamplers5(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDeleteSamplers(count, const_cast<const GLuint*>(&samplers));
}
void QOpenGLFunctions_4_5_Core_GlDeleteShader5(void* ptr, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDeleteShader(shader);
}
void QOpenGLFunctions_4_5_Core_GlDeleteTextures5(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDeleteTextures(n, const_cast<const GLuint*>(&textures));
}
void QOpenGLFunctions_4_5_Core_GlDeleteTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDeleteTransformFeedbacks(n, const_cast<const GLuint*>(&ids));
}
void QOpenGLFunctions_4_5_Core_GlDeleteVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDeleteVertexArrays(n, const_cast<const GLuint*>(&arrays));
}
void QOpenGLFunctions_4_5_Core_GlDepthFunc5(void* ptr, unsigned int fu)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDepthFunc(fu);
}
void QOpenGLFunctions_4_5_Core_GlDepthMask5(void* ptr, char flag)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_4_5_Core_GlDepthRangef5(void* ptr, float n, float fo)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDepthRangef(n, fo);
}
void QOpenGLFunctions_4_5_Core_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDetachShader(program, shader);
}
void QOpenGLFunctions_4_5_Core_GlDisable5(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDisable(cap);
}
void QOpenGLFunctions_4_5_Core_GlDisableVertexArrayAttrib5(void* ptr, unsigned int vaobj, unsigned int index)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDisableVertexArrayAttrib(vaobj, index);
}
void QOpenGLFunctions_4_5_Core_GlDisableVertexAttribArray5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDisableVertexAttribArray(index);
}
void QOpenGLFunctions_4_5_Core_GlDisablei5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDisablei(target, index);
}
void QOpenGLFunctions_4_5_Core_GlDispatchCompute5(void* ptr, unsigned int num_groups_x, unsigned int num_groups_y, unsigned int num_groups_z)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
}
void QOpenGLFunctions_4_5_Core_GlDrawArrays5(void* ptr, unsigned int mode, int first, int count)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDrawArrays(mode, first, count);
}
void QOpenGLFunctions_4_5_Core_GlDrawArraysIndirect5(void* ptr, unsigned int mode, void* indirect)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDrawArraysIndirect(mode, indirect);
}
void QOpenGLFunctions_4_5_Core_GlDrawArraysInstanced5(void* ptr, unsigned int mode, int first, int count, int instancecount)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDrawArraysInstanced(mode, first, count, instancecount);
}
void QOpenGLFunctions_4_5_Core_GlDrawArraysInstancedBaseInstance5(void* ptr, unsigned int mode, int first, int count, int instancecount, unsigned int baseinstance)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
}
void QOpenGLFunctions_4_5_Core_GlDrawBuffer5(void* ptr, unsigned int buf)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDrawBuffer(buf);
}
void QOpenGLFunctions_4_5_Core_GlDrawBuffers5(void* ptr, int n, unsigned int bufs)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDrawBuffers(n, const_cast<const GLenum*>(&bufs));
}
void QOpenGLFunctions_4_5_Core_GlDrawElements5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDrawElements(mode, count, ty, indices);
}
void QOpenGLFunctions_4_5_Core_GlDrawElementsBaseVertex5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDrawElementsBaseVertex(mode, count, ty, indices, basevertex);
}
void QOpenGLFunctions_4_5_Core_GlDrawElementsIndirect5(void* ptr, unsigned int mode, unsigned int ty, void* indirect)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDrawElementsIndirect(mode, ty, indirect);
}
void QOpenGLFunctions_4_5_Core_GlDrawElementsInstanced5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDrawElementsInstanced(mode, count, ty, indices, instancecount);
}
void QOpenGLFunctions_4_5_Core_GlDrawElementsInstancedBaseInstance5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, unsigned int baseinstance)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDrawElementsInstancedBaseInstance(mode, count, ty, indices, instancecount, baseinstance);
}
void QOpenGLFunctions_4_5_Core_GlDrawElementsInstancedBaseVertex5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDrawElementsInstancedBaseVertex(mode, count, ty, indices, instancecount, basevertex);
}
void QOpenGLFunctions_4_5_Core_GlDrawElementsInstancedBaseVertexBaseInstance5(void* ptr, unsigned int mode, int count, unsigned int ty, void* indices, int instancecount, int basevertex, unsigned int baseinstance)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDrawElementsInstancedBaseVertexBaseInstance(mode, count, ty, indices, instancecount, basevertex, baseinstance);
}
void QOpenGLFunctions_4_5_Core_GlDrawRangeElements5(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDrawRangeElements(mode, start, end, count, ty, indices);
}
void QOpenGLFunctions_4_5_Core_GlDrawRangeElementsBaseVertex5(void* ptr, unsigned int mode, unsigned int start, unsigned int end, int count, unsigned int ty, void* indices, int basevertex)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDrawRangeElementsBaseVertex(mode, start, end, count, ty, indices, basevertex);
}
void QOpenGLFunctions_4_5_Core_GlDrawTransformFeedback5(void* ptr, unsigned int mode, unsigned int id)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDrawTransformFeedback(mode, id);
}
void QOpenGLFunctions_4_5_Core_GlDrawTransformFeedbackInstanced5(void* ptr, unsigned int mode, unsigned int id, int instancecount)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDrawTransformFeedbackInstanced(mode, id, instancecount);
}
void QOpenGLFunctions_4_5_Core_GlDrawTransformFeedbackStream5(void* ptr, unsigned int mode, unsigned int id, unsigned int stream)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDrawTransformFeedbackStream(mode, id, stream);
}
void QOpenGLFunctions_4_5_Core_GlDrawTransformFeedbackStreamInstanced5(void* ptr, unsigned int mode, unsigned int id, unsigned int stream, int instancecount)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
}
void QOpenGLFunctions_4_5_Core_GlEnable5(void* ptr, unsigned int cap)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glEnable(cap);
}
void QOpenGLFunctions_4_5_Core_GlEnableVertexArrayAttrib5(void* ptr, unsigned int vaobj, unsigned int index)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glEnableVertexArrayAttrib(vaobj, index);
}
void QOpenGLFunctions_4_5_Core_GlEnableVertexAttribArray5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glEnableVertexAttribArray(index);
}
void QOpenGLFunctions_4_5_Core_GlEnablei5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glEnablei(target, index);
}
void QOpenGLFunctions_4_5_Core_GlEndConditionalRender5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glEndConditionalRender();
}
void QOpenGLFunctions_4_5_Core_GlEndQuery5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glEndQuery(target);
}
void QOpenGLFunctions_4_5_Core_GlEndQueryIndexed5(void* ptr, unsigned int target, unsigned int index)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glEndQueryIndexed(target, index);
}
void QOpenGLFunctions_4_5_Core_GlEndTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glEndTransformFeedback();
}
void QOpenGLFunctions_4_5_Core_GlFinish5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glFinish();
}
void QOpenGLFunctions_4_5_Core_GlFlush5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glFlush();
}
void QOpenGLFunctions_4_5_Core_GlFramebufferParameteri5(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glFramebufferParameteri(target, pname, param);
}
void QOpenGLFunctions_4_5_Core_GlFramebufferRenderbuffer5(void* ptr, unsigned int target, unsigned int attachment, unsigned int renderbuffertarget, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
void QOpenGLFunctions_4_5_Core_GlFramebufferTexture5(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glFramebufferTexture(target, attachment, texture, level);
}
void QOpenGLFunctions_4_5_Core_GlFramebufferTexture1D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glFramebufferTexture1D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_4_5_Core_GlFramebufferTexture2D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
void QOpenGLFunctions_4_5_Core_GlFramebufferTexture3D5(void* ptr, unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level, int zoffset)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}
void QOpenGLFunctions_4_5_Core_GlFramebufferTextureLayer5(void* ptr, unsigned int target, unsigned int attachment, unsigned int texture, int level, int layer)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glFramebufferTextureLayer(target, attachment, texture, level, layer);
}
void QOpenGLFunctions_4_5_Core_GlFrontFace5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glFrontFace(mode);
}
void QOpenGLFunctions_4_5_Core_GlGenBuffers5(void* ptr, int n, unsigned int buffers)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGenBuffers(n, &buffers);
}
void QOpenGLFunctions_4_5_Core_GlGenFramebuffers5(void* ptr, int n, unsigned int framebuffers)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGenFramebuffers(n, &framebuffers);
}
void QOpenGLFunctions_4_5_Core_GlGenProgramPipelines5(void* ptr, int n, unsigned int pipelines)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGenProgramPipelines(n, &pipelines);
}
void QOpenGLFunctions_4_5_Core_GlGenQueries5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGenQueries(n, &ids);
}
void QOpenGLFunctions_4_5_Core_GlGenRenderbuffers5(void* ptr, int n, unsigned int renderbuffers)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGenRenderbuffers(n, &renderbuffers);
}
void QOpenGLFunctions_4_5_Core_GlGenSamplers5(void* ptr, int count, unsigned int samplers)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGenSamplers(count, &samplers);
}
void QOpenGLFunctions_4_5_Core_GlGenTextures5(void* ptr, int n, unsigned int textures)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGenTextures(n, &textures);
}
void QOpenGLFunctions_4_5_Core_GlGenTransformFeedbacks5(void* ptr, int n, unsigned int ids)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGenTransformFeedbacks(n, &ids);
}
void QOpenGLFunctions_4_5_Core_GlGenVertexArrays5(void* ptr, int n, unsigned int arrays)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGenVertexArrays(n, &arrays);
}
void QOpenGLFunctions_4_5_Core_GlGenerateMipmap5(void* ptr, unsigned int target)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGenerateMipmap(target);
}
void QOpenGLFunctions_4_5_Core_GlGenerateTextureMipmap5(void* ptr, unsigned int texture)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGenerateTextureMipmap(texture);
}
void QOpenGLFunctions_4_5_Core_GlGetActiveAtomicCounterBufferiv5(void* ptr, unsigned int program, unsigned int bufferIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetActiveAtomicCounterBufferiv(program, bufferIndex, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetActiveSubroutineUniformiv5(void* ptr, unsigned int program, unsigned int shadertype, unsigned int index, unsigned int pname, int values)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetActiveSubroutineUniformiv(program, shadertype, index, pname, &values);
}
void QOpenGLFunctions_4_5_Core_GlGetActiveUniformBlockiv5(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetActiveUniformsiv5(void* ptr, unsigned int program, int uniformCount, unsigned int uniformIndices, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetActiveUniformsiv(program, uniformCount, const_cast<const GLuint*>(&uniformIndices), pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetAttachedShaders5(void* ptr, unsigned int program, int maxCount, int count, unsigned int shaders)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetAttachedShaders(program, maxCount, &count, &shaders);
}
void QOpenGLFunctions_4_5_Core_GlGetBooleani_v5(void* ptr, unsigned int target, unsigned int index, char data)
{
Q_UNUSED(data);
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetBooleani_v(target, index, NULL);
}
void QOpenGLFunctions_4_5_Core_GlGetBooleanv5(void* ptr, unsigned int pname, char data)
{
Q_UNUSED(data);
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetBooleanv(pname, NULL);
}
void QOpenGLFunctions_4_5_Core_GlGetBufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetBufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetBufferPointerv5(void* ptr, unsigned int target, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetBufferPointerv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetCompressedTexImage5(void* ptr, unsigned int target, int level, void* img)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetCompressedTexImage(target, level, img);
}
void QOpenGLFunctions_4_5_Core_GlGetCompressedTextureImage5(void* ptr, unsigned int texture, int level, int bufSize, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetCompressedTextureImage(texture, level, bufSize, pixels);
}
void QOpenGLFunctions_4_5_Core_GlGetCompressedTextureSubImage5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, int bufSize, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);
}
void QOpenGLFunctions_4_5_Core_GlGetFloati_v5(void* ptr, unsigned int target, unsigned int index, float data)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetFloati_v(target, index, &data);
}
void QOpenGLFunctions_4_5_Core_GlGetFloatv5(void* ptr, unsigned int pname, float data)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetFloatv(pname, &data);
}
void QOpenGLFunctions_4_5_Core_GlGetFramebufferAttachmentParameteriv5(void* ptr, unsigned int target, unsigned int attachment, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetFramebufferAttachmentParameteriv(target, attachment, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetFramebufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetFramebufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetIntegeri_v5(void* ptr, unsigned int target, unsigned int index, int data)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetIntegeri_v(target, index, &data);
}
void QOpenGLFunctions_4_5_Core_GlGetIntegerv5(void* ptr, unsigned int pname, int data)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetIntegerv(pname, &data);
}
void QOpenGLFunctions_4_5_Core_GlGetInternalformativ5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int pname, int bufSize, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetInternalformativ(target, internalformat, pname, bufSize, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetMultisamplefv5(void* ptr, unsigned int pname, unsigned int index, float val)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetMultisamplefv(pname, index, &val);
}
void QOpenGLFunctions_4_5_Core_GlGetNamedBufferParameteriv5(void* ptr, unsigned int buffer, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetNamedBufferParameteriv(buffer, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetNamedBufferPointerv5(void* ptr, unsigned int buffer, unsigned int pname, void* params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetNamedBufferPointerv(buffer, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetNamedFramebufferAttachmentParameteriv5(void* ptr, unsigned int framebuffer, unsigned int attachment, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetNamedFramebufferParameteriv5(void* ptr, unsigned int framebuffer, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetNamedFramebufferParameteriv(framebuffer, pname, &param);
}
void QOpenGLFunctions_4_5_Core_GlGetNamedRenderbufferParameteriv5(void* ptr, unsigned int renderbuffer, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetNamedRenderbufferParameteriv(renderbuffer, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetProgramBinary5(void* ptr, unsigned int program, int bufSize, int length, unsigned int binaryFormat, void* binary)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetProgramBinary(program, bufSize, &length, &binaryFormat, binary);
}
void QOpenGLFunctions_4_5_Core_GlGetProgramInterfaceiv5(void* ptr, unsigned int program, unsigned int programInterface, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetProgramInterfaceiv(program, programInterface, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetProgramPipelineiv5(void* ptr, unsigned int pipeline, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetProgramPipelineiv(pipeline, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetProgramResourceiv5(void* ptr, unsigned int program, unsigned int programInterface, unsigned int index, int propCount, unsigned int props, int bufSize, int length, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetProgramResourceiv(program, programInterface, index, propCount, const_cast<const GLenum*>(&props), bufSize, &length, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetProgramStageiv5(void* ptr, unsigned int program, unsigned int shadertype, unsigned int pname, int values)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetProgramStageiv(program, shadertype, pname, &values);
}
void QOpenGLFunctions_4_5_Core_GlGetProgramiv5(void* ptr, unsigned int program, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetProgramiv(program, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetQueryIndexediv5(void* ptr, unsigned int target, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetQueryIndexediv(target, index, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetQueryObjectiv5(void* ptr, unsigned int id, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetQueryObjectiv(id, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetQueryObjectuiv5(void* ptr, unsigned int id, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetQueryObjectuiv(id, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetQueryiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetQueryiv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetRenderbufferParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetRenderbufferParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetSamplerParameterIiv5(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetSamplerParameterIiv(sampler, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetSamplerParameterIuiv5(void* ptr, unsigned int sampler, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetSamplerParameterIuiv(sampler, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetSamplerParameterfv5(void* ptr, unsigned int sampler, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetSamplerParameterfv(sampler, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetSamplerParameteriv5(void* ptr, unsigned int sampler, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetSamplerParameteriv(sampler, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetShaderPrecisionFormat5(void* ptr, unsigned int shadertype, unsigned int precisiontype, int ran, int precision)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetShaderPrecisionFormat(shadertype, precisiontype, &ran, &precision);
}
void QOpenGLFunctions_4_5_Core_GlGetShaderiv5(void* ptr, unsigned int shader, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetShaderiv(shader, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetTexImage5(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetTexImage(target, level, format, ty, pixels);
}
void QOpenGLFunctions_4_5_Core_GlGetTexLevelParameterfv5(void* ptr, unsigned int target, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetTexLevelParameterfv(target, level, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetTexLevelParameteriv5(void* ptr, unsigned int target, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetTexLevelParameteriv(target, level, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetTexParameterIiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetTexParameterIiv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetTexParameterIuiv5(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetTexParameterIuiv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetTexParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetTexParameterfv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetTexParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetTexParameteriv(target, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetTextureImage5(void* ptr, unsigned int texture, int level, unsigned int format, unsigned int ty, int bufSize, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetTextureImage(texture, level, format, ty, bufSize, pixels);
}
void QOpenGLFunctions_4_5_Core_GlGetTextureLevelParameterfv5(void* ptr, unsigned int texture, int level, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetTextureLevelParameterfv(texture, level, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetTextureLevelParameteriv5(void* ptr, unsigned int texture, int level, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetTextureLevelParameteriv(texture, level, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetTextureParameterIiv5(void* ptr, unsigned int texture, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetTextureParameterIiv(texture, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetTextureParameterIuiv5(void* ptr, unsigned int texture, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetTextureParameterIuiv(texture, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetTextureParameterfv5(void* ptr, unsigned int texture, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetTextureParameterfv(texture, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetTextureParameteriv5(void* ptr, unsigned int texture, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetTextureParameteriv(texture, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetTextureSubImage5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, int bufSize, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, bufSize, pixels);
}
void QOpenGLFunctions_4_5_Core_GlGetTransformFeedbacki_v5(void* ptr, unsigned int xfb, unsigned int pname, unsigned int index, int param)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetTransformFeedbacki_v(xfb, pname, index, &param);
}
void QOpenGLFunctions_4_5_Core_GlGetTransformFeedbackiv5(void* ptr, unsigned int xfb, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetTransformFeedbackiv(xfb, pname, &param);
}
void QOpenGLFunctions_4_5_Core_GlGetUniformSubroutineuiv5(void* ptr, unsigned int shadertype, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetUniformSubroutineuiv(shadertype, location, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetUniformfv5(void* ptr, unsigned int program, int location, float params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetUniformfv(program, location, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetUniformiv5(void* ptr, unsigned int program, int location, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetUniformiv(program, location, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetUniformuiv5(void* ptr, unsigned int program, int location, unsigned int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetUniformuiv(program, location, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetVertexArrayIndexediv5(void* ptr, unsigned int vaobj, unsigned int index, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetVertexArrayIndexediv(vaobj, index, pname, &param);
}
void QOpenGLFunctions_4_5_Core_GlGetVertexArrayiv5(void* ptr, unsigned int vaobj, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetVertexArrayiv(vaobj, pname, &param);
}
void QOpenGLFunctions_4_5_Core_GlGetVertexAttribIiv5(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetVertexAttribIiv(index, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetVertexAttribIuiv5(void* ptr, unsigned int index, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetVertexAttribIuiv(index, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetVertexAttribPointerv5(void* ptr, unsigned int index, unsigned int pname, void* pointer)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetVertexAttribPointerv(index, pname, &pointer);
}
void QOpenGLFunctions_4_5_Core_GlGetVertexAttribfv5(void* ptr, unsigned int index, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetVertexAttribfv(index, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetVertexAttribiv5(void* ptr, unsigned int index, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetVertexAttribiv(index, pname, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetnCompressedTexImage5(void* ptr, unsigned int target, int lod, int bufSize, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetnCompressedTexImage(target, lod, bufSize, pixels);
}
void QOpenGLFunctions_4_5_Core_GlGetnTexImage5(void* ptr, unsigned int target, int level, unsigned int format, unsigned int ty, int bufSize, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetnTexImage(target, level, format, ty, bufSize, pixels);
}
void QOpenGLFunctions_4_5_Core_GlGetnUniformfv5(void* ptr, unsigned int program, int location, int bufSize, float params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetnUniformfv(program, location, bufSize, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetnUniformiv5(void* ptr, unsigned int program, int location, int bufSize, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetnUniformiv(program, location, bufSize, &params);
}
void QOpenGLFunctions_4_5_Core_GlGetnUniformuiv5(void* ptr, unsigned int program, int location, int bufSize, unsigned int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glGetnUniformuiv(program, location, bufSize, &params);
}
void QOpenGLFunctions_4_5_Core_GlHint5(void* ptr, unsigned int target, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glHint(target, mode);
}
void QOpenGLFunctions_4_5_Core_GlInvalidateBufferData5(void* ptr, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glInvalidateBufferData(buffer);
}
void QOpenGLFunctions_4_5_Core_GlInvalidateFramebuffer5(void* ptr, unsigned int target, int numAttachments, unsigned int attachments)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glInvalidateFramebuffer(target, numAttachments, const_cast<const GLenum*>(&attachments));
}
void QOpenGLFunctions_4_5_Core_GlInvalidateNamedFramebufferData5(void* ptr, unsigned int framebuffer, int numAttachments, unsigned int attachments)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glInvalidateNamedFramebufferData(framebuffer, numAttachments, const_cast<const GLenum*>(&attachments));
}
void QOpenGLFunctions_4_5_Core_GlInvalidateNamedFramebufferSubData5(void* ptr, unsigned int framebuffer, int numAttachments, unsigned int attachments, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glInvalidateNamedFramebufferSubData(framebuffer, numAttachments, const_cast<const GLenum*>(&attachments), x, y, width, height);
}
void QOpenGLFunctions_4_5_Core_GlInvalidateSubFramebuffer5(void* ptr, unsigned int target, int numAttachments, unsigned int attachments, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glInvalidateSubFramebuffer(target, numAttachments, const_cast<const GLenum*>(&attachments), x, y, width, height);
}
void QOpenGLFunctions_4_5_Core_GlInvalidateTexImage5(void* ptr, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glInvalidateTexImage(texture, level);
}
void QOpenGLFunctions_4_5_Core_GlInvalidateTexSubImage5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glInvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
}
void QOpenGLFunctions_4_5_Core_GlLineWidth5(void* ptr, float width)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glLineWidth(width);
}
void QOpenGLFunctions_4_5_Core_GlLinkProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glLinkProgram(program);
}
void QOpenGLFunctions_4_5_Core_GlLogicOp5(void* ptr, unsigned int opcode)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glLogicOp(opcode);
}
void QOpenGLFunctions_4_5_Core_GlMemoryBarrier5(void* ptr, unsigned int barriers)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glMemoryBarrier(barriers);
}
void QOpenGLFunctions_4_5_Core_GlMemoryBarrierByRegion5(void* ptr, unsigned int barriers)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glMemoryBarrierByRegion(barriers);
}
void QOpenGLFunctions_4_5_Core_GlMinSampleShading5(void* ptr, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glMinSampleShading(value);
}
void QOpenGLFunctions_4_5_Core_GlMultiDrawArrays5(void* ptr, unsigned int mode, int first, int count, int drawcount)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glMultiDrawArrays(mode, const_cast<const GLint*>(&first), const_cast<const GLsizei*>(&count), drawcount);
}
void QOpenGLFunctions_4_5_Core_GlMultiDrawArraysIndirect5(void* ptr, unsigned int mode, void* indirect, int drawcount, int stride)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glMultiDrawArraysIndirect(mode, indirect, drawcount, stride);
}
void QOpenGLFunctions_4_5_Core_GlMultiDrawElementsIndirect5(void* ptr, unsigned int mode, unsigned int ty, void* indirect, int drawcount, int stride)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glMultiDrawElementsIndirect(mode, ty, indirect, drawcount, stride);
}
void QOpenGLFunctions_4_5_Core_GlNamedBufferData5(void* ptr, unsigned int buffer, int size, void* data, unsigned int usage)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glNamedBufferData(buffer, size, data, usage);
}
void QOpenGLFunctions_4_5_Core_GlNamedBufferStorage5(void* ptr, unsigned int buffer, int size, void* data, unsigned int flags)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glNamedBufferStorage(buffer, size, data, flags);
}
void QOpenGLFunctions_4_5_Core_GlNamedFramebufferDrawBuffer5(void* ptr, unsigned int framebuffer, unsigned int buf)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glNamedFramebufferDrawBuffer(framebuffer, buf);
}
void QOpenGLFunctions_4_5_Core_GlNamedFramebufferDrawBuffers5(void* ptr, unsigned int framebuffer, int n, unsigned int bufs)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glNamedFramebufferDrawBuffers(framebuffer, n, const_cast<const GLenum*>(&bufs));
}
void QOpenGLFunctions_4_5_Core_GlNamedFramebufferParameteri5(void* ptr, unsigned int framebuffer, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glNamedFramebufferParameteri(framebuffer, pname, param);
}
void QOpenGLFunctions_4_5_Core_GlNamedFramebufferReadBuffer5(void* ptr, unsigned int framebuffer, unsigned int src)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glNamedFramebufferReadBuffer(framebuffer, src);
}
void QOpenGLFunctions_4_5_Core_GlNamedFramebufferRenderbuffer5(void* ptr, unsigned int framebuffer, unsigned int attachment, unsigned int renderbuffertarget, unsigned int renderbuffer)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glNamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer);
}
void QOpenGLFunctions_4_5_Core_GlNamedFramebufferTexture5(void* ptr, unsigned int framebuffer, unsigned int attachment, unsigned int texture, int level)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glNamedFramebufferTexture(framebuffer, attachment, texture, level);
}
void QOpenGLFunctions_4_5_Core_GlNamedFramebufferTextureLayer5(void* ptr, unsigned int framebuffer, unsigned int attachment, unsigned int texture, int level, int layer)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glNamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer);
}
void QOpenGLFunctions_4_5_Core_GlNamedRenderbufferStorage5(void* ptr, unsigned int renderbuffer, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glNamedRenderbufferStorage(renderbuffer, internalformat, width, height);
}
void QOpenGLFunctions_4_5_Core_GlNamedRenderbufferStorageMultisample5(void* ptr, unsigned int renderbuffer, int samples, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glNamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height);
}
void QOpenGLFunctions_4_5_Core_GlPatchParameterfv5(void* ptr, unsigned int pname, float values)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glPatchParameterfv(pname, const_cast<const GLfloat*>(&values));
}
void QOpenGLFunctions_4_5_Core_GlPatchParameteri5(void* ptr, unsigned int pname, int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glPatchParameteri(pname, value);
}
void QOpenGLFunctions_4_5_Core_GlPauseTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glPauseTransformFeedback();
}
void QOpenGLFunctions_4_5_Core_GlPixelStoref5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glPixelStoref(pname, param);
}
void QOpenGLFunctions_4_5_Core_GlPixelStorei5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glPixelStorei(pname, param);
}
void QOpenGLFunctions_4_5_Core_GlPointParameterf5(void* ptr, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glPointParameterf(pname, param);
}
void QOpenGLFunctions_4_5_Core_GlPointParameterfv5(void* ptr, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glPointParameterfv(pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_5_Core_GlPointParameteri5(void* ptr, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glPointParameteri(pname, param);
}
void QOpenGLFunctions_4_5_Core_GlPointParameteriv5(void* ptr, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glPointParameteriv(pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_5_Core_GlPointSize5(void* ptr, float size)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glPointSize(size);
}
void QOpenGLFunctions_4_5_Core_GlPolygonMode5(void* ptr, unsigned int face, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glPolygonMode(face, mode);
}
void QOpenGLFunctions_4_5_Core_GlPolygonOffset5(void* ptr, float factor, float units)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glPolygonOffset(factor, units);
}
void QOpenGLFunctions_4_5_Core_GlPopDebugGroup5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glPopDebugGroup();
}
void QOpenGLFunctions_4_5_Core_GlPrimitiveRestartIndex5(void* ptr, unsigned int index)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glPrimitiveRestartIndex(index);
}
void QOpenGLFunctions_4_5_Core_GlProgramBinary5(void* ptr, unsigned int program, unsigned int binaryFormat, void* binary, int length)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramBinary(program, binaryFormat, binary, length);
}
void QOpenGLFunctions_4_5_Core_GlProgramParameteri5(void* ptr, unsigned int program, unsigned int pname, int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramParameteri(program, pname, value);
}
void QOpenGLFunctions_4_5_Core_GlProgramUniform1f5(void* ptr, unsigned int program, int location, float v0)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniform1f(program, location, v0);
}
void QOpenGLFunctions_4_5_Core_GlProgramUniform1fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniform1fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlProgramUniform1i5(void* ptr, unsigned int program, int location, int v0)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniform1i(program, location, v0);
}
void QOpenGLFunctions_4_5_Core_GlProgramUniform1iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniform1iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlProgramUniform1ui5(void* ptr, unsigned int program, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniform1ui(program, location, v0);
}
void QOpenGLFunctions_4_5_Core_GlProgramUniform1uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniform1uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlProgramUniform2f5(void* ptr, unsigned int program, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniform2f(program, location, v0, v1);
}
void QOpenGLFunctions_4_5_Core_GlProgramUniform2fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniform2fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlProgramUniform2i5(void* ptr, unsigned int program, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniform2i(program, location, v0, v1);
}
void QOpenGLFunctions_4_5_Core_GlProgramUniform2iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniform2iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlProgramUniform2ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniform2ui(program, location, v0, v1);
}
void QOpenGLFunctions_4_5_Core_GlProgramUniform2uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniform2uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlProgramUniform3f5(void* ptr, unsigned int program, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniform3f(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_5_Core_GlProgramUniform3fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniform3fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlProgramUniform3i5(void* ptr, unsigned int program, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniform3i(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_5_Core_GlProgramUniform3iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniform3iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlProgramUniform3ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniform3ui(program, location, v0, v1, v2);
}
void QOpenGLFunctions_4_5_Core_GlProgramUniform3uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniform3uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlProgramUniform4f5(void* ptr, unsigned int program, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniform4f(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_5_Core_GlProgramUniform4fv5(void* ptr, unsigned int program, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniform4fv(program, location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlProgramUniform4i5(void* ptr, unsigned int program, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniform4i(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_5_Core_GlProgramUniform4iv5(void* ptr, unsigned int program, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniform4iv(program, location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlProgramUniform4ui5(void* ptr, unsigned int program, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniform4ui(program, location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_5_Core_GlProgramUniform4uiv5(void* ptr, unsigned int program, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniform4uiv(program, location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlProgramUniformMatrix2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniformMatrix2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlProgramUniformMatrix2x3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniformMatrix2x3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlProgramUniformMatrix2x4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniformMatrix2x4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlProgramUniformMatrix3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniformMatrix3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlProgramUniformMatrix3x2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniformMatrix3x2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlProgramUniformMatrix3x4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniformMatrix3x4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlProgramUniformMatrix4fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniformMatrix4fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlProgramUniformMatrix4x2fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniformMatrix4x2fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlProgramUniformMatrix4x3fv5(void* ptr, unsigned int program, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProgramUniformMatrix4x3fv(program, location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlProvokingVertex5(void* ptr, unsigned int mode)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glProvokingVertex(mode);
}
void QOpenGLFunctions_4_5_Core_GlQueryCounter5(void* ptr, unsigned int id, unsigned int target)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glQueryCounter(id, target);
}
void QOpenGLFunctions_4_5_Core_GlReadBuffer5(void* ptr, unsigned int src)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glReadBuffer(src);
}
void QOpenGLFunctions_4_5_Core_GlReadPixels5(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glReadPixels(x, y, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_5_Core_GlReadnPixels5(void* ptr, int x, int y, int width, int height, unsigned int format, unsigned int ty, int bufSize, void* data)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glReadnPixels(x, y, width, height, format, ty, bufSize, data);
}
void QOpenGLFunctions_4_5_Core_GlReleaseShaderCompiler5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glReleaseShaderCompiler();
}
void QOpenGLFunctions_4_5_Core_GlRenderbufferStorage5(void* ptr, unsigned int target, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glRenderbufferStorage(target, internalformat, width, height);
}
void QOpenGLFunctions_4_5_Core_GlRenderbufferStorageMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
}
void QOpenGLFunctions_4_5_Core_GlResumeTransformFeedback5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glResumeTransformFeedback();
}
void QOpenGLFunctions_4_5_Core_GlSampleCoverage5(void* ptr, float value, char invert)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glSampleCoverage(value, invert != 0);
}
void QOpenGLFunctions_4_5_Core_GlSampleMaski5(void* ptr, unsigned int maskNumber, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glSampleMaski(maskNumber, mask);
}
void QOpenGLFunctions_4_5_Core_GlSamplerParameterIiv5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glSamplerParameterIiv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_5_Core_GlSamplerParameterIuiv5(void* ptr, unsigned int sampler, unsigned int pname, unsigned int param)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glSamplerParameterIuiv(sampler, pname, const_cast<const GLuint*>(&param));
}
void QOpenGLFunctions_4_5_Core_GlSamplerParameterf5(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glSamplerParameterf(sampler, pname, param);
}
void QOpenGLFunctions_4_5_Core_GlSamplerParameterfv5(void* ptr, unsigned int sampler, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glSamplerParameterfv(sampler, pname, const_cast<const GLfloat*>(&param));
}
void QOpenGLFunctions_4_5_Core_GlSamplerParameteri5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glSamplerParameteri(sampler, pname, param);
}
void QOpenGLFunctions_4_5_Core_GlSamplerParameteriv5(void* ptr, unsigned int sampler, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glSamplerParameteriv(sampler, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_5_Core_GlScissor5(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glScissor(x, y, width, height);
}
void QOpenGLFunctions_4_5_Core_GlScissorArrayv5(void* ptr, unsigned int first, int count, int v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glScissorArrayv(first, count, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlScissorIndexed5(void* ptr, unsigned int index, int left, int bottom, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glScissorIndexed(index, left, bottom, width, height);
}
void QOpenGLFunctions_4_5_Core_GlScissorIndexedv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glScissorIndexedv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlShaderBinary5(void* ptr, int count, unsigned int shaders, unsigned int binaryformat, void* binary, int length)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glShaderBinary(count, const_cast<const GLuint*>(&shaders), binaryformat, binary, length);
}
void QOpenGLFunctions_4_5_Core_GlShaderStorageBlockBinding5(void* ptr, unsigned int program, unsigned int storageBlockIndex, unsigned int storageBlockBinding)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
}
void QOpenGLFunctions_4_5_Core_GlStencilFunc5(void* ptr, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glStencilFunc(fu, ref, mask);
}
void QOpenGLFunctions_4_5_Core_GlStencilFuncSeparate5(void* ptr, unsigned int face, unsigned int fu, int ref, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glStencilFuncSeparate(face, fu, ref, mask);
}
void QOpenGLFunctions_4_5_Core_GlStencilMask5(void* ptr, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glStencilMask(mask);
}
void QOpenGLFunctions_4_5_Core_GlStencilMaskSeparate5(void* ptr, unsigned int face, unsigned int mask)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glStencilMaskSeparate(face, mask);
}
void QOpenGLFunctions_4_5_Core_GlStencilOp5(void* ptr, unsigned int fail, unsigned int zfail, unsigned int zpass)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glStencilOp(fail, zfail, zpass);
}
void QOpenGLFunctions_4_5_Core_GlStencilOpSeparate5(void* ptr, unsigned int face, unsigned int sfail, unsigned int dpfail, unsigned int dppass)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glStencilOpSeparate(face, sfail, dpfail, dppass);
}
void QOpenGLFunctions_4_5_Core_GlTexBuffer5(void* ptr, unsigned int target, unsigned int internalformat, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTexBuffer(target, internalformat, buffer);
}
void QOpenGLFunctions_4_5_Core_GlTexImage1D5(void* ptr, unsigned int target, int level, int internalformat, int width, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTexImage1D(target, level, internalformat, width, border, format, ty, pixels);
}
void QOpenGLFunctions_4_5_Core_GlTexImage2D5(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTexImage2D(target, level, internalformat, width, height, border, format, ty, pixels);
}
void QOpenGLFunctions_4_5_Core_GlTexImage2DMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_5_Core_GlTexImage3D5(void* ptr, unsigned int target, int level, int internalformat, int width, int height, int depth, int border, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTexImage3D(target, level, internalformat, width, height, depth, border, format, ty, pixels);
}
void QOpenGLFunctions_4_5_Core_GlTexImage3DMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_5_Core_GlTexParameterIiv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTexParameterIiv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_5_Core_GlTexParameterIuiv5(void* ptr, unsigned int target, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTexParameterIuiv(target, pname, const_cast<const GLuint*>(&params));
}
void QOpenGLFunctions_4_5_Core_GlTexParameterf5(void* ptr, unsigned int target, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTexParameterf(target, pname, param);
}
void QOpenGLFunctions_4_5_Core_GlTexParameterfv5(void* ptr, unsigned int target, unsigned int pname, float params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTexParameterfv(target, pname, const_cast<const GLfloat*>(&params));
}
void QOpenGLFunctions_4_5_Core_GlTexParameteri5(void* ptr, unsigned int target, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTexParameteri(target, pname, param);
}
void QOpenGLFunctions_4_5_Core_GlTexParameteriv5(void* ptr, unsigned int target, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTexParameteriv(target, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_5_Core_GlTexStorage1D5(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTexStorage1D(target, levels, internalformat, width);
}
void QOpenGLFunctions_4_5_Core_GlTexStorage2D5(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTexStorage2D(target, levels, internalformat, width, height);
}
void QOpenGLFunctions_4_5_Core_GlTexStorage2DMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_5_Core_GlTexStorage3D5(void* ptr, unsigned int target, int levels, unsigned int internalformat, int width, int height, int depth)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTexStorage3D(target, levels, internalformat, width, height, depth);
}
void QOpenGLFunctions_4_5_Core_GlTexStorage3DMultisample5(void* ptr, unsigned int target, int samples, unsigned int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_5_Core_GlTexSubImage1D5(void* ptr, unsigned int target, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTexSubImage1D(target, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_4_5_Core_GlTexSubImage2D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_5_Core_GlTexSubImage3D5(void* ptr, unsigned int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_4_5_Core_GlTextureBarrier5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTextureBarrier();
}
void QOpenGLFunctions_4_5_Core_GlTextureBuffer5(void* ptr, unsigned int texture, unsigned int internalformat, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTextureBuffer(texture, internalformat, buffer);
}
void QOpenGLFunctions_4_5_Core_GlTextureParameterIiv5(void* ptr, unsigned int texture, unsigned int pname, int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTextureParameterIiv(texture, pname, const_cast<const GLint*>(&params));
}
void QOpenGLFunctions_4_5_Core_GlTextureParameterIuiv5(void* ptr, unsigned int texture, unsigned int pname, unsigned int params)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTextureParameterIuiv(texture, pname, const_cast<const GLuint*>(&params));
}
void QOpenGLFunctions_4_5_Core_GlTextureParameterf5(void* ptr, unsigned int texture, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTextureParameterf(texture, pname, param);
}
void QOpenGLFunctions_4_5_Core_GlTextureParameterfv5(void* ptr, unsigned int texture, unsigned int pname, float param)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTextureParameterfv(texture, pname, const_cast<const GLfloat*>(&param));
}
void QOpenGLFunctions_4_5_Core_GlTextureParameteri5(void* ptr, unsigned int texture, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTextureParameteri(texture, pname, param);
}
void QOpenGLFunctions_4_5_Core_GlTextureParameteriv5(void* ptr, unsigned int texture, unsigned int pname, int param)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTextureParameteriv(texture, pname, const_cast<const GLint*>(&param));
}
void QOpenGLFunctions_4_5_Core_GlTextureStorage1D5(void* ptr, unsigned int texture, int levels, unsigned int internalformat, int width)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTextureStorage1D(texture, levels, internalformat, width);
}
void QOpenGLFunctions_4_5_Core_GlTextureStorage2D5(void* ptr, unsigned int texture, int levels, unsigned int internalformat, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTextureStorage2D(texture, levels, internalformat, width, height);
}
void QOpenGLFunctions_4_5_Core_GlTextureStorage2DMultisample5(void* ptr, unsigned int texture, int samples, unsigned int internalformat, int width, int height, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_5_Core_GlTextureStorage3D5(void* ptr, unsigned int texture, int levels, unsigned int internalformat, int width, int height, int depth)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTextureStorage3D(texture, levels, internalformat, width, height, depth);
}
void QOpenGLFunctions_4_5_Core_GlTextureStorage3DMultisample5(void* ptr, unsigned int texture, int samples, unsigned int internalformat, int width, int height, int depth, char fixedsamplelocations)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations != 0);
}
void QOpenGLFunctions_4_5_Core_GlTextureSubImage1D5(void* ptr, unsigned int texture, int level, int xoffset, int width, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTextureSubImage1D(texture, level, xoffset, width, format, ty, pixels);
}
void QOpenGLFunctions_4_5_Core_GlTextureSubImage2D5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int width, int height, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, ty, pixels);
}
void QOpenGLFunctions_4_5_Core_GlTextureSubImage3D5(void* ptr, unsigned int texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, unsigned int format, unsigned int ty, void* pixels)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, pixels);
}
void QOpenGLFunctions_4_5_Core_GlTextureView5(void* ptr, unsigned int texture, unsigned int target, unsigned int origtexture, unsigned int internalformat, unsigned int minlevel, unsigned int numlevels, unsigned int minlayer, unsigned int numlayers)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
}
void QOpenGLFunctions_4_5_Core_GlTransformFeedbackBufferBase5(void* ptr, unsigned int xfb, unsigned int index, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glTransformFeedbackBufferBase(xfb, index, buffer);
}
void QOpenGLFunctions_4_5_Core_GlUniform1f5(void* ptr, int location, float v0)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniform1f(location, v0);
}
void QOpenGLFunctions_4_5_Core_GlUniform1fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniform1fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlUniform1i5(void* ptr, int location, int v0)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniform1i(location, v0);
}
void QOpenGLFunctions_4_5_Core_GlUniform1iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniform1iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlUniform1ui5(void* ptr, int location, unsigned int v0)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniform1ui(location, v0);
}
void QOpenGLFunctions_4_5_Core_GlUniform1uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniform1uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlUniform2f5(void* ptr, int location, float v0, float v1)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniform2f(location, v0, v1);
}
void QOpenGLFunctions_4_5_Core_GlUniform2fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniform2fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlUniform2i5(void* ptr, int location, int v0, int v1)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniform2i(location, v0, v1);
}
void QOpenGLFunctions_4_5_Core_GlUniform2iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniform2iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlUniform2ui5(void* ptr, int location, unsigned int v0, unsigned int v1)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniform2ui(location, v0, v1);
}
void QOpenGLFunctions_4_5_Core_GlUniform2uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniform2uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlUniform3f5(void* ptr, int location, float v0, float v1, float v2)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniform3f(location, v0, v1, v2);
}
void QOpenGLFunctions_4_5_Core_GlUniform3fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniform3fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlUniform3i5(void* ptr, int location, int v0, int v1, int v2)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniform3i(location, v0, v1, v2);
}
void QOpenGLFunctions_4_5_Core_GlUniform3iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniform3iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlUniform3ui5(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniform3ui(location, v0, v1, v2);
}
void QOpenGLFunctions_4_5_Core_GlUniform3uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniform3uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlUniform4f5(void* ptr, int location, float v0, float v1, float v2, float v3)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniform4f(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_5_Core_GlUniform4fv5(void* ptr, int location, int count, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniform4fv(location, count, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlUniform4i5(void* ptr, int location, int v0, int v1, int v2, int v3)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniform4i(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_5_Core_GlUniform4iv5(void* ptr, int location, int count, int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniform4iv(location, count, const_cast<const GLint*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlUniform4ui5(void* ptr, int location, unsigned int v0, unsigned int v1, unsigned int v2, unsigned int v3)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniform4ui(location, v0, v1, v2, v3);
}
void QOpenGLFunctions_4_5_Core_GlUniform4uiv5(void* ptr, int location, int count, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniform4uiv(location, count, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlUniformBlockBinding5(void* ptr, unsigned int program, unsigned int uniformBlockIndex, unsigned int uniformBlockBinding)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}
void QOpenGLFunctions_4_5_Core_GlUniformMatrix2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniformMatrix2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlUniformMatrix2x3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniformMatrix2x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlUniformMatrix2x4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniformMatrix2x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlUniformMatrix3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniformMatrix3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlUniformMatrix3x2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniformMatrix3x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlUniformMatrix3x4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniformMatrix3x4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlUniformMatrix4fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniformMatrix4fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlUniformMatrix4x2fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniformMatrix4x2fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlUniformMatrix4x3fv5(void* ptr, int location, int count, char transpose, float value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniformMatrix4x3fv(location, count, transpose != 0, const_cast<const GLfloat*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlUniformSubroutinesuiv5(void* ptr, unsigned int shadertype, int count, unsigned int indices)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUniformSubroutinesuiv(shadertype, count, const_cast<const GLuint*>(&indices));
}
void QOpenGLFunctions_4_5_Core_GlUseProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUseProgram(program);
}
void QOpenGLFunctions_4_5_Core_GlUseProgramStages5(void* ptr, unsigned int pipeline, unsigned int stages, unsigned int program)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glUseProgramStages(pipeline, stages, program);
}
void QOpenGLFunctions_4_5_Core_GlValidateProgram5(void* ptr, unsigned int program)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glValidateProgram(program);
}
void QOpenGLFunctions_4_5_Core_GlValidateProgramPipeline5(void* ptr, unsigned int pipeline)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glValidateProgramPipeline(pipeline);
}
void QOpenGLFunctions_4_5_Core_GlVertexArrayAttribBinding5(void* ptr, unsigned int vaobj, unsigned int attribindex, unsigned int bindingindex)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexArrayAttribBinding(vaobj, attribindex, bindingindex);
}
void QOpenGLFunctions_4_5_Core_GlVertexArrayAttribFormat5(void* ptr, unsigned int vaobj, unsigned int attribindex, int size, unsigned int ty, char normalized, unsigned int relativeoffset)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexArrayAttribFormat(vaobj, attribindex, size, ty, normalized != 0, relativeoffset);
}
void QOpenGLFunctions_4_5_Core_GlVertexArrayAttribIFormat5(void* ptr, unsigned int vaobj, unsigned int attribindex, int size, unsigned int ty, unsigned int relativeoffset)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexArrayAttribIFormat(vaobj, attribindex, size, ty, relativeoffset);
}
void QOpenGLFunctions_4_5_Core_GlVertexArrayAttribLFormat5(void* ptr, unsigned int vaobj, unsigned int attribindex, int size, unsigned int ty, unsigned int relativeoffset)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexArrayAttribLFormat(vaobj, attribindex, size, ty, relativeoffset);
}
void QOpenGLFunctions_4_5_Core_GlVertexArrayBindingDivisor5(void* ptr, unsigned int vaobj, unsigned int bindingindex, unsigned int divisor)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexArrayBindingDivisor(vaobj, bindingindex, divisor);
}
void QOpenGLFunctions_4_5_Core_GlVertexArrayElementBuffer5(void* ptr, unsigned int vaobj, unsigned int buffer)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexArrayElementBuffer(vaobj, buffer);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib1f5(void* ptr, unsigned int index, float x)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib1f(index, x);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib1fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib1fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib1s5(void* ptr, unsigned int index, short x)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib1s(index, x);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib1sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib1sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib2f5(void* ptr, unsigned int index, float x, float y)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib2f(index, x, y);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib2fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib2fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib2s5(void* ptr, unsigned int index, short x, short y)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib2s(index, x, y);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib2sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib2sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib3f5(void* ptr, unsigned int index, float x, float y, float z)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib3f(index, x, y, z);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib3fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib3fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib3s5(void* ptr, unsigned int index, short x, short y, short z)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib3s(index, x, y, z);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib3sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib3sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib4Niv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib4Niv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib4Nsv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib4Nsv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib4Nub5(void* ptr, unsigned int index, char* x, char* y, char* z, char* w)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib4Nub(index, *static_cast<GLubyte*>(static_cast<void*>(x)), *static_cast<GLubyte*>(static_cast<void*>(y)), *static_cast<GLubyte*>(static_cast<void*>(z)), *static_cast<GLubyte*>(static_cast<void*>(w)));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib4Nubv5(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib4Nubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib4Nuiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib4Nuiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib4Nusv5(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib4Nusv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib4f5(void* ptr, unsigned int index, float x, float y, float z, float w)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib4f(index, x, y, z, w);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib4fv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib4fv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib4iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib4s5(void* ptr, unsigned int index, short x, short y, short z, short w)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib4s(index, x, y, z, w);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib4sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib4sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib4ubv5(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib4ubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib4uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttrib4usv5(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttrib4usv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribBinding5(void* ptr, unsigned int attribindex, unsigned int bindingindex)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribBinding(attribindex, bindingindex);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribDivisor5(void* ptr, unsigned int index, unsigned int divisor)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribDivisor(index, divisor);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribFormat5(void* ptr, unsigned int attribindex, int size, unsigned int ty, char normalized, unsigned int relativeoffset)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribFormat(attribindex, size, ty, normalized != 0, relativeoffset);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribI1i5(void* ptr, unsigned int index, int x)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribI1i(index, x);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribI1iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribI1iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribI1ui5(void* ptr, unsigned int index, unsigned int x)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribI1ui(index, x);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribI1uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribI1uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribI2i5(void* ptr, unsigned int index, int x, int y)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribI2i(index, x, y);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribI2iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribI2iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribI2ui5(void* ptr, unsigned int index, unsigned int x, unsigned int y)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribI2ui(index, x, y);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribI2uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribI2uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribI3i5(void* ptr, unsigned int index, int x, int y, int z)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribI3i(index, x, y, z);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribI3iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribI3iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribI3ui5(void* ptr, unsigned int index, unsigned int x, unsigned int y, unsigned int z)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribI3ui(index, x, y, z);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribI3uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribI3uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribI4i5(void* ptr, unsigned int index, int x, int y, int z, int w)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribI4i(index, x, y, z, w);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribI4iv5(void* ptr, unsigned int index, int v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribI4iv(index, const_cast<const GLint*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribI4sv5(void* ptr, unsigned int index, short v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribI4sv(index, const_cast<const GLshort*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribI4ubv5(void* ptr, unsigned int index, char* v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribI4ubv(index, const_cast<const GLubyte*>(static_cast<GLubyte*>(static_cast<void*>(v))));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribI4ui5(void* ptr, unsigned int index, unsigned int x, unsigned int y, unsigned int z, unsigned int w)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribI4ui(index, x, y, z, w);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribI4uiv5(void* ptr, unsigned int index, unsigned int v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribI4uiv(index, const_cast<const GLuint*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribI4usv5(void* ptr, unsigned int index, unsigned short v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribI4usv(index, const_cast<const GLushort*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribIFormat5(void* ptr, unsigned int attribindex, int size, unsigned int ty, unsigned int relativeoffset)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribIFormat(attribindex, size, ty, relativeoffset);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribIPointer5(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribIPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribLFormat5(void* ptr, unsigned int attribindex, int size, unsigned int ty, unsigned int relativeoffset)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribLFormat(attribindex, size, ty, relativeoffset);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribLPointer5(void* ptr, unsigned int index, int size, unsigned int ty, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribLPointer(index, size, ty, stride, pointer);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribP1ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribP1ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribP1uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribP1uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribP2ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribP2ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribP2uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribP2uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribP3ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribP3ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribP3uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribP3uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribP4ui5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribP4ui(index, ty, normalized != 0, value);
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribP4uiv5(void* ptr, unsigned int index, unsigned int ty, char normalized, unsigned int value)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribP4uiv(index, ty, normalized != 0, const_cast<const GLuint*>(&value));
}
void QOpenGLFunctions_4_5_Core_GlVertexAttribPointer5(void* ptr, unsigned int index, int size, unsigned int ty, char normalized, int stride, void* pointer)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexAttribPointer(index, size, ty, normalized != 0, stride, pointer);
}
void QOpenGLFunctions_4_5_Core_GlVertexBindingDivisor5(void* ptr, unsigned int bindingindex, unsigned int divisor)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glVertexBindingDivisor(bindingindex, divisor);
}
void QOpenGLFunctions_4_5_Core_GlViewport5(void* ptr, int x, int y, int width, int height)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glViewport(x, y, width, height);
}
void QOpenGLFunctions_4_5_Core_GlViewportArrayv5(void* ptr, unsigned int first, int count, float v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glViewportArrayv(first, count, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Core_GlViewportIndexedf5(void* ptr, unsigned int index, float x, float y, float w, float h)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glViewportIndexedf(index, x, y, w, h);
}
void QOpenGLFunctions_4_5_Core_GlViewportIndexedfv5(void* ptr, unsigned int index, float v)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glViewportIndexedfv(index, const_cast<const GLfloat*>(&v));
}
void QOpenGLFunctions_4_5_Core_DestroyQOpenGLFunctions_4_5_Core5(void* ptr)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->~QOpenGLFunctions_4_5_Core();
}
void QOpenGLFunctions_4_5_Core_DestroyQOpenGLFunctions_4_5_Core5Default(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQOpenGLPaintDevice: public QOpenGLPaintDevice
{
public:
MyQOpenGLPaintDevice() : QOpenGLPaintDevice() {};
MyQOpenGLPaintDevice(const QSize &size) : QOpenGLPaintDevice(size) {};
MyQOpenGLPaintDevice(int width, int height) : QOpenGLPaintDevice(width, height) {};
void ensureActiveTarget() { callbackQOpenGLPaintDevice_EnsureActiveTarget(this); };
~MyQOpenGLPaintDevice() { callbackQOpenGLPaintDevice_DestroyQOpenGLPaintDevice(this); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQOpenGLPaintDevice_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPaintDevice_Metric(const_cast<void*>(static_cast<const void*>(this)), metric); };
};
void* QOpenGLPaintDevice_NewQOpenGLPaintDevice()
{
return new MyQOpenGLPaintDevice();
}
void* QOpenGLPaintDevice_NewQOpenGLPaintDevice2(void* size)
{
return new MyQOpenGLPaintDevice(*static_cast<QSize*>(size));
}
void* QOpenGLPaintDevice_NewQOpenGLPaintDevice3(int width, int height)
{
return new MyQOpenGLPaintDevice(width, height);
}
void QOpenGLPaintDevice_EnsureActiveTarget(void* ptr)
{
static_cast<QOpenGLPaintDevice*>(ptr)->ensureActiveTarget();
}
void QOpenGLPaintDevice_EnsureActiveTargetDefault(void* ptr)
{
static_cast<QOpenGLPaintDevice*>(ptr)->QOpenGLPaintDevice::ensureActiveTarget();
}
void QOpenGLPaintDevice_SetDevicePixelRatio(void* ptr, double devicePixelRatio)
{
static_cast<QOpenGLPaintDevice*>(ptr)->setDevicePixelRatio(devicePixelRatio);
}
void QOpenGLPaintDevice_SetDotsPerMeterX(void* ptr, double dpmx)
{
static_cast<QOpenGLPaintDevice*>(ptr)->setDotsPerMeterX(dpmx);
}
void QOpenGLPaintDevice_SetDotsPerMeterY(void* ptr, double dpmy)
{
static_cast<QOpenGLPaintDevice*>(ptr)->setDotsPerMeterY(dpmy);
}
void QOpenGLPaintDevice_SetPaintFlipped(void* ptr, char flipped)
{
static_cast<QOpenGLPaintDevice*>(ptr)->setPaintFlipped(flipped != 0);
}
void QOpenGLPaintDevice_SetSize(void* ptr, void* size)
{
static_cast<QOpenGLPaintDevice*>(ptr)->setSize(*static_cast<QSize*>(size));
}
void QOpenGLPaintDevice_DestroyQOpenGLPaintDevice(void* ptr)
{
static_cast<QOpenGLPaintDevice*>(ptr)->~QOpenGLPaintDevice();
}
void QOpenGLPaintDevice_DestroyQOpenGLPaintDeviceDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QOpenGLPaintDevice_Context(void* ptr)
{
return static_cast<QOpenGLPaintDevice*>(ptr)->context();
}
void* QOpenGLPaintDevice_PaintEngine(void* ptr)
{
return static_cast<QOpenGLPaintDevice*>(ptr)->paintEngine();
}
void* QOpenGLPaintDevice_PaintEngineDefault(void* ptr)
{
return static_cast<QOpenGLPaintDevice*>(ptr)->QOpenGLPaintDevice::paintEngine();
}
void* QOpenGLPaintDevice_Size(void* ptr)
{
return ({ QSize tmpValue = static_cast<QOpenGLPaintDevice*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
}
char QOpenGLPaintDevice_PaintFlipped(void* ptr)
{
return static_cast<QOpenGLPaintDevice*>(ptr)->paintFlipped();
}
double QOpenGLPaintDevice_DotsPerMeterX(void* ptr)
{
return static_cast<QOpenGLPaintDevice*>(ptr)->dotsPerMeterX();
}
double QOpenGLPaintDevice_DotsPerMeterY(void* ptr)
{
return static_cast<QOpenGLPaintDevice*>(ptr)->dotsPerMeterY();
}
void* QOpenGLPixelTransferOptions_NewQOpenGLPixelTransferOptions()
{
return new QOpenGLPixelTransferOptions();
}
void QOpenGLPixelTransferOptions_SetAlignment(void* ptr, int alignment)
{
static_cast<QOpenGLPixelTransferOptions*>(ptr)->setAlignment(alignment);
}
void QOpenGLPixelTransferOptions_SetImageHeight(void* ptr, int imageHeight)
{
static_cast<QOpenGLPixelTransferOptions*>(ptr)->setImageHeight(imageHeight);
}
void QOpenGLPixelTransferOptions_SetLeastSignificantByteFirst(void* ptr, char lsbFirst)
{
static_cast<QOpenGLPixelTransferOptions*>(ptr)->setLeastSignificantByteFirst(lsbFirst != 0);
}
void QOpenGLPixelTransferOptions_SetRowLength(void* ptr, int rowLength)
{
static_cast<QOpenGLPixelTransferOptions*>(ptr)->setRowLength(rowLength);
}
void QOpenGLPixelTransferOptions_SetSkipImages(void* ptr, int skipImages)
{
static_cast<QOpenGLPixelTransferOptions*>(ptr)->setSkipImages(skipImages);
}
void QOpenGLPixelTransferOptions_SetSkipPixels(void* ptr, int skipPixels)
{
static_cast<QOpenGLPixelTransferOptions*>(ptr)->setSkipPixels(skipPixels);
}
void QOpenGLPixelTransferOptions_SetSkipRows(void* ptr, int skipRows)
{
static_cast<QOpenGLPixelTransferOptions*>(ptr)->setSkipRows(skipRows);
}
void QOpenGLPixelTransferOptions_SetSwapBytesEnabled(void* ptr, char swapBytes)
{
static_cast<QOpenGLPixelTransferOptions*>(ptr)->setSwapBytesEnabled(swapBytes != 0);
}
void QOpenGLPixelTransferOptions_DestroyQOpenGLPixelTransferOptions(void* ptr)
{
static_cast<QOpenGLPixelTransferOptions*>(ptr)->~QOpenGLPixelTransferOptions();
}
char QOpenGLPixelTransferOptions_IsLeastSignificantBitFirst(void* ptr)
{
return static_cast<QOpenGLPixelTransferOptions*>(ptr)->isLeastSignificantBitFirst();
}
char QOpenGLPixelTransferOptions_IsSwapBytesEnabled(void* ptr)
{
return static_cast<QOpenGLPixelTransferOptions*>(ptr)->isSwapBytesEnabled();
}
int QOpenGLPixelTransferOptions_Alignment(void* ptr)
{
return static_cast<QOpenGLPixelTransferOptions*>(ptr)->alignment();
}
int QOpenGLPixelTransferOptions_ImageHeight(void* ptr)
{
return static_cast<QOpenGLPixelTransferOptions*>(ptr)->imageHeight();
}
int QOpenGLPixelTransferOptions_RowLength(void* ptr)
{
return static_cast<QOpenGLPixelTransferOptions*>(ptr)->rowLength();
}
int QOpenGLPixelTransferOptions_SkipImages(void* ptr)
{
return static_cast<QOpenGLPixelTransferOptions*>(ptr)->skipImages();
}
int QOpenGLPixelTransferOptions_SkipPixels(void* ptr)
{
return static_cast<QOpenGLPixelTransferOptions*>(ptr)->skipPixels();
}
int QOpenGLPixelTransferOptions_SkipRows(void* ptr)
{
return static_cast<QOpenGLPixelTransferOptions*>(ptr)->skipRows();
}
class MyQOpenGLShader: public QOpenGLShader
{
public:
MyQOpenGLShader(QOpenGLShader::ShaderType ty, QObject *parent = Q_NULLPTR) : QOpenGLShader(ty, parent) {QOpenGLShader_QOpenGLShader_QRegisterMetaType();};
~MyQOpenGLShader() { callbackQOpenGLShader_DestroyQOpenGLShader(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQOpenGLShader_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQOpenGLShader_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQOpenGLShader_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQOpenGLShader_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQOpenGLShader_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQOpenGLShader_CustomEvent(this, event); };
void deleteLater() { callbackQOpenGLShader_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQOpenGLShader_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQOpenGLShader_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQOpenGLShader_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQOpenGLShader_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQOpenGLShader*)
int QOpenGLShader_QOpenGLShader_QRegisterMetaType(){qRegisterMetaType<QOpenGLShader*>(); return qRegisterMetaType<MyQOpenGLShader*>();}
void* QOpenGLShader_NewQOpenGLShader(long long ty, void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShader(static_cast<QOpenGLShader::ShaderTypeBit>(ty), static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShader(static_cast<QOpenGLShader::ShaderTypeBit>(ty), static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShader(static_cast<QOpenGLShader::ShaderTypeBit>(ty), static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShader(static_cast<QOpenGLShader::ShaderTypeBit>(ty), static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShader(static_cast<QOpenGLShader::ShaderTypeBit>(ty), static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShader(static_cast<QOpenGLShader::ShaderTypeBit>(ty), static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShader(static_cast<QOpenGLShader::ShaderTypeBit>(ty), static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShader(static_cast<QOpenGLShader::ShaderTypeBit>(ty), static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShader(static_cast<QOpenGLShader::ShaderTypeBit>(ty), static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShader(static_cast<QOpenGLShader::ShaderTypeBit>(ty), static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShader(static_cast<QOpenGLShader::ShaderTypeBit>(ty), static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShader(static_cast<QOpenGLShader::ShaderTypeBit>(ty), static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShader(static_cast<QOpenGLShader::ShaderTypeBit>(ty), static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShader(static_cast<QOpenGLShader::ShaderTypeBit>(ty), static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShader(static_cast<QOpenGLShader::ShaderTypeBit>(ty), static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShader(static_cast<QOpenGLShader::ShaderTypeBit>(ty), static_cast<QWindow*>(parent));
} else {
return new MyQOpenGLShader(static_cast<QOpenGLShader::ShaderTypeBit>(ty), static_cast<QObject*>(parent));
}
}
struct QtGui_PackedString QOpenGLShader_QOpenGLShader_Tr(char* s, char* c, int n)
{
return ({ QByteArray tfeb2d7 = QOpenGLShader::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(tfeb2d7.prepend("WHITESPACE").constData()+10), tfeb2d7.size()-10 }; });
}
struct QtGui_PackedString QOpenGLShader_QOpenGLShader_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray t7759d6 = QOpenGLShader::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t7759d6.prepend("WHITESPACE").constData()+10), t7759d6.size()-10 }; });
}
char QOpenGLShader_CompileSourceCode2(void* ptr, void* source)
{
return static_cast<QOpenGLShader*>(ptr)->compileSourceCode(*static_cast<QByteArray*>(source));
}
char QOpenGLShader_CompileSourceCode3(void* ptr, struct QtGui_PackedString source)
{
return static_cast<QOpenGLShader*>(ptr)->compileSourceCode(QString::fromUtf8(source.data, source.len));
}
char QOpenGLShader_CompileSourceCode(void* ptr, char* source)
{
return static_cast<QOpenGLShader*>(ptr)->compileSourceCode(const_cast<const char*>(source));
}
char QOpenGLShader_CompileSourceFile(void* ptr, struct QtGui_PackedString fileName)
{
return static_cast<QOpenGLShader*>(ptr)->compileSourceFile(QString::fromUtf8(fileName.data, fileName.len));
}
char QOpenGLShader_QOpenGLShader_HasOpenGLShaders(long long ty, void* context)
{
return QOpenGLShader::hasOpenGLShaders(static_cast<QOpenGLShader::ShaderTypeBit>(ty), static_cast<QOpenGLContext*>(context));
}
void QOpenGLShader_DestroyQOpenGLShader(void* ptr)
{
static_cast<QOpenGLShader*>(ptr)->~QOpenGLShader();
}
void QOpenGLShader_DestroyQOpenGLShaderDefault(void* ptr)
{
Q_UNUSED(ptr);
}
unsigned int QOpenGLShader_ShaderId(void* ptr)
{
return static_cast<QOpenGLShader*>(ptr)->shaderId();
}
void* QOpenGLShader_SourceCode(void* ptr)
{
return new QByteArray(static_cast<QOpenGLShader*>(ptr)->sourceCode());
}
long long QOpenGLShader_ShaderType(void* ptr)
{
return static_cast<QOpenGLShader*>(ptr)->shaderType();
}
struct QtGui_PackedString QOpenGLShader_Log(void* ptr)
{
return ({ QByteArray t6038d9 = static_cast<QOpenGLShader*>(ptr)->log().toUtf8(); QtGui_PackedString { const_cast<char*>(t6038d9.prepend("WHITESPACE").constData()+10), t6038d9.size()-10 }; });
}
char QOpenGLShader_IsCompiled(void* ptr)
{
return static_cast<QOpenGLShader*>(ptr)->isCompiled();
}
void* QOpenGLShader_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QOpenGLShader*>(ptr)->QOpenGLShader::metaObject());
}
void* QOpenGLShader___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QOpenGLShader___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QOpenGLShader___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QOpenGLShader___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLShader___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLShader___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOpenGLShader___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLShader___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLShader___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOpenGLShader___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLShader___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLShader___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOpenGLShader___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLShader___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLShader___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QOpenGLShader_EventDefault(void* ptr, void* e)
{
return static_cast<QOpenGLShader*>(ptr)->QOpenGLShader::event(static_cast<QEvent*>(e));
}
char QOpenGLShader_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLShader*>(ptr)->QOpenGLShader::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLShader*>(ptr)->QOpenGLShader::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLShader*>(ptr)->QOpenGLShader::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLShader*>(ptr)->QOpenGLShader::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QOpenGLShader*>(ptr)->QOpenGLShader::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QOpenGLShader_ChildEventDefault(void* ptr, void* event)
{
static_cast<QOpenGLShader*>(ptr)->QOpenGLShader::childEvent(static_cast<QChildEvent*>(event));
}
void QOpenGLShader_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QOpenGLShader*>(ptr)->QOpenGLShader::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QOpenGLShader_CustomEventDefault(void* ptr, void* event)
{
static_cast<QOpenGLShader*>(ptr)->QOpenGLShader::customEvent(static_cast<QEvent*>(event));
}
void QOpenGLShader_DeleteLaterDefault(void* ptr)
{
static_cast<QOpenGLShader*>(ptr)->QOpenGLShader::deleteLater();
}
void QOpenGLShader_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QOpenGLShader*>(ptr)->QOpenGLShader::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QOpenGLShader_TimerEventDefault(void* ptr, void* event)
{
static_cast<QOpenGLShader*>(ptr)->QOpenGLShader::timerEvent(static_cast<QTimerEvent*>(event));
}
class MyQOpenGLShaderProgram: public QOpenGLShaderProgram
{
public:
MyQOpenGLShaderProgram(QObject *parent = Q_NULLPTR) : QOpenGLShaderProgram(parent) {QOpenGLShaderProgram_QOpenGLShaderProgram_QRegisterMetaType();};
bool link() { return callbackQOpenGLShaderProgram_Link(this) != 0; };
~MyQOpenGLShaderProgram() { callbackQOpenGLShaderProgram_DestroyQOpenGLShaderProgram(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQOpenGLShaderProgram_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQOpenGLShaderProgram_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQOpenGLShaderProgram_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQOpenGLShaderProgram_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQOpenGLShaderProgram_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQOpenGLShaderProgram_CustomEvent(this, event); };
void deleteLater() { callbackQOpenGLShaderProgram_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQOpenGLShaderProgram_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQOpenGLShaderProgram_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQOpenGLShaderProgram_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQOpenGLShaderProgram_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQOpenGLShaderProgram*)
int QOpenGLShaderProgram_QOpenGLShaderProgram_QRegisterMetaType(){qRegisterMetaType<QOpenGLShaderProgram*>(); return qRegisterMetaType<MyQOpenGLShaderProgram*>();}
void* QOpenGLShaderProgram_NewQOpenGLShaderProgram(void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShaderProgram(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShaderProgram(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShaderProgram(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShaderProgram(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShaderProgram(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShaderProgram(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShaderProgram(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShaderProgram(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShaderProgram(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShaderProgram(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShaderProgram(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShaderProgram(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShaderProgram(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShaderProgram(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShaderProgram(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLShaderProgram(static_cast<QWindow*>(parent));
} else {
return new MyQOpenGLShaderProgram(static_cast<QObject*>(parent));
}
}
struct QtGui_PackedString QOpenGLShaderProgram_QOpenGLShaderProgram_Tr(char* s, char* c, int n)
{
return ({ QByteArray te4d9a4 = QOpenGLShaderProgram::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(te4d9a4.prepend("WHITESPACE").constData()+10), te4d9a4.size()-10 }; });
}
struct QtGui_PackedString QOpenGLShaderProgram_QOpenGLShaderProgram_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray tab432f = QOpenGLShaderProgram::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(tab432f.prepend("WHITESPACE").constData()+10), tab432f.size()-10 }; });
}
char QOpenGLShaderProgram_AddCacheableShaderFromSourceCode2(void* ptr, long long ty, void* source)
{
return static_cast<QOpenGLShaderProgram*>(ptr)->addCacheableShaderFromSourceCode(static_cast<QOpenGLShader::ShaderTypeBit>(ty), *static_cast<QByteArray*>(source));
}
char QOpenGLShaderProgram_AddCacheableShaderFromSourceCode3(void* ptr, long long ty, struct QtGui_PackedString source)
{
return static_cast<QOpenGLShaderProgram*>(ptr)->addCacheableShaderFromSourceCode(static_cast<QOpenGLShader::ShaderTypeBit>(ty), QString::fromUtf8(source.data, source.len));
}
char QOpenGLShaderProgram_AddCacheableShaderFromSourceCode(void* ptr, long long ty, char* source)
{
return static_cast<QOpenGLShaderProgram*>(ptr)->addCacheableShaderFromSourceCode(static_cast<QOpenGLShader::ShaderTypeBit>(ty), const_cast<const char*>(source));
}
char QOpenGLShaderProgram_AddCacheableShaderFromSourceFile(void* ptr, long long ty, struct QtGui_PackedString fileName)
{
return static_cast<QOpenGLShaderProgram*>(ptr)->addCacheableShaderFromSourceFile(static_cast<QOpenGLShader::ShaderTypeBit>(ty), QString::fromUtf8(fileName.data, fileName.len));
}
char QOpenGLShaderProgram_AddShader(void* ptr, void* shader)
{
return static_cast<QOpenGLShaderProgram*>(ptr)->addShader(static_cast<QOpenGLShader*>(shader));
}
char QOpenGLShaderProgram_AddShaderFromSourceCode2(void* ptr, long long ty, void* source)
{
return static_cast<QOpenGLShaderProgram*>(ptr)->addShaderFromSourceCode(static_cast<QOpenGLShader::ShaderTypeBit>(ty), *static_cast<QByteArray*>(source));
}
char QOpenGLShaderProgram_AddShaderFromSourceCode3(void* ptr, long long ty, struct QtGui_PackedString source)
{
return static_cast<QOpenGLShaderProgram*>(ptr)->addShaderFromSourceCode(static_cast<QOpenGLShader::ShaderTypeBit>(ty), QString::fromUtf8(source.data, source.len));
}
char QOpenGLShaderProgram_AddShaderFromSourceCode(void* ptr, long long ty, char* source)
{
return static_cast<QOpenGLShaderProgram*>(ptr)->addShaderFromSourceCode(static_cast<QOpenGLShader::ShaderTypeBit>(ty), const_cast<const char*>(source));
}
char QOpenGLShaderProgram_AddShaderFromSourceFile(void* ptr, long long ty, struct QtGui_PackedString fileName)
{
return static_cast<QOpenGLShaderProgram*>(ptr)->addShaderFromSourceFile(static_cast<QOpenGLShader::ShaderTypeBit>(ty), QString::fromUtf8(fileName.data, fileName.len));
}
char QOpenGLShaderProgram_Bind(void* ptr)
{
return static_cast<QOpenGLShaderProgram*>(ptr)->bind();
}
char QOpenGLShaderProgram_Create(void* ptr)
{
return static_cast<QOpenGLShaderProgram*>(ptr)->create();
}
char QOpenGLShaderProgram_QOpenGLShaderProgram_HasOpenGLShaderPrograms(void* context)
{
return QOpenGLShaderProgram::hasOpenGLShaderPrograms(static_cast<QOpenGLContext*>(context));
}
char QOpenGLShaderProgram_Link(void* ptr)
{
return static_cast<QOpenGLShaderProgram*>(ptr)->link();
}
char QOpenGLShaderProgram_LinkDefault(void* ptr)
{
return static_cast<QOpenGLShaderProgram*>(ptr)->QOpenGLShaderProgram::link();
}
void QOpenGLShaderProgram_BindAttributeLocation2(void* ptr, void* name, int location)
{
static_cast<QOpenGLShaderProgram*>(ptr)->bindAttributeLocation(*static_cast<QByteArray*>(name), location);
}
void QOpenGLShaderProgram_BindAttributeLocation3(void* ptr, struct QtGui_PackedString name, int location)
{
static_cast<QOpenGLShaderProgram*>(ptr)->bindAttributeLocation(QString::fromUtf8(name.data, name.len), location);
}
void QOpenGLShaderProgram_BindAttributeLocation(void* ptr, char* name, int location)
{
static_cast<QOpenGLShaderProgram*>(ptr)->bindAttributeLocation(const_cast<const char*>(name), location);
}
void QOpenGLShaderProgram_DisableAttributeArray2(void* ptr, char* name)
{
static_cast<QOpenGLShaderProgram*>(ptr)->disableAttributeArray(const_cast<const char*>(name));
}
void QOpenGLShaderProgram_DisableAttributeArray(void* ptr, int location)
{
static_cast<QOpenGLShaderProgram*>(ptr)->disableAttributeArray(location);
}
void QOpenGLShaderProgram_EnableAttributeArray2(void* ptr, char* name)
{
static_cast<QOpenGLShaderProgram*>(ptr)->enableAttributeArray(const_cast<const char*>(name));
}
void QOpenGLShaderProgram_EnableAttributeArray(void* ptr, int location)
{
static_cast<QOpenGLShaderProgram*>(ptr)->enableAttributeArray(location);
}
void QOpenGLShaderProgram_Release(void* ptr)
{
static_cast<QOpenGLShaderProgram*>(ptr)->release();
}
void QOpenGLShaderProgram_RemoveAllShaders(void* ptr)
{
static_cast<QOpenGLShaderProgram*>(ptr)->removeAllShaders();
}
void QOpenGLShaderProgram_RemoveShader(void* ptr, void* shader)
{
static_cast<QOpenGLShaderProgram*>(ptr)->removeShader(static_cast<QOpenGLShader*>(shader));
}
void QOpenGLShaderProgram_SetAttributeArray10(void* ptr, char* name, unsigned int ty, void* values, int tupleSize, int stride)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeArray(const_cast<const char*>(name), ty, values, tupleSize, stride);
}
void QOpenGLShaderProgram_SetAttributeArray6(void* ptr, char* name, float values, int tupleSize, int stride)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeArray(const_cast<const char*>(name), const_cast<const GLfloat*>(&values), tupleSize, stride);
}
void QOpenGLShaderProgram_SetAttributeArray7(void* ptr, char* name, void* values, int stride)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeArray(const_cast<const char*>(name), static_cast<QVector2D*>(values), stride);
}
void QOpenGLShaderProgram_SetAttributeArray8(void* ptr, char* name, void* values, int stride)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeArray(const_cast<const char*>(name), static_cast<QVector3D*>(values), stride);
}
void QOpenGLShaderProgram_SetAttributeArray9(void* ptr, char* name, void* values, int stride)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeArray(const_cast<const char*>(name), static_cast<QVector4D*>(values), stride);
}
void QOpenGLShaderProgram_SetAttributeArray5(void* ptr, int location, unsigned int ty, void* values, int tupleSize, int stride)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeArray(location, ty, values, tupleSize, stride);
}
void QOpenGLShaderProgram_SetAttributeArray(void* ptr, int location, float values, int tupleSize, int stride)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeArray(location, const_cast<const GLfloat*>(&values), tupleSize, stride);
}
void QOpenGLShaderProgram_SetAttributeArray2(void* ptr, int location, void* values, int stride)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeArray(location, static_cast<QVector2D*>(values), stride);
}
void QOpenGLShaderProgram_SetAttributeArray3(void* ptr, int location, void* values, int stride)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeArray(location, static_cast<QVector3D*>(values), stride);
}
void QOpenGLShaderProgram_SetAttributeArray4(void* ptr, int location, void* values, int stride)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeArray(location, static_cast<QVector4D*>(values), stride);
}
void QOpenGLShaderProgram_SetAttributeBuffer2(void* ptr, char* name, unsigned int ty, int offset, int tupleSize, int stride)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeBuffer(const_cast<const char*>(name), ty, offset, tupleSize, stride);
}
void QOpenGLShaderProgram_SetAttributeBuffer(void* ptr, int location, unsigned int ty, int offset, int tupleSize, int stride)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeBuffer(location, ty, offset, tupleSize, stride);
}
void QOpenGLShaderProgram_SetAttributeValue10(void* ptr, char* name, float value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeValue(const_cast<const char*>(name), value);
}
void QOpenGLShaderProgram_SetAttributeValue11(void* ptr, char* name, float x, float y)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeValue(const_cast<const char*>(name), x, y);
}
void QOpenGLShaderProgram_SetAttributeValue12(void* ptr, char* name, float x, float y, float z)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeValue(const_cast<const char*>(name), x, y, z);
}
void QOpenGLShaderProgram_SetAttributeValue13(void* ptr, char* name, float x, float y, float z, float w)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeValue(const_cast<const char*>(name), x, y, z, w);
}
void QOpenGLShaderProgram_SetAttributeValue18(void* ptr, char* name, float values, int columns, int rows)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeValue(const_cast<const char*>(name), const_cast<const GLfloat*>(&values), columns, rows);
}
void QOpenGLShaderProgram_SetAttributeValue17(void* ptr, char* name, void* value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeValue(const_cast<const char*>(name), *static_cast<QColor*>(value));
}
void QOpenGLShaderProgram_SetAttributeValue14(void* ptr, char* name, void* value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeValue(const_cast<const char*>(name), *static_cast<QVector2D*>(value));
}
void QOpenGLShaderProgram_SetAttributeValue15(void* ptr, char* name, void* value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeValue(const_cast<const char*>(name), *static_cast<QVector3D*>(value));
}
void QOpenGLShaderProgram_SetAttributeValue16(void* ptr, char* name, void* value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeValue(const_cast<const char*>(name), *static_cast<QVector4D*>(value));
}
void QOpenGLShaderProgram_SetAttributeValue(void* ptr, int location, float value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeValue(location, value);
}
void QOpenGLShaderProgram_SetAttributeValue2(void* ptr, int location, float x, float y)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeValue(location, x, y);
}
void QOpenGLShaderProgram_SetAttributeValue3(void* ptr, int location, float x, float y, float z)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeValue(location, x, y, z);
}
void QOpenGLShaderProgram_SetAttributeValue4(void* ptr, int location, float x, float y, float z, float w)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeValue(location, x, y, z, w);
}
void QOpenGLShaderProgram_SetAttributeValue9(void* ptr, int location, float values, int columns, int rows)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeValue(location, const_cast<const GLfloat*>(&values), columns, rows);
}
void QOpenGLShaderProgram_SetAttributeValue8(void* ptr, int location, void* value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeValue(location, *static_cast<QColor*>(value));
}
void QOpenGLShaderProgram_SetAttributeValue5(void* ptr, int location, void* value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeValue(location, *static_cast<QVector2D*>(value));
}
void QOpenGLShaderProgram_SetAttributeValue6(void* ptr, int location, void* value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeValue(location, *static_cast<QVector3D*>(value));
}
void QOpenGLShaderProgram_SetAttributeValue7(void* ptr, int location, void* value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setAttributeValue(location, *static_cast<QVector4D*>(value));
}
void QOpenGLShaderProgram_SetDefaultInnerTessellationLevels(void* ptr, void* levels)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setDefaultInnerTessellationLevels(*static_cast<QVector<float>*>(levels));
}
void QOpenGLShaderProgram_SetDefaultOuterTessellationLevels(void* ptr, void* levels)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setDefaultOuterTessellationLevels(*static_cast<QVector<float>*>(levels));
}
void QOpenGLShaderProgram_SetPatchVertexCount(void* ptr, int count)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setPatchVertexCount(count);
}
void QOpenGLShaderProgram_SetUniformValue28(void* ptr, char* name, float value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(const_cast<const char*>(name), value);
}
void QOpenGLShaderProgram_SetUniformValue31(void* ptr, char* name, float x, float y)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(const_cast<const char*>(name), x, y);
}
void QOpenGLShaderProgram_SetUniformValue32(void* ptr, char* name, float x, float y, float z)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(const_cast<const char*>(name), x, y, z);
}
void QOpenGLShaderProgram_SetUniformValue33(void* ptr, char* name, float x, float y, float z, float w)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(const_cast<const char*>(name), x, y, z, w);
}
void QOpenGLShaderProgram_SetUniformValue29(void* ptr, char* name, int value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(const_cast<const char*>(name), value);
}
void QOpenGLShaderProgram_SetUniformValue30(void* ptr, char* name, unsigned int value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(const_cast<const char*>(name), value);
}
void QOpenGLShaderProgram_SetUniformValue37(void* ptr, char* name, void* color)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(const_cast<const char*>(name), *static_cast<QColor*>(color));
}
void QOpenGLShaderProgram_SetUniformValue50(void* ptr, char* name, void* value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(const_cast<const char*>(name), *static_cast<QMatrix4x4*>(value));
}
void QOpenGLShaderProgram_SetUniformValue38(void* ptr, char* name, void* point)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(const_cast<const char*>(name), *static_cast<QPoint*>(point));
}
void QOpenGLShaderProgram_SetUniformValue39(void* ptr, char* name, void* point)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(const_cast<const char*>(name), *static_cast<QPointF*>(point));
}
void QOpenGLShaderProgram_SetUniformValue40(void* ptr, char* name, void* size)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(const_cast<const char*>(name), *static_cast<QSize*>(size));
}
void QOpenGLShaderProgram_SetUniformValue41(void* ptr, char* name, void* size)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(const_cast<const char*>(name), *static_cast<QSizeF*>(size));
}
void QOpenGLShaderProgram_SetUniformValue54(void* ptr, char* name, void* value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(const_cast<const char*>(name), *static_cast<QTransform*>(value));
}
void QOpenGLShaderProgram_SetUniformValue34(void* ptr, char* name, void* value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(const_cast<const char*>(name), *static_cast<QVector2D*>(value));
}
void QOpenGLShaderProgram_SetUniformValue35(void* ptr, char* name, void* value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(const_cast<const char*>(name), *static_cast<QVector3D*>(value));
}
void QOpenGLShaderProgram_SetUniformValue36(void* ptr, char* name, void* value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(const_cast<const char*>(name), *static_cast<QVector4D*>(value));
}
void QOpenGLShaderProgram_SetUniformValue(void* ptr, int location, float value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(location, value);
}
void QOpenGLShaderProgram_SetUniformValue4(void* ptr, int location, float x, float y)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(location, x, y);
}
void QOpenGLShaderProgram_SetUniformValue5(void* ptr, int location, float x, float y, float z)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(location, x, y, z);
}
void QOpenGLShaderProgram_SetUniformValue6(void* ptr, int location, float x, float y, float z, float w)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(location, x, y, z, w);
}
void QOpenGLShaderProgram_SetUniformValue2(void* ptr, int location, int value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(location, value);
}
void QOpenGLShaderProgram_SetUniformValue3(void* ptr, int location, unsigned int value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(location, value);
}
void QOpenGLShaderProgram_SetUniformValue10(void* ptr, int location, void* color)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(location, *static_cast<QColor*>(color));
}
void QOpenGLShaderProgram_SetUniformValue23(void* ptr, int location, void* value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(location, *static_cast<QMatrix4x4*>(value));
}
void QOpenGLShaderProgram_SetUniformValue11(void* ptr, int location, void* point)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(location, *static_cast<QPoint*>(point));
}
void QOpenGLShaderProgram_SetUniformValue12(void* ptr, int location, void* point)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(location, *static_cast<QPointF*>(point));
}
void QOpenGLShaderProgram_SetUniformValue13(void* ptr, int location, void* size)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(location, *static_cast<QSize*>(size));
}
void QOpenGLShaderProgram_SetUniformValue14(void* ptr, int location, void* size)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(location, *static_cast<QSizeF*>(size));
}
void QOpenGLShaderProgram_SetUniformValue27(void* ptr, int location, void* value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(location, *static_cast<QTransform*>(value));
}
void QOpenGLShaderProgram_SetUniformValue7(void* ptr, int location, void* value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(location, *static_cast<QVector2D*>(value));
}
void QOpenGLShaderProgram_SetUniformValue8(void* ptr, int location, void* value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(location, *static_cast<QVector3D*>(value));
}
void QOpenGLShaderProgram_SetUniformValue9(void* ptr, int location, void* value)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValue(location, *static_cast<QVector4D*>(value));
}
void QOpenGLShaderProgram_SetUniformValueArray16(void* ptr, char* name, float values, int count, int tupleSize)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValueArray(const_cast<const char*>(name), const_cast<const GLfloat*>(&values), count, tupleSize);
}
void QOpenGLShaderProgram_SetUniformValueArray17(void* ptr, char* name, int values, int count)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValueArray(const_cast<const char*>(name), const_cast<const GLint*>(&values), count);
}
void QOpenGLShaderProgram_SetUniformValueArray18(void* ptr, char* name, unsigned int values, int count)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValueArray(const_cast<const char*>(name), const_cast<const GLuint*>(&values), count);
}
void QOpenGLShaderProgram_SetUniformValueArray30(void* ptr, char* name, void* values, int count)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValueArray(const_cast<const char*>(name), static_cast<QMatrix4x4*>(values), count);
}
void QOpenGLShaderProgram_SetUniformValueArray19(void* ptr, char* name, void* values, int count)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValueArray(const_cast<const char*>(name), static_cast<QVector2D*>(values), count);
}
void QOpenGLShaderProgram_SetUniformValueArray20(void* ptr, char* name, void* values, int count)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValueArray(const_cast<const char*>(name), static_cast<QVector3D*>(values), count);
}
void QOpenGLShaderProgram_SetUniformValueArray21(void* ptr, char* name, void* values, int count)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValueArray(const_cast<const char*>(name), static_cast<QVector4D*>(values), count);
}
void QOpenGLShaderProgram_SetUniformValueArray(void* ptr, int location, float values, int count, int tupleSize)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValueArray(location, const_cast<const GLfloat*>(&values), count, tupleSize);
}
void QOpenGLShaderProgram_SetUniformValueArray2(void* ptr, int location, int values, int count)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValueArray(location, const_cast<const GLint*>(&values), count);
}
void QOpenGLShaderProgram_SetUniformValueArray3(void* ptr, int location, unsigned int values, int count)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValueArray(location, const_cast<const GLuint*>(&values), count);
}
void QOpenGLShaderProgram_SetUniformValueArray15(void* ptr, int location, void* values, int count)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValueArray(location, static_cast<QMatrix4x4*>(values), count);
}
void QOpenGLShaderProgram_SetUniformValueArray4(void* ptr, int location, void* values, int count)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValueArray(location, static_cast<QVector2D*>(values), count);
}
void QOpenGLShaderProgram_SetUniformValueArray5(void* ptr, int location, void* values, int count)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValueArray(location, static_cast<QVector3D*>(values), count);
}
void QOpenGLShaderProgram_SetUniformValueArray6(void* ptr, int location, void* values, int count)
{
static_cast<QOpenGLShaderProgram*>(ptr)->setUniformValueArray(location, static_cast<QVector4D*>(values), count);
}
void QOpenGLShaderProgram_DestroyQOpenGLShaderProgram(void* ptr)
{
static_cast<QOpenGLShaderProgram*>(ptr)->~QOpenGLShaderProgram();
}
void QOpenGLShaderProgram_DestroyQOpenGLShaderProgramDefault(void* ptr)
{
Q_UNUSED(ptr);
}
unsigned int QOpenGLShaderProgram_ProgramId(void* ptr)
{
return static_cast<QOpenGLShaderProgram*>(ptr)->programId();
}
struct QtGui_PackedList QOpenGLShaderProgram_Shaders(void* ptr)
{
return ({ QList<QOpenGLShader *>* tmpValue = new QList<QOpenGLShader *>(static_cast<QOpenGLShaderProgram*>(ptr)->shaders()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedString QOpenGLShaderProgram_Log(void* ptr)
{
return ({ QByteArray t6e5a96 = static_cast<QOpenGLShaderProgram*>(ptr)->log().toUtf8(); QtGui_PackedString { const_cast<char*>(t6e5a96.prepend("WHITESPACE").constData()+10), t6e5a96.size()-10 }; });
}
struct QtGui_PackedList QOpenGLShaderProgram_DefaultInnerTessellationLevels(void* ptr)
{
return ({ QVector<float>* tmpValue = new QVector<float>(static_cast<QOpenGLShaderProgram*>(ptr)->defaultInnerTessellationLevels()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedList QOpenGLShaderProgram_DefaultOuterTessellationLevels(void* ptr)
{
return ({ QVector<float>* tmpValue = new QVector<float>(static_cast<QOpenGLShaderProgram*>(ptr)->defaultOuterTessellationLevels()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
char QOpenGLShaderProgram_IsLinked(void* ptr)
{
return static_cast<QOpenGLShaderProgram*>(ptr)->isLinked();
}
void* QOpenGLShaderProgram_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QOpenGLShaderProgram*>(ptr)->QOpenGLShaderProgram::metaObject());
}
int QOpenGLShaderProgram_AttributeLocation2(void* ptr, void* name)
{
return static_cast<QOpenGLShaderProgram*>(ptr)->attributeLocation(*static_cast<QByteArray*>(name));
}
int QOpenGLShaderProgram_AttributeLocation3(void* ptr, struct QtGui_PackedString name)
{
return static_cast<QOpenGLShaderProgram*>(ptr)->attributeLocation(QString::fromUtf8(name.data, name.len));
}
int QOpenGLShaderProgram_AttributeLocation(void* ptr, char* name)
{
return static_cast<QOpenGLShaderProgram*>(ptr)->attributeLocation(const_cast<const char*>(name));
}
int QOpenGLShaderProgram_MaxGeometryOutputVertices(void* ptr)
{
return static_cast<QOpenGLShaderProgram*>(ptr)->maxGeometryOutputVertices();
}
int QOpenGLShaderProgram_PatchVertexCount(void* ptr)
{
return static_cast<QOpenGLShaderProgram*>(ptr)->patchVertexCount();
}
int QOpenGLShaderProgram_UniformLocation2(void* ptr, void* name)
{
return static_cast<QOpenGLShaderProgram*>(ptr)->uniformLocation(*static_cast<QByteArray*>(name));
}
int QOpenGLShaderProgram_UniformLocation3(void* ptr, struct QtGui_PackedString name)
{
return static_cast<QOpenGLShaderProgram*>(ptr)->uniformLocation(QString::fromUtf8(name.data, name.len));
}
int QOpenGLShaderProgram_UniformLocation(void* ptr, char* name)
{
return static_cast<QOpenGLShaderProgram*>(ptr)->uniformLocation(const_cast<const char*>(name));
}
float QOpenGLShaderProgram___setDefaultInnerTessellationLevels_levels_atList(void* ptr, int i)
{
return ({float tmp = static_cast<QVector<float>*>(ptr)->at(i); if (i == static_cast<QVector<float>*>(ptr)->size()-1) { static_cast<QVector<float>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QOpenGLShaderProgram___setDefaultInnerTessellationLevels_levels_setList(void* ptr, float i)
{
static_cast<QVector<float>*>(ptr)->append(i);
}
void* QOpenGLShaderProgram___setDefaultInnerTessellationLevels_levels_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<float>();
}
float QOpenGLShaderProgram___setDefaultOuterTessellationLevels_levels_atList(void* ptr, int i)
{
return ({float tmp = static_cast<QVector<float>*>(ptr)->at(i); if (i == static_cast<QVector<float>*>(ptr)->size()-1) { static_cast<QVector<float>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QOpenGLShaderProgram___setDefaultOuterTessellationLevels_levels_setList(void* ptr, float i)
{
static_cast<QVector<float>*>(ptr)->append(i);
}
void* QOpenGLShaderProgram___setDefaultOuterTessellationLevels_levels_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<float>();
}
void* QOpenGLShaderProgram___shaders_atList(void* ptr, int i)
{
return ({QOpenGLShader * tmp = static_cast<QList<QOpenGLShader *>*>(ptr)->at(i); if (i == static_cast<QList<QOpenGLShader *>*>(ptr)->size()-1) { static_cast<QList<QOpenGLShader *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLShaderProgram___shaders_setList(void* ptr, void* i)
{
static_cast<QList<QOpenGLShader *>*>(ptr)->append(static_cast<QOpenGLShader*>(i));
}
void* QOpenGLShaderProgram___shaders_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QOpenGLShader *>();
}
float QOpenGLShaderProgram___defaultInnerTessellationLevels_atList(void* ptr, int i)
{
return ({float tmp = static_cast<QVector<float>*>(ptr)->at(i); if (i == static_cast<QVector<float>*>(ptr)->size()-1) { static_cast<QVector<float>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QOpenGLShaderProgram___defaultInnerTessellationLevels_setList(void* ptr, float i)
{
static_cast<QVector<float>*>(ptr)->append(i);
}
void* QOpenGLShaderProgram___defaultInnerTessellationLevels_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<float>();
}
float QOpenGLShaderProgram___defaultOuterTessellationLevels_atList(void* ptr, int i)
{
return ({float tmp = static_cast<QVector<float>*>(ptr)->at(i); if (i == static_cast<QVector<float>*>(ptr)->size()-1) { static_cast<QVector<float>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QOpenGLShaderProgram___defaultOuterTessellationLevels_setList(void* ptr, float i)
{
static_cast<QVector<float>*>(ptr)->append(i);
}
void* QOpenGLShaderProgram___defaultOuterTessellationLevels_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<float>();
}
void* QOpenGLShaderProgram___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QOpenGLShaderProgram___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QOpenGLShaderProgram___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QOpenGLShaderProgram___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLShaderProgram___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLShaderProgram___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOpenGLShaderProgram___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLShaderProgram___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLShaderProgram___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOpenGLShaderProgram___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLShaderProgram___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLShaderProgram___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOpenGLShaderProgram___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLShaderProgram___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLShaderProgram___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QOpenGLShaderProgram_EventDefault(void* ptr, void* e)
{
return static_cast<QOpenGLShaderProgram*>(ptr)->QOpenGLShaderProgram::event(static_cast<QEvent*>(e));
}
char QOpenGLShaderProgram_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLShaderProgram*>(ptr)->QOpenGLShaderProgram::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLShaderProgram*>(ptr)->QOpenGLShaderProgram::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLShaderProgram*>(ptr)->QOpenGLShaderProgram::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLShaderProgram*>(ptr)->QOpenGLShaderProgram::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QOpenGLShaderProgram*>(ptr)->QOpenGLShaderProgram::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QOpenGLShaderProgram_ChildEventDefault(void* ptr, void* event)
{
static_cast<QOpenGLShaderProgram*>(ptr)->QOpenGLShaderProgram::childEvent(static_cast<QChildEvent*>(event));
}
void QOpenGLShaderProgram_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QOpenGLShaderProgram*>(ptr)->QOpenGLShaderProgram::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QOpenGLShaderProgram_CustomEventDefault(void* ptr, void* event)
{
static_cast<QOpenGLShaderProgram*>(ptr)->QOpenGLShaderProgram::customEvent(static_cast<QEvent*>(event));
}
void QOpenGLShaderProgram_DeleteLaterDefault(void* ptr)
{
static_cast<QOpenGLShaderProgram*>(ptr)->QOpenGLShaderProgram::deleteLater();
}
void QOpenGLShaderProgram_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QOpenGLShaderProgram*>(ptr)->QOpenGLShaderProgram::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QOpenGLShaderProgram_TimerEventDefault(void* ptr, void* event)
{
static_cast<QOpenGLShaderProgram*>(ptr)->QOpenGLShaderProgram::timerEvent(static_cast<QTimerEvent*>(event));
}
unsigned int QOpenGLTexture_QOpenGLTexture_BoundTextureId(long long target)
{
return QOpenGLTexture::boundTextureId(static_cast<QOpenGLTexture::BindingTarget>(target));
}
unsigned int QOpenGLTexture_QOpenGLTexture_BoundTextureId2(unsigned int unit, long long target)
{
return QOpenGLTexture::boundTextureId(unit, static_cast<QOpenGLTexture::BindingTarget>(target));
}
void* QOpenGLTexture_NewQOpenGLTexture(long long target)
{
return new QOpenGLTexture(static_cast<QOpenGLTexture::Target>(target));
}
void* QOpenGLTexture_NewQOpenGLTexture2(void* image, long long genMipMaps)
{
return new QOpenGLTexture(*static_cast<QImage*>(image), static_cast<QOpenGLTexture::MipMapGeneration>(genMipMaps));
}
char QOpenGLTexture_Create(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->create();
}
char QOpenGLTexture_QOpenGLTexture_HasFeature(long long feature)
{
return QOpenGLTexture::hasFeature(static_cast<QOpenGLTexture::Feature>(feature));
}
char QOpenGLTexture_IsBound2(void* ptr, unsigned int unit)
{
return static_cast<QOpenGLTexture*>(ptr)->isBound(unit);
}
void QOpenGLTexture_AllocateStorage(void* ptr)
{
static_cast<QOpenGLTexture*>(ptr)->allocateStorage();
}
void QOpenGLTexture_AllocateStorage2(void* ptr, long long pixelFormat, long long pixelType)
{
static_cast<QOpenGLTexture*>(ptr)->allocateStorage(static_cast<QOpenGLTexture::PixelFormat>(pixelFormat), static_cast<QOpenGLTexture::PixelType>(pixelType));
}
void QOpenGLTexture_Bind(void* ptr)
{
static_cast<QOpenGLTexture*>(ptr)->bind();
}
void QOpenGLTexture_Bind2(void* ptr, unsigned int unit, long long reset)
{
static_cast<QOpenGLTexture*>(ptr)->bind(unit, static_cast<QOpenGLTexture::TextureUnitReset>(reset));
}
void QOpenGLTexture_Destroy(void* ptr)
{
static_cast<QOpenGLTexture*>(ptr)->destroy();
}
void QOpenGLTexture_GenerateMipMaps(void* ptr)
{
static_cast<QOpenGLTexture*>(ptr)->generateMipMaps();
}
void QOpenGLTexture_GenerateMipMaps2(void* ptr, int baseLevel, char resetBaseLevel)
{
static_cast<QOpenGLTexture*>(ptr)->generateMipMaps(baseLevel, resetBaseLevel != 0);
}
void QOpenGLTexture_Release(void* ptr)
{
static_cast<QOpenGLTexture*>(ptr)->release();
}
void QOpenGLTexture_Release2(void* ptr, unsigned int unit, long long reset)
{
static_cast<QOpenGLTexture*>(ptr)->release(unit, static_cast<QOpenGLTexture::TextureUnitReset>(reset));
}
void QOpenGLTexture_SetAutoMipMapGenerationEnabled(void* ptr, char enabled)
{
static_cast<QOpenGLTexture*>(ptr)->setAutoMipMapGenerationEnabled(enabled != 0);
}
void QOpenGLTexture_SetBorderColor(void* ptr, void* color)
{
static_cast<QOpenGLTexture*>(ptr)->setBorderColor(*static_cast<QColor*>(color));
}
void QOpenGLTexture_SetBorderColor2(void* ptr, float r, float g, float b, float a)
{
static_cast<QOpenGLTexture*>(ptr)->setBorderColor(r, g, b, a);
}
void QOpenGLTexture_SetBorderColor3(void* ptr, int r, int g, int b, int a)
{
static_cast<QOpenGLTexture*>(ptr)->setBorderColor(r, g, b, a);
}
void QOpenGLTexture_SetBorderColor4(void* ptr, unsigned int r, unsigned int g, unsigned int b, unsigned int a)
{
static_cast<QOpenGLTexture*>(ptr)->setBorderColor(r, g, b, a);
}
void QOpenGLTexture_SetComparisonFunction(void* ptr, long long function)
{
static_cast<QOpenGLTexture*>(ptr)->setComparisonFunction(static_cast<QOpenGLTexture::ComparisonFunction>(function));
}
void QOpenGLTexture_SetComparisonMode(void* ptr, long long mode)
{
static_cast<QOpenGLTexture*>(ptr)->setComparisonMode(static_cast<QOpenGLTexture::ComparisonMode>(mode));
}
void QOpenGLTexture_SetCompressedData9(void* ptr, int dataSize, void* data, void* options)
{
static_cast<QOpenGLTexture*>(ptr)->setCompressedData(dataSize, data, static_cast<QOpenGLPixelTransferOptions*>(options));
}
void QOpenGLTexture_SetCompressedData8(void* ptr, int mipLevel, int dataSize, void* data, void* options)
{
static_cast<QOpenGLTexture*>(ptr)->setCompressedData(mipLevel, dataSize, data, static_cast<QOpenGLPixelTransferOptions*>(options));
}
void QOpenGLTexture_SetCompressedData(void* ptr, int mipLevel, int layer, long long cubeFace, int dataSize, void* data, void* options)
{
static_cast<QOpenGLTexture*>(ptr)->setCompressedData(mipLevel, layer, static_cast<QOpenGLTexture::CubeMapFace>(cubeFace), dataSize, data, static_cast<QOpenGLPixelTransferOptions*>(options));
}
void QOpenGLTexture_SetCompressedData7(void* ptr, int mipLevel, int layer, int dataSize, void* data, void* options)
{
static_cast<QOpenGLTexture*>(ptr)->setCompressedData(mipLevel, layer, dataSize, data, static_cast<QOpenGLPixelTransferOptions*>(options));
}
void QOpenGLTexture_SetCompressedData6(void* ptr, int mipLevel, int layer, int layerCount, long long cubeFace, int dataSize, void* data, void* options)
{
static_cast<QOpenGLTexture*>(ptr)->setCompressedData(mipLevel, layer, layerCount, static_cast<QOpenGLTexture::CubeMapFace>(cubeFace), dataSize, data, static_cast<QOpenGLPixelTransferOptions*>(options));
}
void QOpenGLTexture_SetData9(void* ptr, long long sourceFormat, long long sourceType, void* data, void* options)
{
static_cast<QOpenGLTexture*>(ptr)->setData(static_cast<QOpenGLTexture::PixelFormat>(sourceFormat), static_cast<QOpenGLTexture::PixelType>(sourceType), data, static_cast<QOpenGLPixelTransferOptions*>(options));
}
void QOpenGLTexture_SetData10(void* ptr, void* image, long long genMipMaps)
{
static_cast<QOpenGLTexture*>(ptr)->setData(*static_cast<QImage*>(image), static_cast<QOpenGLTexture::MipMapGeneration>(genMipMaps));
}
void QOpenGLTexture_SetData8(void* ptr, int mipLevel, long long sourceFormat, long long sourceType, void* data, void* options)
{
static_cast<QOpenGLTexture*>(ptr)->setData(mipLevel, static_cast<QOpenGLTexture::PixelFormat>(sourceFormat), static_cast<QOpenGLTexture::PixelType>(sourceType), data, static_cast<QOpenGLPixelTransferOptions*>(options));
}
void QOpenGLTexture_SetData(void* ptr, int mipLevel, int layer, long long cubeFace, long long sourceFormat, long long sourceType, void* data, void* options)
{
static_cast<QOpenGLTexture*>(ptr)->setData(mipLevel, layer, static_cast<QOpenGLTexture::CubeMapFace>(cubeFace), static_cast<QOpenGLTexture::PixelFormat>(sourceFormat), static_cast<QOpenGLTexture::PixelType>(sourceType), data, static_cast<QOpenGLPixelTransferOptions*>(options));
}
void QOpenGLTexture_SetData7(void* ptr, int mipLevel, int layer, long long sourceFormat, long long sourceType, void* data, void* options)
{
static_cast<QOpenGLTexture*>(ptr)->setData(mipLevel, layer, static_cast<QOpenGLTexture::PixelFormat>(sourceFormat), static_cast<QOpenGLTexture::PixelType>(sourceType), data, static_cast<QOpenGLPixelTransferOptions*>(options));
}
void QOpenGLTexture_SetData6(void* ptr, int mipLevel, int layer, int layerCount, long long cubeFace, long long sourceFormat, long long sourceType, void* data, void* options)
{
static_cast<QOpenGLTexture*>(ptr)->setData(mipLevel, layer, layerCount, static_cast<QOpenGLTexture::CubeMapFace>(cubeFace), static_cast<QOpenGLTexture::PixelFormat>(sourceFormat), static_cast<QOpenGLTexture::PixelType>(sourceType), data, static_cast<QOpenGLPixelTransferOptions*>(options));
}
void QOpenGLTexture_SetDepthStencilMode(void* ptr, long long mode)
{
static_cast<QOpenGLTexture*>(ptr)->setDepthStencilMode(static_cast<QOpenGLTexture::DepthStencilMode>(mode));
}
void QOpenGLTexture_SetFixedSamplePositions(void* ptr, char fixed)
{
static_cast<QOpenGLTexture*>(ptr)->setFixedSamplePositions(fixed != 0);
}
void QOpenGLTexture_SetFormat(void* ptr, long long format)
{
static_cast<QOpenGLTexture*>(ptr)->setFormat(static_cast<QOpenGLTexture::TextureFormat>(format));
}
void QOpenGLTexture_SetLayers(void* ptr, int layers)
{
static_cast<QOpenGLTexture*>(ptr)->setLayers(layers);
}
void QOpenGLTexture_SetLevelOfDetailRange(void* ptr, float min, float max)
{
static_cast<QOpenGLTexture*>(ptr)->setLevelOfDetailRange(min, max);
}
void QOpenGLTexture_SetLevelofDetailBias(void* ptr, float bias)
{
static_cast<QOpenGLTexture*>(ptr)->setLevelofDetailBias(bias);
}
void QOpenGLTexture_SetMagnificationFilter(void* ptr, long long filter)
{
static_cast<QOpenGLTexture*>(ptr)->setMagnificationFilter(static_cast<QOpenGLTexture::Filter>(filter));
}
void QOpenGLTexture_SetMaximumAnisotropy(void* ptr, float anisotropy)
{
static_cast<QOpenGLTexture*>(ptr)->setMaximumAnisotropy(anisotropy);
}
void QOpenGLTexture_SetMaximumLevelOfDetail(void* ptr, float value)
{
static_cast<QOpenGLTexture*>(ptr)->setMaximumLevelOfDetail(value);
}
void QOpenGLTexture_SetMinMagFilters(void* ptr, long long minificationFilter, long long magnificationFilter)
{
static_cast<QOpenGLTexture*>(ptr)->setMinMagFilters(static_cast<QOpenGLTexture::Filter>(minificationFilter), static_cast<QOpenGLTexture::Filter>(magnificationFilter));
}
void QOpenGLTexture_SetMinificationFilter(void* ptr, long long filter)
{
static_cast<QOpenGLTexture*>(ptr)->setMinificationFilter(static_cast<QOpenGLTexture::Filter>(filter));
}
void QOpenGLTexture_SetMinimumLevelOfDetail(void* ptr, float value)
{
static_cast<QOpenGLTexture*>(ptr)->setMinimumLevelOfDetail(value);
}
void QOpenGLTexture_SetMipBaseLevel(void* ptr, int baseLevel)
{
static_cast<QOpenGLTexture*>(ptr)->setMipBaseLevel(baseLevel);
}
void QOpenGLTexture_SetMipLevelRange(void* ptr, int baseLevel, int maxLevel)
{
static_cast<QOpenGLTexture*>(ptr)->setMipLevelRange(baseLevel, maxLevel);
}
void QOpenGLTexture_SetMipLevels(void* ptr, int levels)
{
static_cast<QOpenGLTexture*>(ptr)->setMipLevels(levels);
}
void QOpenGLTexture_SetMipMaxLevel(void* ptr, int maxLevel)
{
static_cast<QOpenGLTexture*>(ptr)->setMipMaxLevel(maxLevel);
}
void QOpenGLTexture_SetSamples(void* ptr, int samples)
{
static_cast<QOpenGLTexture*>(ptr)->setSamples(samples);
}
void QOpenGLTexture_SetSize(void* ptr, int width, int height, int depth)
{
static_cast<QOpenGLTexture*>(ptr)->setSize(width, height, depth);
}
void QOpenGLTexture_SetSwizzleMask(void* ptr, long long component, long long value)
{
static_cast<QOpenGLTexture*>(ptr)->setSwizzleMask(static_cast<QOpenGLTexture::SwizzleComponent>(component), static_cast<QOpenGLTexture::SwizzleValue>(value));
}
void QOpenGLTexture_SetSwizzleMask2(void* ptr, long long r, long long g, long long b, long long a)
{
static_cast<QOpenGLTexture*>(ptr)->setSwizzleMask(static_cast<QOpenGLTexture::SwizzleValue>(r), static_cast<QOpenGLTexture::SwizzleValue>(g), static_cast<QOpenGLTexture::SwizzleValue>(b), static_cast<QOpenGLTexture::SwizzleValue>(a));
}
void QOpenGLTexture_SetWrapMode2(void* ptr, long long direction, long long mode)
{
static_cast<QOpenGLTexture*>(ptr)->setWrapMode(static_cast<QOpenGLTexture::CoordinateDirection>(direction), static_cast<QOpenGLTexture::WrapMode>(mode));
}
void QOpenGLTexture_SetWrapMode(void* ptr, long long mode)
{
static_cast<QOpenGLTexture*>(ptr)->setWrapMode(static_cast<QOpenGLTexture::WrapMode>(mode));
}
void QOpenGLTexture_DestroyQOpenGLTexture(void* ptr)
{
static_cast<QOpenGLTexture*>(ptr)->~QOpenGLTexture();
}
unsigned int QOpenGLTexture_TextureId(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->textureId();
}
void* QOpenGLTexture_BorderColor(void* ptr)
{
return new QColor(static_cast<QOpenGLTexture*>(ptr)->borderColor());
}
void* QOpenGLTexture_CreateTextureView(void* ptr, long long target, long long viewFormat, int minimumMipmapLevel, int maximumMipmapLevel, int minimumLayer, int maximumLayer)
{
return static_cast<QOpenGLTexture*>(ptr)->createTextureView(static_cast<QOpenGLTexture::Target>(target), static_cast<QOpenGLTexture::TextureFormat>(viewFormat), minimumMipmapLevel, maximumMipmapLevel, minimumLayer, maximumLayer);
}
long long QOpenGLTexture_ComparisonFunction(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->comparisonFunction();
}
long long QOpenGLTexture_ComparisonMode(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->comparisonMode();
}
long long QOpenGLTexture_DepthStencilMode(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->depthStencilMode();
}
long long QOpenGLTexture_MagnificationFilter(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->magnificationFilter();
}
long long QOpenGLTexture_MinificationFilter(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->minificationFilter();
}
long long QOpenGLTexture_SwizzleMask(void* ptr, long long component)
{
return static_cast<QOpenGLTexture*>(ptr)->swizzleMask(static_cast<QOpenGLTexture::SwizzleComponent>(component));
}
long long QOpenGLTexture_Target(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->target();
}
long long QOpenGLTexture_Format(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->format();
}
long long QOpenGLTexture_WrapMode(void* ptr, long long direction)
{
return static_cast<QOpenGLTexture*>(ptr)->wrapMode(static_cast<QOpenGLTexture::CoordinateDirection>(direction));
}
char QOpenGLTexture_IsAutoMipMapGenerationEnabled(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->isAutoMipMapGenerationEnabled();
}
char QOpenGLTexture_IsBound(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->isBound();
}
char QOpenGLTexture_IsCreated(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->isCreated();
}
char QOpenGLTexture_IsFixedSamplePositions(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->isFixedSamplePositions();
}
char QOpenGLTexture_IsStorageAllocated(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->isStorageAllocated();
}
char QOpenGLTexture_IsTextureView(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->isTextureView();
}
float QOpenGLTexture_LevelofDetailBias(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->levelofDetailBias();
}
float QOpenGLTexture_MaximumAnisotropy(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->maximumAnisotropy();
}
float QOpenGLTexture_MaximumLevelOfDetail(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->maximumLevelOfDetail();
}
float QOpenGLTexture_MinimumLevelOfDetail(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->minimumLevelOfDetail();
}
int QOpenGLTexture_Depth(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->depth();
}
int QOpenGLTexture_Faces(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->faces();
}
int QOpenGLTexture_Height(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->height();
}
int QOpenGLTexture_Layers(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->layers();
}
int QOpenGLTexture_MaximumMipLevels(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->maximumMipLevels();
}
int QOpenGLTexture_MipBaseLevel(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->mipBaseLevel();
}
int QOpenGLTexture_MipLevels(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->mipLevels();
}
int QOpenGLTexture_MipMaxLevel(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->mipMaxLevel();
}
int QOpenGLTexture_Samples(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->samples();
}
int QOpenGLTexture_Width(void* ptr)
{
return static_cast<QOpenGLTexture*>(ptr)->width();
}
void QOpenGLTexture_BorderColor2(void* ptr, float border)
{
static_cast<QOpenGLTexture*>(ptr)->borderColor(&border);
}
void QOpenGLTexture_BorderColor3(void* ptr, int border)
{
static_cast<QOpenGLTexture*>(ptr)->borderColor(&border);
}
void QOpenGLTexture_BorderColor4(void* ptr, unsigned int border)
{
static_cast<QOpenGLTexture*>(ptr)->borderColor(&border);
}
void* QOpenGLTextureBlitter_QOpenGLTextureBlitter_TargetTransform(void* target, void* viewport)
{
return new QMatrix4x4(QOpenGLTextureBlitter::targetTransform(*static_cast<QRectF*>(target), *static_cast<QRect*>(viewport)));
}
void* QOpenGLTextureBlitter_NewQOpenGLTextureBlitter()
{
return new QOpenGLTextureBlitter();
}
char QOpenGLTextureBlitter_Create(void* ptr)
{
return static_cast<QOpenGLTextureBlitter*>(ptr)->create();
}
void QOpenGLTextureBlitter_Bind(void* ptr, unsigned int target)
{
static_cast<QOpenGLTextureBlitter*>(ptr)->bind(target);
}
void QOpenGLTextureBlitter_Blit(void* ptr, unsigned int texture, void* targetTransform, long long sourceOrigin)
{
static_cast<QOpenGLTextureBlitter*>(ptr)->blit(texture, *static_cast<QMatrix4x4*>(targetTransform), static_cast<QOpenGLTextureBlitter::Origin>(sourceOrigin));
}
void QOpenGLTextureBlitter_Destroy(void* ptr)
{
static_cast<QOpenGLTextureBlitter*>(ptr)->destroy();
}
void QOpenGLTextureBlitter_Release(void* ptr)
{
static_cast<QOpenGLTextureBlitter*>(ptr)->release();
}
void QOpenGLTextureBlitter_SetOpacity(void* ptr, float opacity)
{
static_cast<QOpenGLTextureBlitter*>(ptr)->setOpacity(opacity);
}
void QOpenGLTextureBlitter_SetRedBlueSwizzle(void* ptr, char swizzle)
{
static_cast<QOpenGLTextureBlitter*>(ptr)->setRedBlueSwizzle(swizzle != 0);
}
void QOpenGLTextureBlitter_DestroyQOpenGLTextureBlitter(void* ptr)
{
static_cast<QOpenGLTextureBlitter*>(ptr)->~QOpenGLTextureBlitter();
}
char QOpenGLTextureBlitter_IsCreated(void* ptr)
{
return static_cast<QOpenGLTextureBlitter*>(ptr)->isCreated();
}
char QOpenGLTextureBlitter_SupportsExternalOESTarget(void* ptr)
{
return static_cast<QOpenGLTextureBlitter*>(ptr)->supportsExternalOESTarget();
}
class MyQOpenGLTimeMonitor: public QOpenGLTimeMonitor
{
public:
MyQOpenGLTimeMonitor(QObject *parent = Q_NULLPTR) : QOpenGLTimeMonitor(parent) {QOpenGLTimeMonitor_QOpenGLTimeMonitor_QRegisterMetaType();};
~MyQOpenGLTimeMonitor() { callbackQOpenGLTimeMonitor_DestroyQOpenGLTimeMonitor(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQOpenGLTimeMonitor_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQOpenGLTimeMonitor_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQOpenGLTimeMonitor_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQOpenGLTimeMonitor_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQOpenGLTimeMonitor_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQOpenGLTimeMonitor_CustomEvent(this, event); };
void deleteLater() { callbackQOpenGLTimeMonitor_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQOpenGLTimeMonitor_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQOpenGLTimeMonitor_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQOpenGLTimeMonitor_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQOpenGLTimeMonitor_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQOpenGLTimeMonitor*)
int QOpenGLTimeMonitor_QOpenGLTimeMonitor_QRegisterMetaType(){qRegisterMetaType<QOpenGLTimeMonitor*>(); return qRegisterMetaType<MyQOpenGLTimeMonitor*>();}
void* QOpenGLTimeMonitor_NewQOpenGLTimeMonitor(void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimeMonitor(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimeMonitor(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimeMonitor(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimeMonitor(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimeMonitor(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimeMonitor(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimeMonitor(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimeMonitor(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimeMonitor(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimeMonitor(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimeMonitor(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimeMonitor(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimeMonitor(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimeMonitor(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimeMonitor(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimeMonitor(static_cast<QWindow*>(parent));
} else {
return new MyQOpenGLTimeMonitor(static_cast<QObject*>(parent));
}
}
struct QtGui_PackedString QOpenGLTimeMonitor_QOpenGLTimeMonitor_Tr(char* s, char* c, int n)
{
return ({ QByteArray tca25e9 = QOpenGLTimeMonitor::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(tca25e9.prepend("WHITESPACE").constData()+10), tca25e9.size()-10 }; });
}
struct QtGui_PackedString QOpenGLTimeMonitor_QOpenGLTimeMonitor_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray tbb13c4 = QOpenGLTimeMonitor::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(tbb13c4.prepend("WHITESPACE").constData()+10), tbb13c4.size()-10 }; });
}
char QOpenGLTimeMonitor_Create(void* ptr)
{
return static_cast<QOpenGLTimeMonitor*>(ptr)->create();
}
int QOpenGLTimeMonitor_RecordSample(void* ptr)
{
return static_cast<QOpenGLTimeMonitor*>(ptr)->recordSample();
}
void QOpenGLTimeMonitor_Destroy(void* ptr)
{
static_cast<QOpenGLTimeMonitor*>(ptr)->destroy();
}
void QOpenGLTimeMonitor_Reset(void* ptr)
{
static_cast<QOpenGLTimeMonitor*>(ptr)->reset();
}
void QOpenGLTimeMonitor_SetSampleCount(void* ptr, int sampleCount)
{
static_cast<QOpenGLTimeMonitor*>(ptr)->setSampleCount(sampleCount);
}
void QOpenGLTimeMonitor_DestroyQOpenGLTimeMonitor(void* ptr)
{
static_cast<QOpenGLTimeMonitor*>(ptr)->~QOpenGLTimeMonitor();
}
void QOpenGLTimeMonitor_DestroyQOpenGLTimeMonitorDefault(void* ptr)
{
Q_UNUSED(ptr);
}
struct QtGui_PackedList QOpenGLTimeMonitor_ObjectIds(void* ptr)
{
return ({ QVector<GLuint>* tmpValue = new QVector<GLuint>(static_cast<QOpenGLTimeMonitor*>(ptr)->objectIds()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
char QOpenGLTimeMonitor_IsCreated(void* ptr)
{
return static_cast<QOpenGLTimeMonitor*>(ptr)->isCreated();
}
char QOpenGLTimeMonitor_IsResultAvailable(void* ptr)
{
return static_cast<QOpenGLTimeMonitor*>(ptr)->isResultAvailable();
}
void* QOpenGLTimeMonitor_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QOpenGLTimeMonitor*>(ptr)->QOpenGLTimeMonitor::metaObject());
}
int QOpenGLTimeMonitor_SampleCount(void* ptr)
{
return static_cast<QOpenGLTimeMonitor*>(ptr)->sampleCount();
}
void* QOpenGLTimeMonitor___waitForIntervals_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<GLuint64>();
}
void* QOpenGLTimeMonitor___waitForSamples_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<GLuint64>();
}
unsigned int QOpenGLTimeMonitor___objectIds_atList(void* ptr, int i)
{
return ({GLuint tmp = static_cast<QVector<GLuint>*>(ptr)->at(i); if (i == static_cast<QVector<GLuint>*>(ptr)->size()-1) { static_cast<QVector<GLuint>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QOpenGLTimeMonitor___objectIds_setList(void* ptr, unsigned int i)
{
static_cast<QVector<GLuint>*>(ptr)->append(i);
}
void* QOpenGLTimeMonitor___objectIds_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<GLuint>();
}
void* QOpenGLTimeMonitor___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QOpenGLTimeMonitor___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QOpenGLTimeMonitor___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QOpenGLTimeMonitor___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLTimeMonitor___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLTimeMonitor___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOpenGLTimeMonitor___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLTimeMonitor___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLTimeMonitor___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOpenGLTimeMonitor___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLTimeMonitor___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLTimeMonitor___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOpenGLTimeMonitor___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLTimeMonitor___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLTimeMonitor___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QOpenGLTimeMonitor_EventDefault(void* ptr, void* e)
{
return static_cast<QOpenGLTimeMonitor*>(ptr)->QOpenGLTimeMonitor::event(static_cast<QEvent*>(e));
}
char QOpenGLTimeMonitor_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLTimeMonitor*>(ptr)->QOpenGLTimeMonitor::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLTimeMonitor*>(ptr)->QOpenGLTimeMonitor::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLTimeMonitor*>(ptr)->QOpenGLTimeMonitor::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLTimeMonitor*>(ptr)->QOpenGLTimeMonitor::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QOpenGLTimeMonitor*>(ptr)->QOpenGLTimeMonitor::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QOpenGLTimeMonitor_ChildEventDefault(void* ptr, void* event)
{
static_cast<QOpenGLTimeMonitor*>(ptr)->QOpenGLTimeMonitor::childEvent(static_cast<QChildEvent*>(event));
}
void QOpenGLTimeMonitor_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QOpenGLTimeMonitor*>(ptr)->QOpenGLTimeMonitor::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QOpenGLTimeMonitor_CustomEventDefault(void* ptr, void* event)
{
static_cast<QOpenGLTimeMonitor*>(ptr)->QOpenGLTimeMonitor::customEvent(static_cast<QEvent*>(event));
}
void QOpenGLTimeMonitor_DeleteLaterDefault(void* ptr)
{
static_cast<QOpenGLTimeMonitor*>(ptr)->QOpenGLTimeMonitor::deleteLater();
}
void QOpenGLTimeMonitor_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QOpenGLTimeMonitor*>(ptr)->QOpenGLTimeMonitor::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QOpenGLTimeMonitor_TimerEventDefault(void* ptr, void* event)
{
static_cast<QOpenGLTimeMonitor*>(ptr)->QOpenGLTimeMonitor::timerEvent(static_cast<QTimerEvent*>(event));
}
class MyQOpenGLTimerQuery: public QOpenGLTimerQuery
{
public:
MyQOpenGLTimerQuery(QObject *parent = Q_NULLPTR) : QOpenGLTimerQuery(parent) {QOpenGLTimerQuery_QOpenGLTimerQuery_QRegisterMetaType();};
~MyQOpenGLTimerQuery() { callbackQOpenGLTimerQuery_DestroyQOpenGLTimerQuery(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQOpenGLTimerQuery_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQOpenGLTimerQuery_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQOpenGLTimerQuery_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQOpenGLTimerQuery_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQOpenGLTimerQuery_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQOpenGLTimerQuery_CustomEvent(this, event); };
void deleteLater() { callbackQOpenGLTimerQuery_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQOpenGLTimerQuery_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQOpenGLTimerQuery_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQOpenGLTimerQuery_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQOpenGLTimerQuery_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQOpenGLTimerQuery*)
int QOpenGLTimerQuery_QOpenGLTimerQuery_QRegisterMetaType(){qRegisterMetaType<QOpenGLTimerQuery*>(); return qRegisterMetaType<MyQOpenGLTimerQuery*>();}
void* QOpenGLTimerQuery_NewQOpenGLTimerQuery(void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimerQuery(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimerQuery(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimerQuery(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimerQuery(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimerQuery(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimerQuery(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimerQuery(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimerQuery(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimerQuery(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimerQuery(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimerQuery(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimerQuery(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimerQuery(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimerQuery(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimerQuery(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLTimerQuery(static_cast<QWindow*>(parent));
} else {
return new MyQOpenGLTimerQuery(static_cast<QObject*>(parent));
}
}
struct QtGui_PackedString QOpenGLTimerQuery_QOpenGLTimerQuery_Tr(char* s, char* c, int n)
{
return ({ QByteArray tfff934 = QOpenGLTimerQuery::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(tfff934.prepend("WHITESPACE").constData()+10), tfff934.size()-10 }; });
}
struct QtGui_PackedString QOpenGLTimerQuery_QOpenGLTimerQuery_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray tb3b15d = QOpenGLTimerQuery::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(tb3b15d.prepend("WHITESPACE").constData()+10), tb3b15d.size()-10 }; });
}
char QOpenGLTimerQuery_Create(void* ptr)
{
return static_cast<QOpenGLTimerQuery*>(ptr)->create();
}
void QOpenGLTimerQuery_Begin(void* ptr)
{
static_cast<QOpenGLTimerQuery*>(ptr)->begin();
}
void QOpenGLTimerQuery_Destroy(void* ptr)
{
static_cast<QOpenGLTimerQuery*>(ptr)->destroy();
}
void QOpenGLTimerQuery_End(void* ptr)
{
static_cast<QOpenGLTimerQuery*>(ptr)->end();
}
void QOpenGLTimerQuery_RecordTimestamp(void* ptr)
{
static_cast<QOpenGLTimerQuery*>(ptr)->recordTimestamp();
}
void QOpenGLTimerQuery_DestroyQOpenGLTimerQuery(void* ptr)
{
static_cast<QOpenGLTimerQuery*>(ptr)->~QOpenGLTimerQuery();
}
void QOpenGLTimerQuery_DestroyQOpenGLTimerQueryDefault(void* ptr)
{
Q_UNUSED(ptr);
}
unsigned int QOpenGLTimerQuery_ObjectId(void* ptr)
{
return static_cast<QOpenGLTimerQuery*>(ptr)->objectId();
}
char QOpenGLTimerQuery_IsCreated(void* ptr)
{
return static_cast<QOpenGLTimerQuery*>(ptr)->isCreated();
}
char QOpenGLTimerQuery_IsResultAvailable(void* ptr)
{
return static_cast<QOpenGLTimerQuery*>(ptr)->isResultAvailable();
}
void* QOpenGLTimerQuery_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QOpenGLTimerQuery*>(ptr)->QOpenGLTimerQuery::metaObject());
}
void* QOpenGLTimerQuery___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QOpenGLTimerQuery___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QOpenGLTimerQuery___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QOpenGLTimerQuery___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLTimerQuery___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLTimerQuery___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOpenGLTimerQuery___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLTimerQuery___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLTimerQuery___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOpenGLTimerQuery___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLTimerQuery___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLTimerQuery___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOpenGLTimerQuery___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLTimerQuery___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLTimerQuery___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QOpenGLTimerQuery_EventDefault(void* ptr, void* e)
{
return static_cast<QOpenGLTimerQuery*>(ptr)->QOpenGLTimerQuery::event(static_cast<QEvent*>(e));
}
char QOpenGLTimerQuery_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLTimerQuery*>(ptr)->QOpenGLTimerQuery::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLTimerQuery*>(ptr)->QOpenGLTimerQuery::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLTimerQuery*>(ptr)->QOpenGLTimerQuery::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLTimerQuery*>(ptr)->QOpenGLTimerQuery::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QOpenGLTimerQuery*>(ptr)->QOpenGLTimerQuery::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QOpenGLTimerQuery_ChildEventDefault(void* ptr, void* event)
{
static_cast<QOpenGLTimerQuery*>(ptr)->QOpenGLTimerQuery::childEvent(static_cast<QChildEvent*>(event));
}
void QOpenGLTimerQuery_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QOpenGLTimerQuery*>(ptr)->QOpenGLTimerQuery::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QOpenGLTimerQuery_CustomEventDefault(void* ptr, void* event)
{
static_cast<QOpenGLTimerQuery*>(ptr)->QOpenGLTimerQuery::customEvent(static_cast<QEvent*>(event));
}
void QOpenGLTimerQuery_DeleteLaterDefault(void* ptr)
{
static_cast<QOpenGLTimerQuery*>(ptr)->QOpenGLTimerQuery::deleteLater();
}
void QOpenGLTimerQuery_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QOpenGLTimerQuery*>(ptr)->QOpenGLTimerQuery::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QOpenGLTimerQuery_TimerEventDefault(void* ptr, void* event)
{
static_cast<QOpenGLTimerQuery*>(ptr)->QOpenGLTimerQuery::timerEvent(static_cast<QTimerEvent*>(event));
}
void* QOpenGLVersionProfile_NewQOpenGLVersionProfile()
{
return new QOpenGLVersionProfile();
}
void* QOpenGLVersionProfile_NewQOpenGLVersionProfile3(void* other)
{
return new QOpenGLVersionProfile(*static_cast<QOpenGLVersionProfile*>(other));
}
void* QOpenGLVersionProfile_NewQOpenGLVersionProfile2(void* format)
{
return new QOpenGLVersionProfile(*static_cast<QSurfaceFormat*>(format));
}
void QOpenGLVersionProfile_SetProfile(void* ptr, long long profile)
{
static_cast<QOpenGLVersionProfile*>(ptr)->setProfile(static_cast<QSurfaceFormat::OpenGLContextProfile>(profile));
}
void QOpenGLVersionProfile_SetVersion(void* ptr, int majorVersion, int minorVersion)
{
static_cast<QOpenGLVersionProfile*>(ptr)->setVersion(majorVersion, minorVersion);
}
void QOpenGLVersionProfile_DestroyQOpenGLVersionProfile(void* ptr)
{
static_cast<QOpenGLVersionProfile*>(ptr)->~QOpenGLVersionProfile();
}
long long QOpenGLVersionProfile_Profile(void* ptr)
{
return static_cast<QOpenGLVersionProfile*>(ptr)->profile();
}
char QOpenGLVersionProfile_HasProfiles(void* ptr)
{
return static_cast<QOpenGLVersionProfile*>(ptr)->hasProfiles();
}
char QOpenGLVersionProfile_IsLegacyVersion(void* ptr)
{
return static_cast<QOpenGLVersionProfile*>(ptr)->isLegacyVersion();
}
char QOpenGLVersionProfile_IsValid(void* ptr)
{
return static_cast<QOpenGLVersionProfile*>(ptr)->isValid();
}
class MyQOpenGLVertexArrayObject: public QOpenGLVertexArrayObject
{
public:
MyQOpenGLVertexArrayObject(QObject *parent = Q_NULLPTR) : QOpenGLVertexArrayObject(parent) {QOpenGLVertexArrayObject_QOpenGLVertexArrayObject_QRegisterMetaType();};
~MyQOpenGLVertexArrayObject() { callbackQOpenGLVertexArrayObject_DestroyQOpenGLVertexArrayObject(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQOpenGLVertexArrayObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQOpenGLVertexArrayObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQOpenGLVertexArrayObject_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQOpenGLVertexArrayObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQOpenGLVertexArrayObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQOpenGLVertexArrayObject_CustomEvent(this, event); };
void deleteLater() { callbackQOpenGLVertexArrayObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQOpenGLVertexArrayObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQOpenGLVertexArrayObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQOpenGLVertexArrayObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQOpenGLVertexArrayObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQOpenGLVertexArrayObject*)
int QOpenGLVertexArrayObject_QOpenGLVertexArrayObject_QRegisterMetaType(){qRegisterMetaType<QOpenGLVertexArrayObject*>(); return qRegisterMetaType<MyQOpenGLVertexArrayObject*>();}
void* QOpenGLVertexArrayObject_NewQOpenGLVertexArrayObject(void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLVertexArrayObject(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLVertexArrayObject(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLVertexArrayObject(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLVertexArrayObject(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLVertexArrayObject(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLVertexArrayObject(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLVertexArrayObject(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLVertexArrayObject(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLVertexArrayObject(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLVertexArrayObject(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLVertexArrayObject(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLVertexArrayObject(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLVertexArrayObject(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLVertexArrayObject(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLVertexArrayObject(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLVertexArrayObject(static_cast<QWindow*>(parent));
} else {
return new MyQOpenGLVertexArrayObject(static_cast<QObject*>(parent));
}
}
struct QtGui_PackedString QOpenGLVertexArrayObject_QOpenGLVertexArrayObject_Tr(char* s, char* c, int n)
{
return ({ QByteArray t7b08be = QOpenGLVertexArrayObject::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t7b08be.prepend("WHITESPACE").constData()+10), t7b08be.size()-10 }; });
}
struct QtGui_PackedString QOpenGLVertexArrayObject_QOpenGLVertexArrayObject_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray t98a7ac = QOpenGLVertexArrayObject::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t98a7ac.prepend("WHITESPACE").constData()+10), t98a7ac.size()-10 }; });
}
char QOpenGLVertexArrayObject_Create(void* ptr)
{
return static_cast<QOpenGLVertexArrayObject*>(ptr)->create();
}
void QOpenGLVertexArrayObject_Bind(void* ptr)
{
static_cast<QOpenGLVertexArrayObject*>(ptr)->bind();
}
void QOpenGLVertexArrayObject_Destroy(void* ptr)
{
static_cast<QOpenGLVertexArrayObject*>(ptr)->destroy();
}
void QOpenGLVertexArrayObject_Release(void* ptr)
{
static_cast<QOpenGLVertexArrayObject*>(ptr)->release();
}
void QOpenGLVertexArrayObject_DestroyQOpenGLVertexArrayObject(void* ptr)
{
static_cast<QOpenGLVertexArrayObject*>(ptr)->~QOpenGLVertexArrayObject();
}
void QOpenGLVertexArrayObject_DestroyQOpenGLVertexArrayObjectDefault(void* ptr)
{
Q_UNUSED(ptr);
}
unsigned int QOpenGLVertexArrayObject_ObjectId(void* ptr)
{
return static_cast<QOpenGLVertexArrayObject*>(ptr)->objectId();
}
char QOpenGLVertexArrayObject_IsCreated(void* ptr)
{
return static_cast<QOpenGLVertexArrayObject*>(ptr)->isCreated();
}
void* QOpenGLVertexArrayObject_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QOpenGLVertexArrayObject*>(ptr)->QOpenGLVertexArrayObject::metaObject());
}
void* QOpenGLVertexArrayObject___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QOpenGLVertexArrayObject___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QOpenGLVertexArrayObject___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QOpenGLVertexArrayObject___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLVertexArrayObject___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLVertexArrayObject___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOpenGLVertexArrayObject___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLVertexArrayObject___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLVertexArrayObject___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOpenGLVertexArrayObject___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLVertexArrayObject___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLVertexArrayObject___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QOpenGLVertexArrayObject___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QOpenGLVertexArrayObject___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QOpenGLVertexArrayObject___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QOpenGLVertexArrayObject_EventDefault(void* ptr, void* e)
{
return static_cast<QOpenGLVertexArrayObject*>(ptr)->QOpenGLVertexArrayObject::event(static_cast<QEvent*>(e));
}
char QOpenGLVertexArrayObject_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLVertexArrayObject*>(ptr)->QOpenGLVertexArrayObject::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLVertexArrayObject*>(ptr)->QOpenGLVertexArrayObject::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLVertexArrayObject*>(ptr)->QOpenGLVertexArrayObject::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLVertexArrayObject*>(ptr)->QOpenGLVertexArrayObject::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QOpenGLVertexArrayObject*>(ptr)->QOpenGLVertexArrayObject::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QOpenGLVertexArrayObject_ChildEventDefault(void* ptr, void* event)
{
static_cast<QOpenGLVertexArrayObject*>(ptr)->QOpenGLVertexArrayObject::childEvent(static_cast<QChildEvent*>(event));
}
void QOpenGLVertexArrayObject_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QOpenGLVertexArrayObject*>(ptr)->QOpenGLVertexArrayObject::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QOpenGLVertexArrayObject_CustomEventDefault(void* ptr, void* event)
{
static_cast<QOpenGLVertexArrayObject*>(ptr)->QOpenGLVertexArrayObject::customEvent(static_cast<QEvent*>(event));
}
void QOpenGLVertexArrayObject_DeleteLaterDefault(void* ptr)
{
static_cast<QOpenGLVertexArrayObject*>(ptr)->QOpenGLVertexArrayObject::deleteLater();
}
void QOpenGLVertexArrayObject_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QOpenGLVertexArrayObject*>(ptr)->QOpenGLVertexArrayObject::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QOpenGLVertexArrayObject_TimerEventDefault(void* ptr, void* event)
{
static_cast<QOpenGLVertexArrayObject*>(ptr)->QOpenGLVertexArrayObject::timerEvent(static_cast<QTimerEvent*>(event));
}
class MyQOpenGLWindow: public QOpenGLWindow
{
public:
MyQOpenGLWindow(QOpenGLContext *shareContext, QOpenGLWindow::UpdateBehavior updateBehavior = NoPartialUpdate, QWindow *parent = Q_NULLPTR) : QOpenGLWindow(shareContext, updateBehavior, parent) {QOpenGLWindow_QOpenGLWindow_QRegisterMetaType();};
MyQOpenGLWindow(QOpenGLWindow::UpdateBehavior updateBehavior = NoPartialUpdate, QWindow *parent = Q_NULLPTR) : QOpenGLWindow(updateBehavior, parent) {QOpenGLWindow_QOpenGLWindow_QRegisterMetaType();};
void Signal_FrameSwapped() { callbackQOpenGLWindow_FrameSwapped(this); };
void initializeGL() { callbackQOpenGLWindow_InitializeGL(this); };
void paintEvent(QPaintEvent * event) { callbackQPaintDeviceWindow_PaintEvent(this, event); };
void paintGL() { callbackQOpenGLWindow_PaintGL(this); };
void paintOverGL() { callbackQOpenGLWindow_PaintOverGL(this); };
void paintUnderGL() { callbackQOpenGLWindow_PaintUnderGL(this); };
void resizeEvent(QResizeEvent * event) { callbackQWindow_ResizeEvent(this, event); };
void resizeGL(int w, int h) { callbackQOpenGLWindow_ResizeGL(this, w, h); };
~MyQOpenGLWindow() { callbackQOpenGLWindow_DestroyQOpenGLWindow(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWindow_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void update() { callbackQPaintDeviceWindow_Update3(this); };
bool close() { return callbackQWindow_Close(this) != 0; };
bool event(QEvent * ev) { return callbackQWindow_Event(this, ev) != 0; };
void Signal_ActiveChanged() { callbackQWindow_ActiveChanged(this); };
void alert(int msec) { callbackQWindow_Alert(this, msec); };
void Signal_ContentOrientationChanged(Qt::ScreenOrientation orientation) { callbackQWindow_ContentOrientationChanged(this, orientation); };
void exposeEvent(QExposeEvent * ev) { callbackQWindow_ExposeEvent(this, ev); };
void focusInEvent(QFocusEvent * ev) { callbackQWindow_FocusInEvent(this, ev); };
void Signal_FocusObjectChanged(QObject * object) { callbackQWindow_FocusObjectChanged(this, object); };
void focusOutEvent(QFocusEvent * ev) { callbackQWindow_FocusOutEvent(this, ev); };
void Signal_HeightChanged(int arg) { callbackQWindow_HeightChanged(this, arg); };
void hide() { callbackQWindow_Hide(this); };
void hideEvent(QHideEvent * ev) { callbackQWindow_HideEvent(this, ev); };
void keyPressEvent(QKeyEvent * ev) { callbackQWindow_KeyPressEvent(this, ev); };
void keyReleaseEvent(QKeyEvent * ev) { callbackQWindow_KeyReleaseEvent(this, ev); };
void lower() { callbackQWindow_Lower(this); };
void Signal_MaximumHeightChanged(int arg) { callbackQWindow_MaximumHeightChanged(this, arg); };
void Signal_MaximumWidthChanged(int arg) { callbackQWindow_MaximumWidthChanged(this, arg); };
void Signal_MinimumHeightChanged(int arg) { callbackQWindow_MinimumHeightChanged(this, arg); };
void Signal_MinimumWidthChanged(int arg) { callbackQWindow_MinimumWidthChanged(this, arg); };
void Signal_ModalityChanged(Qt::WindowModality modality) { callbackQWindow_ModalityChanged(this, modality); };
void mouseDoubleClickEvent(QMouseEvent * ev) { callbackQWindow_MouseDoubleClickEvent(this, ev); };
void mouseMoveEvent(QMouseEvent * ev) { callbackQWindow_MouseMoveEvent(this, ev); };
void mousePressEvent(QMouseEvent * ev) { callbackQWindow_MousePressEvent(this, ev); };
void mouseReleaseEvent(QMouseEvent * ev) { callbackQWindow_MouseReleaseEvent(this, ev); };
void moveEvent(QMoveEvent * ev) { callbackQWindow_MoveEvent(this, ev); };
void Signal_OpacityChanged(qreal opacity) { callbackQWindow_OpacityChanged(this, opacity); };
void raise() { callbackQWindow_Raise(this); };
void requestActivate() { callbackQWindow_RequestActivate(this); };
void requestUpdate() { callbackQWindow_RequestUpdate(this); };
void Signal_ScreenChanged(QScreen * screen) { callbackQWindow_ScreenChanged(this, screen); };
void setGeometry(const QRect & rect) { callbackQWindow_SetGeometry2(this, const_cast<QRect*>(&rect)); };
void setGeometry(int posx, int posy, int w, int h) { callbackQWindow_SetGeometry(this, posx, posy, w, h); };
void setHeight(int arg) { callbackQWindow_SetHeight(this, arg); };
void setMaximumHeight(int h) { callbackQWindow_SetMaximumHeight(this, h); };
void setMaximumWidth(int w) { callbackQWindow_SetMaximumWidth(this, w); };
void setMinimumHeight(int h) { callbackQWindow_SetMinimumHeight(this, h); };
void setMinimumWidth(int w) { callbackQWindow_SetMinimumWidth(this, w); };
void setTitle(const QString & vqs) { QByteArray tda39a3 = vqs.toUtf8(); QtGui_PackedString vqsPacked = { const_cast<char*>(tda39a3.prepend("WHITESPACE").constData()+10), tda39a3.size()-10 };callbackQWindow_SetTitle(this, vqsPacked); };
void setVisible(bool visible) { callbackQWindow_SetVisible(this, visible); };
void setWidth(int arg) { callbackQWindow_SetWidth(this, arg); };
void setX(int arg) { callbackQWindow_SetX(this, arg); };
void setY(int arg) { callbackQWindow_SetY(this, arg); };
void show() { callbackQWindow_Show(this); };
void showEvent(QShowEvent * ev) { callbackQWindow_ShowEvent(this, ev); };
void showFullScreen() { callbackQWindow_ShowFullScreen(this); };
void showMaximized() { callbackQWindow_ShowMaximized(this); };
void showMinimized() { callbackQWindow_ShowMinimized(this); };
void showNormal() { callbackQWindow_ShowNormal(this); };
void tabletEvent(QTabletEvent * ev) { callbackQWindow_TabletEvent(this, ev); };
void touchEvent(QTouchEvent * ev) { callbackQWindow_TouchEvent(this, ev); };
void Signal_VisibilityChanged(QWindow::Visibility visibility) { callbackQWindow_VisibilityChanged(this, visibility); };
void Signal_VisibleChanged(bool arg) { callbackQWindow_VisibleChanged(this, arg); };
void wheelEvent(QWheelEvent * ev) { callbackQWindow_WheelEvent(this, ev); };
void Signal_WidthChanged(int arg) { callbackQWindow_WidthChanged(this, arg); };
void Signal_WindowStateChanged(Qt::WindowState windowState) { callbackQWindow_WindowStateChanged(this, windowState); };
void Signal_WindowTitleChanged(const QString & title) { QByteArray t3c6de1 = title.toUtf8(); QtGui_PackedString titlePacked = { const_cast<char*>(t3c6de1.prepend("WHITESPACE").constData()+10), t3c6de1.size()-10 };callbackQWindow_WindowTitleChanged(this, titlePacked); };
void Signal_XChanged(int arg) { callbackQWindow_XChanged(this, arg); };
void Signal_YChanged(int arg) { callbackQWindow_YChanged(this, arg); };
QObject * focusObject() const { return static_cast<QObject*>(callbackQWindow_FocusObject(const_cast<void*>(static_cast<const void*>(this)))); };
QSize size() const { return *static_cast<QSize*>(callbackQWindow_Size(const_cast<void*>(static_cast<const void*>(this)))); };
QSurface::SurfaceType surfaceType() const { return static_cast<QSurface::SurfaceType>(callbackQWindow_SurfaceType(const_cast<void*>(static_cast<const void*>(this)))); };
QSurfaceFormat format() const { return *static_cast<QSurfaceFormat*>(callbackQWindow_Format(const_cast<void*>(static_cast<const void*>(this)))); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQWindow_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQWindow_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQWindow_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQWindow_CustomEvent(this, event); };
void deleteLater() { callbackQWindow_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQWindow_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQWindow_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQWindow_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQWindow_TimerEvent(this, event); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQPaintDeviceWindow_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPaintDevice_Metric(const_cast<void*>(static_cast<const void*>(this)), metric); };
};
Q_DECLARE_METATYPE(MyQOpenGLWindow*)
int QOpenGLWindow_QOpenGLWindow_QRegisterMetaType(){qRegisterMetaType<QOpenGLWindow*>(); return qRegisterMetaType<MyQOpenGLWindow*>();}
void* QOpenGLWindow_GrabFramebuffer(void* ptr)
{
return new QImage(static_cast<QOpenGLWindow*>(ptr)->grabFramebuffer());
}
void* QOpenGLWindow_NewQOpenGLWindow2(void* shareContext, long long updateBehavior, void* parent)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLWindow(static_cast<QOpenGLContext*>(shareContext), static_cast<QOpenGLWindow::UpdateBehavior>(updateBehavior), static_cast<QPaintDeviceWindow*>(parent));
} else {
return new MyQOpenGLWindow(static_cast<QOpenGLContext*>(shareContext), static_cast<QOpenGLWindow::UpdateBehavior>(updateBehavior), static_cast<QWindow*>(parent));
}
}
void* QOpenGLWindow_NewQOpenGLWindow(long long updateBehavior, void* parent)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQOpenGLWindow(static_cast<QOpenGLWindow::UpdateBehavior>(updateBehavior), static_cast<QPaintDeviceWindow*>(parent));
} else {
return new MyQOpenGLWindow(static_cast<QOpenGLWindow::UpdateBehavior>(updateBehavior), static_cast<QWindow*>(parent));
}
}
void QOpenGLWindow_DoneCurrent(void* ptr)
{
static_cast<QOpenGLWindow*>(ptr)->doneCurrent();
}
void QOpenGLWindow_ConnectFrameSwapped(void* ptr)
{
QObject::connect(static_cast<QOpenGLWindow*>(ptr), static_cast<void (QOpenGLWindow::*)()>(&QOpenGLWindow::frameSwapped), static_cast<MyQOpenGLWindow*>(ptr), static_cast<void (MyQOpenGLWindow::*)()>(&MyQOpenGLWindow::Signal_FrameSwapped));
}
void QOpenGLWindow_DisconnectFrameSwapped(void* ptr)
{
QObject::disconnect(static_cast<QOpenGLWindow*>(ptr), static_cast<void (QOpenGLWindow::*)()>(&QOpenGLWindow::frameSwapped), static_cast<MyQOpenGLWindow*>(ptr), static_cast<void (MyQOpenGLWindow::*)()>(&MyQOpenGLWindow::Signal_FrameSwapped));
}
void QOpenGLWindow_FrameSwapped(void* ptr)
{
static_cast<QOpenGLWindow*>(ptr)->frameSwapped();
}
void QOpenGLWindow_InitializeGL(void* ptr)
{
static_cast<QOpenGLWindow*>(ptr)->initializeGL();
}
void QOpenGLWindow_InitializeGLDefault(void* ptr)
{
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::initializeGL();
}
void QOpenGLWindow_MakeCurrent(void* ptr)
{
static_cast<QOpenGLWindow*>(ptr)->makeCurrent();
}
void QOpenGLWindow_PaintGL(void* ptr)
{
static_cast<QOpenGLWindow*>(ptr)->paintGL();
}
void QOpenGLWindow_PaintGLDefault(void* ptr)
{
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::paintGL();
}
void QOpenGLWindow_PaintOverGL(void* ptr)
{
static_cast<QOpenGLWindow*>(ptr)->paintOverGL();
}
void QOpenGLWindow_PaintOverGLDefault(void* ptr)
{
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::paintOverGL();
}
void QOpenGLWindow_PaintUnderGL(void* ptr)
{
static_cast<QOpenGLWindow*>(ptr)->paintUnderGL();
}
void QOpenGLWindow_PaintUnderGLDefault(void* ptr)
{
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::paintUnderGL();
}
void QOpenGLWindow_ResizeGL(void* ptr, int w, int h)
{
static_cast<QOpenGLWindow*>(ptr)->resizeGL(w, h);
}
void QOpenGLWindow_ResizeGLDefault(void* ptr, int w, int h)
{
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::resizeGL(w, h);
}
void QOpenGLWindow_DestroyQOpenGLWindow(void* ptr)
{
static_cast<QOpenGLWindow*>(ptr)->~QOpenGLWindow();
}
void QOpenGLWindow_DestroyQOpenGLWindowDefault(void* ptr)
{
Q_UNUSED(ptr);
}
unsigned int QOpenGLWindow_DefaultFramebufferObject(void* ptr)
{
return static_cast<QOpenGLWindow*>(ptr)->defaultFramebufferObject();
}
void* QOpenGLWindow_Context(void* ptr)
{
return static_cast<QOpenGLWindow*>(ptr)->context();
}
void* QOpenGLWindow_ShareContext(void* ptr)
{
return static_cast<QOpenGLWindow*>(ptr)->shareContext();
}
long long QOpenGLWindow_UpdateBehavior(void* ptr)
{
return static_cast<QOpenGLWindow*>(ptr)->updateBehavior();
}
char QOpenGLWindow_IsValid(void* ptr)
{
return static_cast<QOpenGLWindow*>(ptr)->isValid();
}
void* QPageLayout_NewQPageLayout()
{
return new QPageLayout();
}
void* QPageLayout_NewQPageLayout3(void* other)
{
return new QPageLayout(*static_cast<QPageLayout*>(other));
}
void* QPageLayout_NewQPageLayout2(void* pageSize, long long orientation, void* margins, long long units, void* minMargins)
{
return new QPageLayout(*static_cast<QPageSize*>(pageSize), static_cast<QPageLayout::Orientation>(orientation), *static_cast<QMarginsF*>(margins), static_cast<QPageLayout::Unit>(units), *static_cast<QMarginsF*>(minMargins));
}
char QPageLayout_SetBottomMargin(void* ptr, double bottomMargin)
{
return static_cast<QPageLayout*>(ptr)->setBottomMargin(bottomMargin);
}
char QPageLayout_SetLeftMargin(void* ptr, double leftMargin)
{
return static_cast<QPageLayout*>(ptr)->setLeftMargin(leftMargin);
}
char QPageLayout_SetMargins(void* ptr, void* margins)
{
return static_cast<QPageLayout*>(ptr)->setMargins(*static_cast<QMarginsF*>(margins));
}
char QPageLayout_SetRightMargin(void* ptr, double rightMargin)
{
return static_cast<QPageLayout*>(ptr)->setRightMargin(rightMargin);
}
char QPageLayout_SetTopMargin(void* ptr, double topMargin)
{
return static_cast<QPageLayout*>(ptr)->setTopMargin(topMargin);
}
void QPageLayout_SetMinimumMargins(void* ptr, void* minMargins)
{
static_cast<QPageLayout*>(ptr)->setMinimumMargins(*static_cast<QMarginsF*>(minMargins));
}
void QPageLayout_SetMode(void* ptr, long long mode)
{
static_cast<QPageLayout*>(ptr)->setMode(static_cast<QPageLayout::Mode>(mode));
}
void QPageLayout_SetOrientation(void* ptr, long long orientation)
{
static_cast<QPageLayout*>(ptr)->setOrientation(static_cast<QPageLayout::Orientation>(orientation));
}
void QPageLayout_SetPageSize(void* ptr, void* pageSize, void* minMargins)
{
static_cast<QPageLayout*>(ptr)->setPageSize(*static_cast<QPageSize*>(pageSize), *static_cast<QMarginsF*>(minMargins));
}
void QPageLayout_SetUnits(void* ptr, long long units)
{
static_cast<QPageLayout*>(ptr)->setUnits(static_cast<QPageLayout::Unit>(units));
}
void QPageLayout_Swap(void* ptr, void* other)
{
static_cast<QPageLayout*>(ptr)->swap(*static_cast<QPageLayout*>(other));
}
void QPageLayout_DestroyQPageLayout(void* ptr)
{
static_cast<QPageLayout*>(ptr)->~QPageLayout();
}
void* QPageLayout_MarginsPixels(void* ptr, int resolution)
{
return ({ QMargins tmpValue = static_cast<QPageLayout*>(ptr)->marginsPixels(resolution); new QMargins(tmpValue.left(), tmpValue.top(), tmpValue.right(), tmpValue.bottom()); });
}
void* QPageLayout_MarginsPoints(void* ptr)
{
return ({ QMargins tmpValue = static_cast<QPageLayout*>(ptr)->marginsPoints(); new QMargins(tmpValue.left(), tmpValue.top(), tmpValue.right(), tmpValue.bottom()); });
}
void* QPageLayout_Margins(void* ptr)
{
return ({ QMarginsF tmpValue = static_cast<QPageLayout*>(ptr)->margins(); new QMarginsF(tmpValue.left(), tmpValue.top(), tmpValue.right(), tmpValue.bottom()); });
}
void* QPageLayout_Margins2(void* ptr, long long units)
{
return ({ QMarginsF tmpValue = static_cast<QPageLayout*>(ptr)->margins(static_cast<QPageLayout::Unit>(units)); new QMarginsF(tmpValue.left(), tmpValue.top(), tmpValue.right(), tmpValue.bottom()); });
}
void* QPageLayout_MaximumMargins(void* ptr)
{
return ({ QMarginsF tmpValue = static_cast<QPageLayout*>(ptr)->maximumMargins(); new QMarginsF(tmpValue.left(), tmpValue.top(), tmpValue.right(), tmpValue.bottom()); });
}
void* QPageLayout_MinimumMargins(void* ptr)
{
return ({ QMarginsF tmpValue = static_cast<QPageLayout*>(ptr)->minimumMargins(); new QMarginsF(tmpValue.left(), tmpValue.top(), tmpValue.right(), tmpValue.bottom()); });
}
long long QPageLayout_Mode(void* ptr)
{
return static_cast<QPageLayout*>(ptr)->mode();
}
long long QPageLayout_Orientation(void* ptr)
{
return static_cast<QPageLayout*>(ptr)->orientation();
}
long long QPageLayout_Units(void* ptr)
{
return static_cast<QPageLayout*>(ptr)->units();
}
void* QPageLayout_PageSize(void* ptr)
{
return new QPageSize(static_cast<QPageLayout*>(ptr)->pageSize());
}
void* QPageLayout_FullRectPixels(void* ptr, int resolution)
{
return ({ QRect tmpValue = static_cast<QPageLayout*>(ptr)->fullRectPixels(resolution); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QPageLayout_FullRectPoints(void* ptr)
{
return ({ QRect tmpValue = static_cast<QPageLayout*>(ptr)->fullRectPoints(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QPageLayout_PaintRectPixels(void* ptr, int resolution)
{
return ({ QRect tmpValue = static_cast<QPageLayout*>(ptr)->paintRectPixels(resolution); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QPageLayout_PaintRectPoints(void* ptr)
{
return ({ QRect tmpValue = static_cast<QPageLayout*>(ptr)->paintRectPoints(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QPageLayout_FullRect(void* ptr)
{
return ({ QRectF tmpValue = static_cast<QPageLayout*>(ptr)->fullRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QPageLayout_FullRect2(void* ptr, long long units)
{
return ({ QRectF tmpValue = static_cast<QPageLayout*>(ptr)->fullRect(static_cast<QPageLayout::Unit>(units)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QPageLayout_PaintRect(void* ptr)
{
return ({ QRectF tmpValue = static_cast<QPageLayout*>(ptr)->paintRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QPageLayout_PaintRect2(void* ptr, long long units)
{
return ({ QRectF tmpValue = static_cast<QPageLayout*>(ptr)->paintRect(static_cast<QPageLayout::Unit>(units)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
char QPageLayout_IsEquivalentTo(void* ptr, void* other)
{
return static_cast<QPageLayout*>(ptr)->isEquivalentTo(*static_cast<QPageLayout*>(other));
}
char QPageLayout_IsValid(void* ptr)
{
return static_cast<QPageLayout*>(ptr)->isValid();
}
void* QPageSize_NewQPageSize()
{
return new QPageSize();
}
void* QPageSize_NewQPageSize2(long long pageSize)
{
return new QPageSize(static_cast<QPageSize::PageSizeId>(pageSize));
}
void* QPageSize_NewQPageSize5(void* other)
{
return new QPageSize(*static_cast<QPageSize*>(other));
}
void* QPageSize_NewQPageSize3(void* pointSize, struct QtGui_PackedString name, long long matchPolicy)
{
return new QPageSize(*static_cast<QSize*>(pointSize), QString::fromUtf8(name.data, name.len), static_cast<QPageSize::SizeMatchPolicy>(matchPolicy));
}
void* QPageSize_NewQPageSize4(void* size, long long units, struct QtGui_PackedString name, long long matchPolicy)
{
return new QPageSize(*static_cast<QSizeF*>(size), static_cast<QPageSize::Unit>(units), QString::fromUtf8(name.data, name.len), static_cast<QPageSize::SizeMatchPolicy>(matchPolicy));
}
long long QPageSize_QPageSize_Id2(void* pointSize, long long matchPolicy)
{
return QPageSize::id(*static_cast<QSize*>(pointSize), static_cast<QPageSize::SizeMatchPolicy>(matchPolicy));
}
long long QPageSize_QPageSize_Id3(void* size, long long units, long long matchPolicy)
{
return QPageSize::id(*static_cast<QSizeF*>(size), static_cast<QPageSize::Unit>(units), static_cast<QPageSize::SizeMatchPolicy>(matchPolicy));
}
long long QPageSize_QPageSize_Id4(int windowsId)
{
return QPageSize::id(windowsId);
}
long long QPageSize_QPageSize_DefinitionUnits2(long long pageSizeId)
{
return QPageSize::definitionUnits(static_cast<QPageSize::PageSizeId>(pageSizeId));
}
void* QPageSize_QPageSize_SizePixels2(long long pageSizeId, int resolution)
{
return ({ QSize tmpValue = QPageSize::sizePixels(static_cast<QPageSize::PageSizeId>(pageSizeId), resolution); new QSize(tmpValue.width(), tmpValue.height()); });
}
void* QPageSize_QPageSize_SizePoints2(long long pageSizeId)
{
return ({ QSize tmpValue = QPageSize::sizePoints(static_cast<QPageSize::PageSizeId>(pageSizeId)); new QSize(tmpValue.width(), tmpValue.height()); });
}
void* QPageSize_QPageSize_DefinitionSize2(long long pageSizeId)
{
return ({ QSizeF tmpValue = QPageSize::definitionSize(static_cast<QPageSize::PageSizeId>(pageSizeId)); new QSizeF(tmpValue.width(), tmpValue.height()); });
}
void* QPageSize_QPageSize_Size2(long long pageSizeId, long long units)
{
return ({ QSizeF tmpValue = QPageSize::size(static_cast<QPageSize::PageSizeId>(pageSizeId), static_cast<QPageSize::Unit>(units)); new QSizeF(tmpValue.width(), tmpValue.height()); });
}
struct QtGui_PackedString QPageSize_QPageSize_Key2(long long pageSizeId)
{
return ({ QByteArray tba9d4f = QPageSize::key(static_cast<QPageSize::PageSizeId>(pageSizeId)).toUtf8(); QtGui_PackedString { const_cast<char*>(tba9d4f.prepend("WHITESPACE").constData()+10), tba9d4f.size()-10 }; });
}
struct QtGui_PackedString QPageSize_QPageSize_Name2(long long pageSizeId)
{
return ({ QByteArray t8d3c9f = QPageSize::name(static_cast<QPageSize::PageSizeId>(pageSizeId)).toUtf8(); QtGui_PackedString { const_cast<char*>(t8d3c9f.prepend("WHITESPACE").constData()+10), t8d3c9f.size()-10 }; });
}
int QPageSize_QPageSize_WindowsId2(long long pageSizeId)
{
return QPageSize::windowsId(static_cast<QPageSize::PageSizeId>(pageSizeId));
}
void QPageSize_Swap(void* ptr, void* other)
{
static_cast<QPageSize*>(ptr)->swap(*static_cast<QPageSize*>(other));
}
void QPageSize_DestroyQPageSize(void* ptr)
{
static_cast<QPageSize*>(ptr)->~QPageSize();
}
long long QPageSize_Id(void* ptr)
{
return static_cast<QPageSize*>(ptr)->id();
}
long long QPageSize_DefinitionUnits(void* ptr)
{
return static_cast<QPageSize*>(ptr)->definitionUnits();
}
void* QPageSize_RectPixels(void* ptr, int resolution)
{
return ({ QRect tmpValue = static_cast<QPageSize*>(ptr)->rectPixels(resolution); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QPageSize_RectPoints(void* ptr)
{
return ({ QRect tmpValue = static_cast<QPageSize*>(ptr)->rectPoints(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QPageSize_Rect(void* ptr, long long units)
{
return ({ QRectF tmpValue = static_cast<QPageSize*>(ptr)->rect(static_cast<QPageSize::Unit>(units)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QPageSize_SizePixels(void* ptr, int resolution)
{
return ({ QSize tmpValue = static_cast<QPageSize*>(ptr)->sizePixels(resolution); new QSize(tmpValue.width(), tmpValue.height()); });
}
void* QPageSize_SizePoints(void* ptr)
{
return ({ QSize tmpValue = static_cast<QPageSize*>(ptr)->sizePoints(); new QSize(tmpValue.width(), tmpValue.height()); });
}
void* QPageSize_DefinitionSize(void* ptr)
{
return ({ QSizeF tmpValue = static_cast<QPageSize*>(ptr)->definitionSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}
void* QPageSize_Size(void* ptr, long long units)
{
return ({ QSizeF tmpValue = static_cast<QPageSize*>(ptr)->size(static_cast<QPageSize::Unit>(units)); new QSizeF(tmpValue.width(), tmpValue.height()); });
}
struct QtGui_PackedString QPageSize_Key(void* ptr)
{
return ({ QByteArray t01da2c = static_cast<QPageSize*>(ptr)->key().toUtf8(); QtGui_PackedString { const_cast<char*>(t01da2c.prepend("WHITESPACE").constData()+10), t01da2c.size()-10 }; });
}
struct QtGui_PackedString QPageSize_Name(void* ptr)
{
return ({ QByteArray t2620ab = static_cast<QPageSize*>(ptr)->name().toUtf8(); QtGui_PackedString { const_cast<char*>(t2620ab.prepend("WHITESPACE").constData()+10), t2620ab.size()-10 }; });
}
char QPageSize_IsEquivalentTo(void* ptr, void* other)
{
return static_cast<QPageSize*>(ptr)->isEquivalentTo(*static_cast<QPageSize*>(other));
}
char QPageSize_IsValid(void* ptr)
{
return static_cast<QPageSize*>(ptr)->isValid();
}
int QPageSize_WindowsId(void* ptr)
{
return static_cast<QPageSize*>(ptr)->windowsId();
}
class MyQPagedPaintDevice: public QPagedPaintDevice
{
public:
MyQPagedPaintDevice() : QPagedPaintDevice() {};
bool newPage() { return callbackQPagedPaintDevice_NewPage(this) != 0; };
void setPageSize(QPagedPaintDevice::PageSize size) { callbackQPagedPaintDevice_SetPageSize2(this, size); };
void setPageSizeMM(const QSizeF & size) { callbackQPagedPaintDevice_SetPageSizeMM(this, const_cast<QSizeF*>(&size)); };
~MyQPagedPaintDevice() { callbackQPagedPaintDevice_DestroyQPagedPaintDevice(this); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQPagedPaintDevice_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPaintDevice_Metric(const_cast<void*>(static_cast<const void*>(this)), metric); };
};
void* QPagedPaintDevice_NewQPagedPaintDevice()
{
return new MyQPagedPaintDevice();
}
char QPagedPaintDevice_NewPage(void* ptr)
{
if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->newPage();
} else {
return static_cast<QPagedPaintDevice*>(ptr)->newPage();
}
}
char QPagedPaintDevice_SetPageLayout(void* ptr, void* newPageLayout)
{
if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->setPageLayout(*static_cast<QPageLayout*>(newPageLayout));
} else {
return static_cast<QPagedPaintDevice*>(ptr)->setPageLayout(*static_cast<QPageLayout*>(newPageLayout));
}
}
char QPagedPaintDevice_SetPageMargins(void* ptr, void* margins)
{
if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->setPageMargins(*static_cast<QMarginsF*>(margins));
} else {
return static_cast<QPagedPaintDevice*>(ptr)->setPageMargins(*static_cast<QMarginsF*>(margins));
}
}
char QPagedPaintDevice_SetPageMargins2(void* ptr, void* margins, long long units)
{
if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->setPageMargins(*static_cast<QMarginsF*>(margins), static_cast<QPageLayout::Unit>(units));
} else {
return static_cast<QPagedPaintDevice*>(ptr)->setPageMargins(*static_cast<QMarginsF*>(margins), static_cast<QPageLayout::Unit>(units));
}
}
char QPagedPaintDevice_SetPageOrientation(void* ptr, long long orientation)
{
if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->setPageOrientation(static_cast<QPageLayout::Orientation>(orientation));
} else {
return static_cast<QPagedPaintDevice*>(ptr)->setPageOrientation(static_cast<QPageLayout::Orientation>(orientation));
}
}
char QPagedPaintDevice_SetPageSize(void* ptr, void* pageSize)
{
if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->setPageSize(*static_cast<QPageSize*>(pageSize));
} else {
return static_cast<QPagedPaintDevice*>(ptr)->setPageSize(*static_cast<QPageSize*>(pageSize));
}
}
void QPagedPaintDevice_SetPageSize2(void* ptr, long long size)
{
if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
static_cast<QPdfWriter*>(ptr)->setPageSize(static_cast<QPagedPaintDevice::PageSize>(size));
} else {
static_cast<QPagedPaintDevice*>(ptr)->setPageSize(static_cast<QPagedPaintDevice::PageSize>(size));
}
}
void QPagedPaintDevice_SetPageSize2Default(void* ptr, long long size)
{
if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
static_cast<QPdfWriter*>(ptr)->QPdfWriter::setPageSize(static_cast<QPagedPaintDevice::PageSize>(size));
} else {
static_cast<QPagedPaintDevice*>(ptr)->QPagedPaintDevice::setPageSize(static_cast<QPagedPaintDevice::PageSize>(size));
}
}
void QPagedPaintDevice_SetPageSizeMM(void* ptr, void* size)
{
if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
static_cast<QPdfWriter*>(ptr)->setPageSizeMM(*static_cast<QSizeF*>(size));
} else {
static_cast<QPagedPaintDevice*>(ptr)->setPageSizeMM(*static_cast<QSizeF*>(size));
}
}
void QPagedPaintDevice_SetPageSizeMMDefault(void* ptr, void* size)
{
if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
static_cast<QPdfWriter*>(ptr)->QPdfWriter::setPageSizeMM(*static_cast<QSizeF*>(size));
} else {
static_cast<QPagedPaintDevice*>(ptr)->QPagedPaintDevice::setPageSizeMM(*static_cast<QSizeF*>(size));
}
}
void QPagedPaintDevice_DestroyQPagedPaintDevice(void* ptr)
{
static_cast<QPagedPaintDevice*>(ptr)->~QPagedPaintDevice();
}
void QPagedPaintDevice_DestroyQPagedPaintDeviceDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QPagedPaintDevice_PageLayout(void* ptr)
{
if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return new QPageLayout(static_cast<QPdfWriter*>(ptr)->pageLayout());
} else {
return new QPageLayout(static_cast<QPagedPaintDevice*>(ptr)->pageLayout());
}
}
long long QPagedPaintDevice_PageSize(void* ptr)
{
if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->pageSize();
} else {
return static_cast<QPagedPaintDevice*>(ptr)->pageSize();
}
}
void* QPagedPaintDevice_PageSizeMM(void* ptr)
{
if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return ({ QSizeF tmpValue = static_cast<QPdfWriter*>(ptr)->pageSizeMM(); new QSizeF(tmpValue.width(), tmpValue.height()); });
} else {
return ({ QSizeF tmpValue = static_cast<QPagedPaintDevice*>(ptr)->pageSizeMM(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}
}
void* QPagedPaintDevice_PaintEngine(void* ptr)
{
if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->paintEngine();
} else {
}
}
void* QPagedPaintDevice_PaintEngineDefault(void* ptr)
{
if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->QPdfWriter::paintEngine();
} else {
}
}
class MyQPaintDevice: public QPaintDevice
{
public:
MyQPaintDevice() : QPaintDevice() {};
~MyQPaintDevice() { callbackQPaintDevice_DestroyQPaintDevice(this); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQPaintDevice_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPaintDevice_Metric(const_cast<void*>(static_cast<const void*>(this)), metric); };
};
void* QPaintDevice_NewQPaintDevice()
{
return new MyQPaintDevice();
}
void QPaintDevice_DestroyQPaintDevice(void* ptr)
{
static_cast<QPaintDevice*>(ptr)->~QPaintDevice();
}
void QPaintDevice_DestroyQPaintDeviceDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QPaintDevice_PaintEngine(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->paintEngine();
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->paintEngine();
} else {
return static_cast<QPaintDevice*>(ptr)->paintEngine();
}
}
char QPaintDevice_PaintingActive(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->paintingActive();
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->paintingActive();
} else {
return static_cast<QPaintDevice*>(ptr)->paintingActive();
}
}
int QPaintDevice_ColorCount(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->colorCount();
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->colorCount();
} else {
return static_cast<QPaintDevice*>(ptr)->colorCount();
}
}
int QPaintDevice_Depth(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->depth();
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->depth();
} else {
return static_cast<QPaintDevice*>(ptr)->depth();
}
}
int QPaintDevice_DevicePixelRatio(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->devicePixelRatio();
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->devicePixelRatio();
} else {
return static_cast<QPaintDevice*>(ptr)->devicePixelRatio();
}
}
int QPaintDevice_Height(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->height();
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->height();
} else {
return static_cast<QPaintDevice*>(ptr)->height();
}
}
int QPaintDevice_HeightMM(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->heightMM();
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->heightMM();
} else {
return static_cast<QPaintDevice*>(ptr)->heightMM();
}
}
int QPaintDevice_LogicalDpiX(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->logicalDpiX();
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->logicalDpiX();
} else {
return static_cast<QPaintDevice*>(ptr)->logicalDpiX();
}
}
int QPaintDevice_LogicalDpiY(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->logicalDpiY();
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->logicalDpiY();
} else {
return static_cast<QPaintDevice*>(ptr)->logicalDpiY();
}
}
int QPaintDevice_Metric(void* ptr, long long metric)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
} else {
return static_cast<QPaintDevice*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
}
int QPaintDevice_MetricDefault(void* ptr, long long metric)
{
if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->QPdfWriter::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
} else if (dynamic_cast<QPagedPaintDevice*>(static_cast<QPaintDevice*>(ptr))) {
return static_cast<QPagedPaintDevice*>(ptr)->QPagedPaintDevice::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
} else if (dynamic_cast<QOpenGLPaintDevice*>(static_cast<QPaintDevice*>(ptr))) {
return static_cast<QOpenGLPaintDevice*>(ptr)->QOpenGLPaintDevice::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
} else if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QRasterWindow*>(ptr)->QRasterWindow::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
} else if (dynamic_cast<QBitmap*>(static_cast<QPaintDevice*>(ptr))) {
return static_cast<QBitmap*>(ptr)->QBitmap::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
} else if (dynamic_cast<QPixmap*>(static_cast<QPaintDevice*>(ptr))) {
return static_cast<QPixmap*>(ptr)->QPixmap::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
} else if (dynamic_cast<QPicture*>(static_cast<QPaintDevice*>(ptr))) {
return static_cast<QPicture*>(ptr)->QPicture::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
} else if (dynamic_cast<QImage*>(static_cast<QPaintDevice*>(ptr))) {
return static_cast<QImage*>(ptr)->QImage::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
} else {
return static_cast<QPaintDevice*>(ptr)->QPaintDevice::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
}
int QPaintDevice_PhysicalDpiX(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->physicalDpiX();
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->physicalDpiX();
} else {
return static_cast<QPaintDevice*>(ptr)->physicalDpiX();
}
}
int QPaintDevice_PhysicalDpiY(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->physicalDpiY();
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->physicalDpiY();
} else {
return static_cast<QPaintDevice*>(ptr)->physicalDpiY();
}
}
int QPaintDevice_Width(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->width();
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->width();
} else {
return static_cast<QPaintDevice*>(ptr)->width();
}
}
int QPaintDevice_WidthMM(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->widthMM();
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->widthMM();
} else {
return static_cast<QPaintDevice*>(ptr)->widthMM();
}
}
double QPaintDevice_DevicePixelRatioF(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->devicePixelRatioF();
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->devicePixelRatioF();
} else {
return static_cast<QPaintDevice*>(ptr)->devicePixelRatioF();
}
}
unsigned short QPaintDevice_Painters(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->painters;
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
return static_cast<QPdfWriter*>(ptr)->painters;
} else {
return static_cast<QPaintDevice*>(ptr)->painters;
}
}
void QPaintDevice_SetPainters(void* ptr, unsigned short vus)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->painters = vus;
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
static_cast<QPdfWriter*>(ptr)->painters = vus;
} else {
static_cast<QPaintDevice*>(ptr)->painters = vus;
}
}
class MyQPaintDeviceWindow: public QPaintDeviceWindow
{
public:
void paintEvent(QPaintEvent * event) { callbackQPaintDeviceWindow_PaintEvent(this, event); };
void update() { callbackQPaintDeviceWindow_Update3(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWindow_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool close() { return callbackQWindow_Close(this) != 0; };
bool event(QEvent * ev) { return callbackQWindow_Event(this, ev) != 0; };
void Signal_ActiveChanged() { callbackQWindow_ActiveChanged(this); };
void alert(int msec) { callbackQWindow_Alert(this, msec); };
void Signal_ContentOrientationChanged(Qt::ScreenOrientation orientation) { callbackQWindow_ContentOrientationChanged(this, orientation); };
void exposeEvent(QExposeEvent * ev) { callbackQWindow_ExposeEvent(this, ev); };
void focusInEvent(QFocusEvent * ev) { callbackQWindow_FocusInEvent(this, ev); };
void Signal_FocusObjectChanged(QObject * object) { callbackQWindow_FocusObjectChanged(this, object); };
void focusOutEvent(QFocusEvent * ev) { callbackQWindow_FocusOutEvent(this, ev); };
void Signal_HeightChanged(int arg) { callbackQWindow_HeightChanged(this, arg); };
void hide() { callbackQWindow_Hide(this); };
void hideEvent(QHideEvent * ev) { callbackQWindow_HideEvent(this, ev); };
void keyPressEvent(QKeyEvent * ev) { callbackQWindow_KeyPressEvent(this, ev); };
void keyReleaseEvent(QKeyEvent * ev) { callbackQWindow_KeyReleaseEvent(this, ev); };
void lower() { callbackQWindow_Lower(this); };
void Signal_MaximumHeightChanged(int arg) { callbackQWindow_MaximumHeightChanged(this, arg); };
void Signal_MaximumWidthChanged(int arg) { callbackQWindow_MaximumWidthChanged(this, arg); };
void Signal_MinimumHeightChanged(int arg) { callbackQWindow_MinimumHeightChanged(this, arg); };
void Signal_MinimumWidthChanged(int arg) { callbackQWindow_MinimumWidthChanged(this, arg); };
void Signal_ModalityChanged(Qt::WindowModality modality) { callbackQWindow_ModalityChanged(this, modality); };
void mouseDoubleClickEvent(QMouseEvent * ev) { callbackQWindow_MouseDoubleClickEvent(this, ev); };
void mouseMoveEvent(QMouseEvent * ev) { callbackQWindow_MouseMoveEvent(this, ev); };
void mousePressEvent(QMouseEvent * ev) { callbackQWindow_MousePressEvent(this, ev); };
void mouseReleaseEvent(QMouseEvent * ev) { callbackQWindow_MouseReleaseEvent(this, ev); };
void moveEvent(QMoveEvent * ev) { callbackQWindow_MoveEvent(this, ev); };
void Signal_OpacityChanged(qreal opacity) { callbackQWindow_OpacityChanged(this, opacity); };
void raise() { callbackQWindow_Raise(this); };
void requestActivate() { callbackQWindow_RequestActivate(this); };
void requestUpdate() { callbackQWindow_RequestUpdate(this); };
void resizeEvent(QResizeEvent * ev) { callbackQWindow_ResizeEvent(this, ev); };
void Signal_ScreenChanged(QScreen * screen) { callbackQWindow_ScreenChanged(this, screen); };
void setGeometry(const QRect & rect) { callbackQWindow_SetGeometry2(this, const_cast<QRect*>(&rect)); };
void setGeometry(int posx, int posy, int w, int h) { callbackQWindow_SetGeometry(this, posx, posy, w, h); };
void setHeight(int arg) { callbackQWindow_SetHeight(this, arg); };
void setMaximumHeight(int h) { callbackQWindow_SetMaximumHeight(this, h); };
void setMaximumWidth(int w) { callbackQWindow_SetMaximumWidth(this, w); };
void setMinimumHeight(int h) { callbackQWindow_SetMinimumHeight(this, h); };
void setMinimumWidth(int w) { callbackQWindow_SetMinimumWidth(this, w); };
void setTitle(const QString & vqs) { QByteArray tda39a3 = vqs.toUtf8(); QtGui_PackedString vqsPacked = { const_cast<char*>(tda39a3.prepend("WHITESPACE").constData()+10), tda39a3.size()-10 };callbackQWindow_SetTitle(this, vqsPacked); };
void setVisible(bool visible) { callbackQWindow_SetVisible(this, visible); };
void setWidth(int arg) { callbackQWindow_SetWidth(this, arg); };
void setX(int arg) { callbackQWindow_SetX(this, arg); };
void setY(int arg) { callbackQWindow_SetY(this, arg); };
void show() { callbackQWindow_Show(this); };
void showEvent(QShowEvent * ev) { callbackQWindow_ShowEvent(this, ev); };
void showFullScreen() { callbackQWindow_ShowFullScreen(this); };
void showMaximized() { callbackQWindow_ShowMaximized(this); };
void showMinimized() { callbackQWindow_ShowMinimized(this); };
void showNormal() { callbackQWindow_ShowNormal(this); };
void tabletEvent(QTabletEvent * ev) { callbackQWindow_TabletEvent(this, ev); };
void touchEvent(QTouchEvent * ev) { callbackQWindow_TouchEvent(this, ev); };
void Signal_VisibilityChanged(QWindow::Visibility visibility) { callbackQWindow_VisibilityChanged(this, visibility); };
void Signal_VisibleChanged(bool arg) { callbackQWindow_VisibleChanged(this, arg); };
void wheelEvent(QWheelEvent * ev) { callbackQWindow_WheelEvent(this, ev); };
void Signal_WidthChanged(int arg) { callbackQWindow_WidthChanged(this, arg); };
void Signal_WindowStateChanged(Qt::WindowState windowState) { callbackQWindow_WindowStateChanged(this, windowState); };
void Signal_WindowTitleChanged(const QString & title) { QByteArray t3c6de1 = title.toUtf8(); QtGui_PackedString titlePacked = { const_cast<char*>(t3c6de1.prepend("WHITESPACE").constData()+10), t3c6de1.size()-10 };callbackQWindow_WindowTitleChanged(this, titlePacked); };
void Signal_XChanged(int arg) { callbackQWindow_XChanged(this, arg); };
void Signal_YChanged(int arg) { callbackQWindow_YChanged(this, arg); };
QObject * focusObject() const { return static_cast<QObject*>(callbackQWindow_FocusObject(const_cast<void*>(static_cast<const void*>(this)))); };
QSize size() const { return *static_cast<QSize*>(callbackQWindow_Size(const_cast<void*>(static_cast<const void*>(this)))); };
QSurface::SurfaceType surfaceType() const { return static_cast<QSurface::SurfaceType>(callbackQWindow_SurfaceType(const_cast<void*>(static_cast<const void*>(this)))); };
QSurfaceFormat format() const { return *static_cast<QSurfaceFormat*>(callbackQWindow_Format(const_cast<void*>(static_cast<const void*>(this)))); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQWindow_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQWindow_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQWindow_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQWindow_CustomEvent(this, event); };
void deleteLater() { callbackQWindow_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQWindow_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQWindow_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQWindow_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQWindow_TimerEvent(this, event); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQPaintDeviceWindow_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPaintDevice_Metric(const_cast<void*>(static_cast<const void*>(this)), metric); };
};
Q_DECLARE_METATYPE(MyQPaintDeviceWindow*)
int QPaintDeviceWindow_QPaintDeviceWindow_QRegisterMetaType(){qRegisterMetaType<QPaintDeviceWindow*>(); return qRegisterMetaType<MyQPaintDeviceWindow*>();}
void QPaintDeviceWindow_PaintEvent(void* ptr, void* event)
{
static_cast<QPaintDeviceWindow*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}
void QPaintDeviceWindow_PaintEventDefault(void* ptr, void* event)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::paintEvent(static_cast<QPaintEvent*>(event));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::paintEvent(static_cast<QPaintEvent*>(event));
} else {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::paintEvent(static_cast<QPaintEvent*>(event));
}
}
void QPaintDeviceWindow_Update3(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "update");
}
void QPaintDeviceWindow_Update3Default(void* ptr)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::update();
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::update();
} else {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::update();
}
}
void QPaintDeviceWindow_Update(void* ptr, void* rect)
{
static_cast<QPaintDeviceWindow*>(ptr)->update(*static_cast<QRect*>(rect));
}
void QPaintDeviceWindow_Update2(void* ptr, void* region)
{
static_cast<QPaintDeviceWindow*>(ptr)->update(*static_cast<QRegion*>(region));
}
void* QPaintDeviceWindow_PaintEngine(void* ptr)
{
return static_cast<QPaintDeviceWindow*>(ptr)->paintEngine();
}
void* QPaintDeviceWindow_PaintEngineDefault(void* ptr)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QRasterWindow*>(ptr)->QRasterWindow::paintEngine();
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::paintEngine();
} else {
return static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::paintEngine();
}
}
class MyQPaintEngine: public QPaintEngine
{
public:
MyQPaintEngine(QPaintEngine::PaintEngineFeatures caps = PaintEngineFeatures()) : QPaintEngine(caps) {};
bool begin(QPaintDevice * pdev) { return callbackQPaintEngine_Begin(this, pdev) != 0; };
bool end() { return callbackQPaintEngine_End(this) != 0; };
void drawEllipse(const QRect & rect) { callbackQPaintEngine_DrawEllipse2(this, const_cast<QRect*>(&rect)); };
void drawEllipse(const QRectF & rect) { callbackQPaintEngine_DrawEllipse(this, const_cast<QRectF*>(&rect)); };
void drawImage(const QRectF & rectangle, const QImage & image, const QRectF & sr, Qt::ImageConversionFlags flags) { callbackQPaintEngine_DrawImage(this, const_cast<QRectF*>(&rectangle), const_cast<QImage*>(&image), const_cast<QRectF*>(&sr), flags); };
void drawLines(const QLine * lines, int lineCount) { callbackQPaintEngine_DrawLines2(this, const_cast<QLine*>(lines), lineCount); };
void drawLines(const QLineF * lines, int lineCount) { callbackQPaintEngine_DrawLines(this, const_cast<QLineF*>(lines), lineCount); };
void drawPath(const QPainterPath & path) { callbackQPaintEngine_DrawPath(this, const_cast<QPainterPath*>(&path)); };
void drawPixmap(const QRectF & r, const QPixmap & pm, const QRectF & sr) { callbackQPaintEngine_DrawPixmap(this, const_cast<QRectF*>(&r), const_cast<QPixmap*>(&pm), const_cast<QRectF*>(&sr)); };
void drawPoints(const QPoint * points, int pointCount) { callbackQPaintEngine_DrawPoints2(this, const_cast<QPoint*>(points), pointCount); };
void drawPoints(const QPointF * points, int pointCount) { callbackQPaintEngine_DrawPoints(this, const_cast<QPointF*>(points), pointCount); };
void drawPolygon(const QPoint * points, int pointCount, QPaintEngine::PolygonDrawMode mode) { callbackQPaintEngine_DrawPolygon2(this, const_cast<QPoint*>(points), pointCount, mode); };
void drawPolygon(const QPointF * points, int pointCount, QPaintEngine::PolygonDrawMode mode) { callbackQPaintEngine_DrawPolygon(this, const_cast<QPointF*>(points), pointCount, mode); };
void drawRects(const QRect * rects, int rectCount) { callbackQPaintEngine_DrawRects2(this, const_cast<QRect*>(rects), rectCount); };
void drawRects(const QRectF * rects, int rectCount) { callbackQPaintEngine_DrawRects(this, const_cast<QRectF*>(rects), rectCount); };
void drawTextItem(const QPointF & p, const QTextItem & textItem) { callbackQPaintEngine_DrawTextItem(this, const_cast<QPointF*>(&p), const_cast<QTextItem*>(&textItem)); };
void drawTiledPixmap(const QRectF & rect, const QPixmap & pixmap, const QPointF & p) { callbackQPaintEngine_DrawTiledPixmap(this, const_cast<QRectF*>(&rect), const_cast<QPixmap*>(&pixmap), const_cast<QPointF*>(&p)); };
void updateState(const QPaintEngineState & state) { callbackQPaintEngine_UpdateState(this, const_cast<QPaintEngineState*>(&state)); };
~MyQPaintEngine() { callbackQPaintEngine_DestroyQPaintEngine(this); };
QPaintEngine::Type type() const { return static_cast<QPaintEngine::Type>(callbackQPaintEngine_Type(const_cast<void*>(static_cast<const void*>(this)))); };
};
void* QPaintEngine_NewQPaintEngine(long long caps)
{
return new MyQPaintEngine(static_cast<QPaintEngine::PaintEngineFeature>(caps));
}
char QPaintEngine_Begin(void* ptr, void* pdev)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(pdev))) {
return static_cast<QPaintEngine*>(ptr)->begin(static_cast<QPaintDeviceWindow*>(pdev));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(pdev))) {
return static_cast<QPaintEngine*>(ptr)->begin(static_cast<QPdfWriter*>(pdev));
} else {
return static_cast<QPaintEngine*>(ptr)->begin(static_cast<QPaintDevice*>(pdev));
}
}
char QPaintEngine_End(void* ptr)
{
return static_cast<QPaintEngine*>(ptr)->end();
}
void QPaintEngine_DrawEllipse2(void* ptr, void* rect)
{
static_cast<QPaintEngine*>(ptr)->drawEllipse(*static_cast<QRect*>(rect));
}
void QPaintEngine_DrawEllipse2Default(void* ptr, void* rect)
{
static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawEllipse(*static_cast<QRect*>(rect));
}
void QPaintEngine_DrawEllipse(void* ptr, void* rect)
{
static_cast<QPaintEngine*>(ptr)->drawEllipse(*static_cast<QRectF*>(rect));
}
void QPaintEngine_DrawEllipseDefault(void* ptr, void* rect)
{
static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawEllipse(*static_cast<QRectF*>(rect));
}
void QPaintEngine_DrawImage(void* ptr, void* rectangle, void* image, void* sr, long long flags)
{
static_cast<QPaintEngine*>(ptr)->drawImage(*static_cast<QRectF*>(rectangle), *static_cast<QImage*>(image), *static_cast<QRectF*>(sr), static_cast<Qt::ImageConversionFlag>(flags));
}
void QPaintEngine_DrawImageDefault(void* ptr, void* rectangle, void* image, void* sr, long long flags)
{
static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawImage(*static_cast<QRectF*>(rectangle), *static_cast<QImage*>(image), *static_cast<QRectF*>(sr), static_cast<Qt::ImageConversionFlag>(flags));
}
void QPaintEngine_DrawLines2(void* ptr, void* lines, int lineCount)
{
static_cast<QPaintEngine*>(ptr)->drawLines(static_cast<QLine*>(lines), lineCount);
}
void QPaintEngine_DrawLines2Default(void* ptr, void* lines, int lineCount)
{
static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawLines(static_cast<QLine*>(lines), lineCount);
}
void QPaintEngine_DrawLines(void* ptr, void* lines, int lineCount)
{
static_cast<QPaintEngine*>(ptr)->drawLines(static_cast<QLineF*>(lines), lineCount);
}
void QPaintEngine_DrawLinesDefault(void* ptr, void* lines, int lineCount)
{
static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawLines(static_cast<QLineF*>(lines), lineCount);
}
void QPaintEngine_DrawPath(void* ptr, void* path)
{
static_cast<QPaintEngine*>(ptr)->drawPath(*static_cast<QPainterPath*>(path));
}
void QPaintEngine_DrawPathDefault(void* ptr, void* path)
{
static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawPath(*static_cast<QPainterPath*>(path));
}
void QPaintEngine_DrawPixmap(void* ptr, void* r, void* pm, void* sr)
{
static_cast<QPaintEngine*>(ptr)->drawPixmap(*static_cast<QRectF*>(r), *static_cast<QPixmap*>(pm), *static_cast<QRectF*>(sr));
}
void QPaintEngine_DrawPoints2(void* ptr, void* points, int pointCount)
{
static_cast<QPaintEngine*>(ptr)->drawPoints(static_cast<QPoint*>(points), pointCount);
}
void QPaintEngine_DrawPoints2Default(void* ptr, void* points, int pointCount)
{
static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawPoints(static_cast<QPoint*>(points), pointCount);
}
void QPaintEngine_DrawPoints(void* ptr, void* points, int pointCount)
{
static_cast<QPaintEngine*>(ptr)->drawPoints(static_cast<QPointF*>(points), pointCount);
}
void QPaintEngine_DrawPointsDefault(void* ptr, void* points, int pointCount)
{
static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawPoints(static_cast<QPointF*>(points), pointCount);
}
void QPaintEngine_DrawPolygon2(void* ptr, void* points, int pointCount, long long mode)
{
static_cast<QPaintEngine*>(ptr)->drawPolygon(static_cast<QPoint*>(points), pointCount, static_cast<QPaintEngine::PolygonDrawMode>(mode));
}
void QPaintEngine_DrawPolygon2Default(void* ptr, void* points, int pointCount, long long mode)
{
static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawPolygon(static_cast<QPoint*>(points), pointCount, static_cast<QPaintEngine::PolygonDrawMode>(mode));
}
void QPaintEngine_DrawPolygon(void* ptr, void* points, int pointCount, long long mode)
{
static_cast<QPaintEngine*>(ptr)->drawPolygon(static_cast<QPointF*>(points), pointCount, static_cast<QPaintEngine::PolygonDrawMode>(mode));
}
void QPaintEngine_DrawPolygonDefault(void* ptr, void* points, int pointCount, long long mode)
{
static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawPolygon(static_cast<QPointF*>(points), pointCount, static_cast<QPaintEngine::PolygonDrawMode>(mode));
}
void QPaintEngine_DrawRects2(void* ptr, void* rects, int rectCount)
{
static_cast<QPaintEngine*>(ptr)->drawRects(static_cast<QRect*>(rects), rectCount);
}
void QPaintEngine_DrawRects2Default(void* ptr, void* rects, int rectCount)
{
static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawRects(static_cast<QRect*>(rects), rectCount);
}
void QPaintEngine_DrawRects(void* ptr, void* rects, int rectCount)
{
static_cast<QPaintEngine*>(ptr)->drawRects(static_cast<QRectF*>(rects), rectCount);
}
void QPaintEngine_DrawRectsDefault(void* ptr, void* rects, int rectCount)
{
static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawRects(static_cast<QRectF*>(rects), rectCount);
}
void QPaintEngine_DrawTextItem(void* ptr, void* p, void* textItem)
{
static_cast<QPaintEngine*>(ptr)->drawTextItem(*static_cast<QPointF*>(p), *static_cast<QTextItem*>(textItem));
}
void QPaintEngine_DrawTextItemDefault(void* ptr, void* p, void* textItem)
{
static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawTextItem(*static_cast<QPointF*>(p), *static_cast<QTextItem*>(textItem));
}
void QPaintEngine_DrawTiledPixmap(void* ptr, void* rect, void* pixmap, void* p)
{
static_cast<QPaintEngine*>(ptr)->drawTiledPixmap(*static_cast<QRectF*>(rect), *static_cast<QPixmap*>(pixmap), *static_cast<QPointF*>(p));
}
void QPaintEngine_DrawTiledPixmapDefault(void* ptr, void* rect, void* pixmap, void* p)
{
static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawTiledPixmap(*static_cast<QRectF*>(rect), *static_cast<QPixmap*>(pixmap), *static_cast<QPointF*>(p));
}
void QPaintEngine_SetActive(void* ptr, char state)
{
static_cast<QPaintEngine*>(ptr)->setActive(state != 0);
}
void QPaintEngine_UpdateState(void* ptr, void* state)
{
static_cast<QPaintEngine*>(ptr)->updateState(*static_cast<QPaintEngineState*>(state));
}
void QPaintEngine_DestroyQPaintEngine(void* ptr)
{
static_cast<QPaintEngine*>(ptr)->~QPaintEngine();
}
void QPaintEngine_DestroyQPaintEngineDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QPaintEngine_PaintDevice(void* ptr)
{
return static_cast<QPaintEngine*>(ptr)->paintDevice();
}
long long QPaintEngine_Type(void* ptr)
{
return static_cast<QPaintEngine*>(ptr)->type();
}
void* QPaintEngine_Painter(void* ptr)
{
return static_cast<QPaintEngine*>(ptr)->painter();
}
char QPaintEngine_HasFeature(void* ptr, long long feature)
{
return static_cast<QPaintEngine*>(ptr)->hasFeature(static_cast<QPaintEngine::PaintEngineFeature>(feature));
}
char QPaintEngine_IsActive(void* ptr)
{
return static_cast<QPaintEngine*>(ptr)->isActive();
}
unsigned int QPaintEngine_Active(void* ptr)
{
return static_cast<QPaintEngine*>(ptr)->active;
}
unsigned int QPaintEngine_Extended(void* ptr)
{
return static_cast<QPaintEngine*>(ptr)->extended;
}
void QPaintEngine_SetExtended(void* ptr, unsigned int vui)
{
static_cast<QPaintEngine*>(ptr)->extended = vui;
}
long long QPaintEngine_Gccaps(void* ptr)
{
return static_cast<QPaintEngine*>(ptr)->gccaps;
}
void QPaintEngine_SetGccaps(void* ptr, long long vqp)
{
static_cast<QPaintEngine*>(ptr)->gccaps = static_cast<QPaintEngine::PaintEngineFeature>(vqp);
}
unsigned int QPaintEngine_SelfDestruct(void* ptr)
{
return static_cast<QPaintEngine*>(ptr)->selfDestruct;
}
void QPaintEngine_SetSelfDestruct(void* ptr, unsigned int vui)
{
static_cast<QPaintEngine*>(ptr)->selfDestruct = vui;
}
void* QPaintEngine_State(void* ptr)
{
return static_cast<QPaintEngine*>(ptr)->state;
}
void QPaintEngine_SetState(void* ptr, void* vqp)
{
static_cast<QPaintEngine*>(ptr)->state = static_cast<QPaintEngineState*>(vqp);
}
void* QPaintEngineState_BackgroundBrush(void* ptr)
{
return new QBrush(static_cast<QPaintEngineState*>(ptr)->backgroundBrush());
}
void* QPaintEngineState_Brush(void* ptr)
{
return new QBrush(static_cast<QPaintEngineState*>(ptr)->brush());
}
void* QPaintEngineState_Font(void* ptr)
{
return new QFont(static_cast<QPaintEngineState*>(ptr)->font());
}
long long QPaintEngineState_State(void* ptr)
{
return static_cast<QPaintEngineState*>(ptr)->state();
}
void* QPaintEngineState_Painter(void* ptr)
{
return static_cast<QPaintEngineState*>(ptr)->painter();
}
long long QPaintEngineState_CompositionMode(void* ptr)
{
return static_cast<QPaintEngineState*>(ptr)->compositionMode();
}
long long QPaintEngineState_RenderHints(void* ptr)
{
return static_cast<QPaintEngineState*>(ptr)->renderHints();
}
void* QPaintEngineState_ClipPath(void* ptr)
{
return new QPainterPath(static_cast<QPaintEngineState*>(ptr)->clipPath());
}
void* QPaintEngineState_Pen(void* ptr)
{
return new QPen(static_cast<QPaintEngineState*>(ptr)->pen());
}
void* QPaintEngineState_BrushOrigin(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QPaintEngineState*>(ptr)->brushOrigin(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void* QPaintEngineState_ClipRegion(void* ptr)
{
return new QRegion(static_cast<QPaintEngineState*>(ptr)->clipRegion());
}
void* QPaintEngineState_Transform(void* ptr)
{
return new QTransform(static_cast<QPaintEngineState*>(ptr)->transform());
}
long long QPaintEngineState_BackgroundMode(void* ptr)
{
return static_cast<QPaintEngineState*>(ptr)->backgroundMode();
}
long long QPaintEngineState_ClipOperation(void* ptr)
{
return static_cast<QPaintEngineState*>(ptr)->clipOperation();
}
char QPaintEngineState_BrushNeedsResolving(void* ptr)
{
return static_cast<QPaintEngineState*>(ptr)->brushNeedsResolving();
}
char QPaintEngineState_IsClipEnabled(void* ptr)
{
return static_cast<QPaintEngineState*>(ptr)->isClipEnabled();
}
char QPaintEngineState_PenNeedsResolving(void* ptr)
{
return static_cast<QPaintEngineState*>(ptr)->penNeedsResolving();
}
double QPaintEngineState_Opacity(void* ptr)
{
return static_cast<QPaintEngineState*>(ptr)->opacity();
}
long long QPaintEngineState_DirtyFlags(void* ptr)
{
return static_cast<QPaintEngineState*>(ptr)->dirtyFlags;
}
void QPaintEngineState_SetDirtyFlags(void* ptr, long long vqp)
{
static_cast<QPaintEngineState*>(ptr)->dirtyFlags = static_cast<QPaintEngine::DirtyFlag>(vqp);
}
class MyQPaintEvent: public QPaintEvent
{
public:
MyQPaintEvent(const QRect &paintRect) : QPaintEvent(paintRect) {};
MyQPaintEvent(const QRegion &paintRegion) : QPaintEvent(paintRegion) {};
};
void* QPaintEvent_NewQPaintEvent2(void* paintRect)
{
return new MyQPaintEvent(*static_cast<QRect*>(paintRect));
}
void* QPaintEvent_NewQPaintEvent(void* paintRegion)
{
return new MyQPaintEvent(*static_cast<QRegion*>(paintRegion));
}
void* QPaintEvent_Rect(void* ptr)
{
return const_cast<QRect*>(&static_cast<QPaintEvent*>(ptr)->rect());
}
void* QPaintEvent_Region(void* ptr)
{
return const_cast<QRegion*>(&static_cast<QPaintEvent*>(ptr)->region());
}
char QPaintEvent_M_erased(void* ptr)
{
return static_cast<QPaintEvent*>(ptr)->m_erased;
}
void QPaintEvent_SetM_erased(void* ptr, char vbo)
{
static_cast<QPaintEvent*>(ptr)->m_erased = vbo != 0;
}
void* QPaintEvent_M_rect(void* ptr)
{
return ({ QRect tmpValue = static_cast<QPaintEvent*>(ptr)->m_rect; new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void QPaintEvent_SetM_rect(void* ptr, void* vqr)
{
static_cast<QPaintEvent*>(ptr)->m_rect = *static_cast<QRect*>(vqr);
}
void* QPaintEvent_M_region(void* ptr)
{
return new QRegion(static_cast<QPaintEvent*>(ptr)->m_region);
}
void QPaintEvent_SetM_region(void* ptr, void* vqr)
{
static_cast<QPaintEvent*>(ptr)->m_region = *static_cast<QRegion*>(vqr);
}
void* QPainter_NewQPainter()
{
return new QPainter();
}
void* QPainter_NewQPainter2(void* device)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(device))) {
return new QPainter(static_cast<QPaintDeviceWindow*>(device));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(device))) {
return new QPainter(static_cast<QPdfWriter*>(device));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(device))) {
return new QPainter(static_cast<QWidget*>(device));
} else {
return new QPainter(static_cast<QPaintDevice*>(device));
}
}
void* QPainter_BoundingRect2(void* ptr, void* rectangle, int flags, struct QtGui_PackedString text)
{
return ({ QRect tmpValue = static_cast<QPainter*>(ptr)->boundingRect(*static_cast<QRect*>(rectangle), flags, QString::fromUtf8(text.data, text.len)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QPainter_BoundingRect3(void* ptr, int x, int y, int w, int h, int flags, struct QtGui_PackedString text)
{
return ({ QRect tmpValue = static_cast<QPainter*>(ptr)->boundingRect(x, y, w, h, flags, QString::fromUtf8(text.data, text.len)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QPainter_BoundingRect4(void* ptr, void* rectangle, struct QtGui_PackedString text, void* option)
{
return ({ QRectF tmpValue = static_cast<QPainter*>(ptr)->boundingRect(*static_cast<QRectF*>(rectangle), QString::fromUtf8(text.data, text.len), *static_cast<QTextOption*>(option)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QPainter_BoundingRect(void* ptr, void* rectangle, int flags, struct QtGui_PackedString text)
{
return ({ QRectF tmpValue = static_cast<QPainter*>(ptr)->boundingRect(*static_cast<QRectF*>(rectangle), flags, QString::fromUtf8(text.data, text.len)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
char QPainter_Begin(void* ptr, void* device)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(device))) {
return static_cast<QPainter*>(ptr)->begin(static_cast<QPaintDeviceWindow*>(device));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(device))) {
return static_cast<QPainter*>(ptr)->begin(static_cast<QPdfWriter*>(device));
} else {
return static_cast<QPainter*>(ptr)->begin(static_cast<QPaintDevice*>(device));
}
}
char QPainter_End(void* ptr)
{
return static_cast<QPainter*>(ptr)->end();
}
void QPainter_BeginNativePainting(void* ptr)
{
static_cast<QPainter*>(ptr)->beginNativePainting();
}
void QPainter_DrawArc2(void* ptr, void* rectangle, int startAngle, int spanAngle)
{
static_cast<QPainter*>(ptr)->drawArc(*static_cast<QRect*>(rectangle), startAngle, spanAngle);
}
void QPainter_DrawArc(void* ptr, void* rectangle, int startAngle, int spanAngle)
{
static_cast<QPainter*>(ptr)->drawArc(*static_cast<QRectF*>(rectangle), startAngle, spanAngle);
}
void QPainter_DrawArc3(void* ptr, int x, int y, int width, int height, int startAngle, int spanAngle)
{
static_cast<QPainter*>(ptr)->drawArc(x, y, width, height, startAngle, spanAngle);
}
void QPainter_DrawChord3(void* ptr, void* rectangle, int startAngle, int spanAngle)
{
static_cast<QPainter*>(ptr)->drawChord(*static_cast<QRect*>(rectangle), startAngle, spanAngle);
}
void QPainter_DrawChord(void* ptr, void* rectangle, int startAngle, int spanAngle)
{
static_cast<QPainter*>(ptr)->drawChord(*static_cast<QRectF*>(rectangle), startAngle, spanAngle);
}
void QPainter_DrawChord2(void* ptr, int x, int y, int width, int height, int startAngle, int spanAngle)
{
static_cast<QPainter*>(ptr)->drawChord(x, y, width, height, startAngle, spanAngle);
}
void QPainter_DrawConvexPolygon3(void* ptr, void* points, int pointCount)
{
static_cast<QPainter*>(ptr)->drawConvexPolygon(static_cast<QPoint*>(points), pointCount);
}
void QPainter_DrawConvexPolygon(void* ptr, void* points, int pointCount)
{
static_cast<QPainter*>(ptr)->drawConvexPolygon(static_cast<QPointF*>(points), pointCount);
}
void QPainter_DrawConvexPolygon4(void* ptr, void* polygon)
{
static_cast<QPainter*>(ptr)->drawConvexPolygon(*static_cast<QPolygon*>(polygon));
}
void QPainter_DrawConvexPolygon2(void* ptr, void* polygon)
{
static_cast<QPainter*>(ptr)->drawConvexPolygon(*static_cast<QPolygonF*>(polygon));
}
void QPainter_DrawEllipse5(void* ptr, void* center, int rx, int ry)
{
static_cast<QPainter*>(ptr)->drawEllipse(*static_cast<QPoint*>(center), rx, ry);
}
void QPainter_DrawEllipse4(void* ptr, void* center, double rx, double ry)
{
static_cast<QPainter*>(ptr)->drawEllipse(*static_cast<QPointF*>(center), rx, ry);
}
void QPainter_DrawEllipse2(void* ptr, void* rectangle)
{
static_cast<QPainter*>(ptr)->drawEllipse(*static_cast<QRect*>(rectangle));
}
void QPainter_DrawEllipse(void* ptr, void* rectangle)
{
static_cast<QPainter*>(ptr)->drawEllipse(*static_cast<QRectF*>(rectangle));
}
void QPainter_DrawEllipse3(void* ptr, int x, int y, int width, int height)
{
static_cast<QPainter*>(ptr)->drawEllipse(x, y, width, height);
}
void QPainter_DrawGlyphRun(void* ptr, void* position, void* glyphs)
{
static_cast<QPainter*>(ptr)->drawGlyphRun(*static_cast<QPointF*>(position), *static_cast<QGlyphRun*>(glyphs));
}
void QPainter_DrawImage8(void* ptr, void* point, void* image)
{
static_cast<QPainter*>(ptr)->drawImage(*static_cast<QPoint*>(point), *static_cast<QImage*>(image));
}
void QPainter_DrawImage4(void* ptr, void* point, void* image, void* source, long long flags)
{
static_cast<QPainter*>(ptr)->drawImage(*static_cast<QPoint*>(point), *static_cast<QImage*>(image), *static_cast<QRect*>(source), static_cast<Qt::ImageConversionFlag>(flags));
}
void QPainter_DrawImage7(void* ptr, void* point, void* image)
{
static_cast<QPainter*>(ptr)->drawImage(*static_cast<QPointF*>(point), *static_cast<QImage*>(image));
}
void QPainter_DrawImage3(void* ptr, void* point, void* image, void* source, long long flags)
{
static_cast<QPainter*>(ptr)->drawImage(*static_cast<QPointF*>(point), *static_cast<QImage*>(image), *static_cast<QRectF*>(source), static_cast<Qt::ImageConversionFlag>(flags));
}
void QPainter_DrawImage6(void* ptr, void* rectangle, void* image)
{
static_cast<QPainter*>(ptr)->drawImage(*static_cast<QRect*>(rectangle), *static_cast<QImage*>(image));
}
void QPainter_DrawImage2(void* ptr, void* target, void* image, void* source, long long flags)
{
static_cast<QPainter*>(ptr)->drawImage(*static_cast<QRect*>(target), *static_cast<QImage*>(image), *static_cast<QRect*>(source), static_cast<Qt::ImageConversionFlag>(flags));
}
void QPainter_DrawImage5(void* ptr, void* rectangle, void* image)
{
static_cast<QPainter*>(ptr)->drawImage(*static_cast<QRectF*>(rectangle), *static_cast<QImage*>(image));
}
void QPainter_DrawImage(void* ptr, void* target, void* image, void* source, long long flags)
{
static_cast<QPainter*>(ptr)->drawImage(*static_cast<QRectF*>(target), *static_cast<QImage*>(image), *static_cast<QRectF*>(source), static_cast<Qt::ImageConversionFlag>(flags));
}
void QPainter_DrawImage9(void* ptr, int x, int y, void* image, int sx, int sy, int sw, int sh, long long flags)
{
static_cast<QPainter*>(ptr)->drawImage(x, y, *static_cast<QImage*>(image), sx, sy, sw, sh, static_cast<Qt::ImageConversionFlag>(flags));
}
void QPainter_DrawLine2(void* ptr, void* line)
{
static_cast<QPainter*>(ptr)->drawLine(*static_cast<QLine*>(line));
}
void QPainter_DrawLine(void* ptr, void* line)
{
static_cast<QPainter*>(ptr)->drawLine(*static_cast<QLineF*>(line));
}
void QPainter_DrawLine4(void* ptr, void* p1, void* p2)
{
static_cast<QPainter*>(ptr)->drawLine(*static_cast<QPoint*>(p1), *static_cast<QPoint*>(p2));
}
void QPainter_DrawLine5(void* ptr, void* p1, void* p2)
{
static_cast<QPainter*>(ptr)->drawLine(*static_cast<QPointF*>(p1), *static_cast<QPointF*>(p2));
}
void QPainter_DrawLine3(void* ptr, int x1, int y1, int x2, int y2)
{
static_cast<QPainter*>(ptr)->drawLine(x1, y1, x2, y2);
}
void QPainter_DrawLines5(void* ptr, void* lines, int lineCount)
{
static_cast<QPainter*>(ptr)->drawLines(static_cast<QLine*>(lines), lineCount);
}
void QPainter_DrawLines(void* ptr, void* lines, int lineCount)
{
static_cast<QPainter*>(ptr)->drawLines(static_cast<QLineF*>(lines), lineCount);
}
void QPainter_DrawLines7(void* ptr, void* pointPairs, int lineCount)
{
static_cast<QPainter*>(ptr)->drawLines(static_cast<QPoint*>(pointPairs), lineCount);
}
void QPainter_DrawLines3(void* ptr, void* pointPairs, int lineCount)
{
static_cast<QPainter*>(ptr)->drawLines(static_cast<QPointF*>(pointPairs), lineCount);
}
void QPainter_DrawLines6(void* ptr, void* lines)
{
static_cast<QPainter*>(ptr)->drawLines(*static_cast<QVector<QLine>*>(lines));
}
void QPainter_DrawLines2(void* ptr, void* lines)
{
static_cast<QPainter*>(ptr)->drawLines(*static_cast<QVector<QLineF>*>(lines));
}
void QPainter_DrawLines8(void* ptr, void* pointPairs)
{
static_cast<QPainter*>(ptr)->drawLines(*static_cast<QVector<QPoint>*>(pointPairs));
}
void QPainter_DrawLines4(void* ptr, void* pointPairs)
{
static_cast<QPainter*>(ptr)->drawLines(*static_cast<QVector<QPointF>*>(pointPairs));
}
void QPainter_DrawPath(void* ptr, void* path)
{
static_cast<QPainter*>(ptr)->drawPath(*static_cast<QPainterPath*>(path));
}
void QPainter_DrawPicture3(void* ptr, void* point, void* picture)
{
static_cast<QPainter*>(ptr)->drawPicture(*static_cast<QPoint*>(point), *static_cast<QPicture*>(picture));
}
void QPainter_DrawPicture(void* ptr, void* point, void* picture)
{
static_cast<QPainter*>(ptr)->drawPicture(*static_cast<QPointF*>(point), *static_cast<QPicture*>(picture));
}
void QPainter_DrawPicture2(void* ptr, int x, int y, void* picture)
{
static_cast<QPainter*>(ptr)->drawPicture(x, y, *static_cast<QPicture*>(picture));
}
void QPainter_DrawPie3(void* ptr, void* rectangle, int startAngle, int spanAngle)
{
static_cast<QPainter*>(ptr)->drawPie(*static_cast<QRect*>(rectangle), startAngle, spanAngle);
}
void QPainter_DrawPie(void* ptr, void* rectangle, int startAngle, int spanAngle)
{
static_cast<QPainter*>(ptr)->drawPie(*static_cast<QRectF*>(rectangle), startAngle, spanAngle);
}
void QPainter_DrawPie2(void* ptr, int x, int y, int width, int height, int startAngle, int spanAngle)
{
static_cast<QPainter*>(ptr)->drawPie(x, y, width, height, startAngle, spanAngle);
}
void QPainter_DrawPixmap8(void* ptr, void* point, void* pixmap)
{
static_cast<QPainter*>(ptr)->drawPixmap(*static_cast<QPoint*>(point), *static_cast<QPixmap*>(pixmap));
}
void QPainter_DrawPixmap6(void* ptr, void* point, void* pixmap, void* source)
{
static_cast<QPainter*>(ptr)->drawPixmap(*static_cast<QPoint*>(point), *static_cast<QPixmap*>(pixmap), *static_cast<QRect*>(source));
}
void QPainter_DrawPixmap7(void* ptr, void* point, void* pixmap)
{
static_cast<QPainter*>(ptr)->drawPixmap(*static_cast<QPointF*>(point), *static_cast<QPixmap*>(pixmap));
}
void QPainter_DrawPixmap5(void* ptr, void* point, void* pixmap, void* source)
{
static_cast<QPainter*>(ptr)->drawPixmap(*static_cast<QPointF*>(point), *static_cast<QPixmap*>(pixmap), *static_cast<QRectF*>(source));
}
void QPainter_DrawPixmap10(void* ptr, void* rectangle, void* pixmap)
{
static_cast<QPainter*>(ptr)->drawPixmap(*static_cast<QRect*>(rectangle), *static_cast<QPixmap*>(pixmap));
}
void QPainter_DrawPixmap2(void* ptr, void* target, void* pixmap, void* source)
{
static_cast<QPainter*>(ptr)->drawPixmap(*static_cast<QRect*>(target), *static_cast<QPixmap*>(pixmap), *static_cast<QRect*>(source));
}
void QPainter_DrawPixmap(void* ptr, void* target, void* pixmap, void* source)
{
static_cast<QPainter*>(ptr)->drawPixmap(*static_cast<QRectF*>(target), *static_cast<QPixmap*>(pixmap), *static_cast<QRectF*>(source));
}
void QPainter_DrawPixmap9(void* ptr, int x, int y, void* pixmap)
{
static_cast<QPainter*>(ptr)->drawPixmap(x, y, *static_cast<QPixmap*>(pixmap));
}
void QPainter_DrawPixmap4(void* ptr, int x, int y, void* pixmap, int sx, int sy, int sw, int sh)
{
static_cast<QPainter*>(ptr)->drawPixmap(x, y, *static_cast<QPixmap*>(pixmap), sx, sy, sw, sh);
}
void QPainter_DrawPixmap3(void* ptr, int x, int y, int w, int h, void* pixmap, int sx, int sy, int sw, int sh)
{
static_cast<QPainter*>(ptr)->drawPixmap(x, y, w, h, *static_cast<QPixmap*>(pixmap), sx, sy, sw, sh);
}
void QPainter_DrawPixmap11(void* ptr, int x, int y, int width, int height, void* pixmap)
{
static_cast<QPainter*>(ptr)->drawPixmap(x, y, width, height, *static_cast<QPixmap*>(pixmap));
}
void QPainter_DrawPoint2(void* ptr, void* position)
{
static_cast<QPainter*>(ptr)->drawPoint(*static_cast<QPoint*>(position));
}
void QPainter_DrawPoint(void* ptr, void* position)
{
static_cast<QPainter*>(ptr)->drawPoint(*static_cast<QPointF*>(position));
}
void QPainter_DrawPoint3(void* ptr, int x, int y)
{
static_cast<QPainter*>(ptr)->drawPoint(x, y);
}
void QPainter_DrawPoints3(void* ptr, void* points, int pointCount)
{
static_cast<QPainter*>(ptr)->drawPoints(static_cast<QPoint*>(points), pointCount);
}
void QPainter_DrawPoints(void* ptr, void* points, int pointCount)
{
static_cast<QPainter*>(ptr)->drawPoints(static_cast<QPointF*>(points), pointCount);
}
void QPainter_DrawPoints4(void* ptr, void* points)
{
static_cast<QPainter*>(ptr)->drawPoints(*static_cast<QPolygon*>(points));
}
void QPainter_DrawPoints2(void* ptr, void* points)
{
static_cast<QPainter*>(ptr)->drawPoints(*static_cast<QPolygonF*>(points));
}
void QPainter_DrawPolygon3(void* ptr, void* points, int pointCount, long long fillRule)
{
static_cast<QPainter*>(ptr)->drawPolygon(static_cast<QPoint*>(points), pointCount, static_cast<Qt::FillRule>(fillRule));
}
void QPainter_DrawPolygon(void* ptr, void* points, int pointCount, long long fillRule)
{
static_cast<QPainter*>(ptr)->drawPolygon(static_cast<QPointF*>(points), pointCount, static_cast<Qt::FillRule>(fillRule));
}
void QPainter_DrawPolygon4(void* ptr, void* points, long long fillRule)
{
static_cast<QPainter*>(ptr)->drawPolygon(*static_cast<QPolygon*>(points), static_cast<Qt::FillRule>(fillRule));
}
void QPainter_DrawPolygon2(void* ptr, void* points, long long fillRule)
{
static_cast<QPainter*>(ptr)->drawPolygon(*static_cast<QPolygonF*>(points), static_cast<Qt::FillRule>(fillRule));
}
void QPainter_DrawPolyline3(void* ptr, void* points, int pointCount)
{
static_cast<QPainter*>(ptr)->drawPolyline(static_cast<QPoint*>(points), pointCount);
}
void QPainter_DrawPolyline(void* ptr, void* points, int pointCount)
{
static_cast<QPainter*>(ptr)->drawPolyline(static_cast<QPointF*>(points), pointCount);
}
void QPainter_DrawPolyline4(void* ptr, void* points)
{
static_cast<QPainter*>(ptr)->drawPolyline(*static_cast<QPolygon*>(points));
}
void QPainter_DrawPolyline2(void* ptr, void* points)
{
static_cast<QPainter*>(ptr)->drawPolyline(*static_cast<QPolygonF*>(points));
}
void QPainter_DrawRect3(void* ptr, void* rectangle)
{
static_cast<QPainter*>(ptr)->drawRect(*static_cast<QRect*>(rectangle));
}
void QPainter_DrawRect(void* ptr, void* rectangle)
{
static_cast<QPainter*>(ptr)->drawRect(*static_cast<QRectF*>(rectangle));
}
void QPainter_DrawRect2(void* ptr, int x, int y, int width, int height)
{
static_cast<QPainter*>(ptr)->drawRect(x, y, width, height);
}
void QPainter_DrawRects3(void* ptr, void* rectangles, int rectCount)
{
static_cast<QPainter*>(ptr)->drawRects(static_cast<QRect*>(rectangles), rectCount);
}
void QPainter_DrawRects(void* ptr, void* rectangles, int rectCount)
{
static_cast<QPainter*>(ptr)->drawRects(static_cast<QRectF*>(rectangles), rectCount);
}
void QPainter_DrawRects4(void* ptr, void* rectangles)
{
static_cast<QPainter*>(ptr)->drawRects(*static_cast<QVector<QRect>*>(rectangles));
}
void QPainter_DrawRects2(void* ptr, void* rectangles)
{
static_cast<QPainter*>(ptr)->drawRects(*static_cast<QVector<QRectF>*>(rectangles));
}
void QPainter_DrawRoundedRect3(void* ptr, void* rect, double xRadius, double yRadius, long long mode)
{
static_cast<QPainter*>(ptr)->drawRoundedRect(*static_cast<QRect*>(rect), xRadius, yRadius, static_cast<Qt::SizeMode>(mode));
}
void QPainter_DrawRoundedRect(void* ptr, void* rect, double xRadius, double yRadius, long long mode)
{
static_cast<QPainter*>(ptr)->drawRoundedRect(*static_cast<QRectF*>(rect), xRadius, yRadius, static_cast<Qt::SizeMode>(mode));
}
void QPainter_DrawRoundedRect2(void* ptr, int x, int y, int w, int h, double xRadius, double yRadius, long long mode)
{
static_cast<QPainter*>(ptr)->drawRoundedRect(x, y, w, h, xRadius, yRadius, static_cast<Qt::SizeMode>(mode));
}
void QPainter_DrawStaticText2(void* ptr, void* topLeftPosition, void* staticText)
{
static_cast<QPainter*>(ptr)->drawStaticText(*static_cast<QPoint*>(topLeftPosition), *static_cast<QStaticText*>(staticText));
}
void QPainter_DrawStaticText(void* ptr, void* topLeftPosition, void* staticText)
{
static_cast<QPainter*>(ptr)->drawStaticText(*static_cast<QPointF*>(topLeftPosition), *static_cast<QStaticText*>(staticText));
}
void QPainter_DrawStaticText3(void* ptr, int left, int top, void* staticText)
{
static_cast<QPainter*>(ptr)->drawStaticText(left, top, *static_cast<QStaticText*>(staticText));
}
void QPainter_DrawText2(void* ptr, void* position, struct QtGui_PackedString text)
{
static_cast<QPainter*>(ptr)->drawText(*static_cast<QPoint*>(position), QString::fromUtf8(text.data, text.len));
}
void QPainter_DrawText(void* ptr, void* position, struct QtGui_PackedString text)
{
static_cast<QPainter*>(ptr)->drawText(*static_cast<QPointF*>(position), QString::fromUtf8(text.data, text.len));
}
void QPainter_DrawText6(void* ptr, void* rectangle, int flags, struct QtGui_PackedString text, void* boundingRect)
{
static_cast<QPainter*>(ptr)->drawText(*static_cast<QRect*>(rectangle), flags, QString::fromUtf8(text.data, text.len), static_cast<QRect*>(boundingRect));
}
void QPainter_DrawText8(void* ptr, void* rectangle, struct QtGui_PackedString text, void* option)
{
static_cast<QPainter*>(ptr)->drawText(*static_cast<QRectF*>(rectangle), QString::fromUtf8(text.data, text.len), *static_cast<QTextOption*>(option));
}
void QPainter_DrawText5(void* ptr, void* rectangle, int flags, struct QtGui_PackedString text, void* boundingRect)
{
static_cast<QPainter*>(ptr)->drawText(*static_cast<QRectF*>(rectangle), flags, QString::fromUtf8(text.data, text.len), static_cast<QRectF*>(boundingRect));
}
void QPainter_DrawText3(void* ptr, int x, int y, struct QtGui_PackedString text)
{
static_cast<QPainter*>(ptr)->drawText(x, y, QString::fromUtf8(text.data, text.len));
}
void QPainter_DrawText7(void* ptr, int x, int y, int width, int height, int flags, struct QtGui_PackedString text, void* boundingRect)
{
static_cast<QPainter*>(ptr)->drawText(x, y, width, height, flags, QString::fromUtf8(text.data, text.len), static_cast<QRect*>(boundingRect));
}
void QPainter_DrawTiledPixmap3(void* ptr, void* rectangle, void* pixmap, void* position)
{
static_cast<QPainter*>(ptr)->drawTiledPixmap(*static_cast<QRect*>(rectangle), *static_cast<QPixmap*>(pixmap), *static_cast<QPoint*>(position));
}
void QPainter_DrawTiledPixmap(void* ptr, void* rectangle, void* pixmap, void* position)
{
static_cast<QPainter*>(ptr)->drawTiledPixmap(*static_cast<QRectF*>(rectangle), *static_cast<QPixmap*>(pixmap), *static_cast<QPointF*>(position));
}
void QPainter_DrawTiledPixmap2(void* ptr, int x, int y, int width, int height, void* pixmap, int sx, int sy)
{
static_cast<QPainter*>(ptr)->drawTiledPixmap(x, y, width, height, *static_cast<QPixmap*>(pixmap), sx, sy);
}
void QPainter_EndNativePainting(void* ptr)
{
static_cast<QPainter*>(ptr)->endNativePainting();
}
void QPainter_EraseRect3(void* ptr, void* rectangle)
{
static_cast<QPainter*>(ptr)->eraseRect(*static_cast<QRect*>(rectangle));
}
void QPainter_EraseRect(void* ptr, void* rectangle)
{
static_cast<QPainter*>(ptr)->eraseRect(*static_cast<QRectF*>(rectangle));
}
void QPainter_EraseRect2(void* ptr, int x, int y, int width, int height)
{
static_cast<QPainter*>(ptr)->eraseRect(x, y, width, height);
}
void QPainter_FillPath(void* ptr, void* path, void* brush)
{
static_cast<QPainter*>(ptr)->fillPath(*static_cast<QPainterPath*>(path), *static_cast<QBrush*>(brush));
}
void QPainter_FillRect11(void* ptr, void* rectangle, long long style)
{
static_cast<QPainter*>(ptr)->fillRect(*static_cast<QRect*>(rectangle), static_cast<Qt::BrushStyle>(style));
}
void QPainter_FillRect8(void* ptr, void* rectangle, long long color)
{
static_cast<QPainter*>(ptr)->fillRect(*static_cast<QRect*>(rectangle), static_cast<Qt::GlobalColor>(color));
}
void QPainter_FillRect3(void* ptr, void* rectangle, void* brush)
{
static_cast<QPainter*>(ptr)->fillRect(*static_cast<QRect*>(rectangle), *static_cast<QBrush*>(brush));
}
void QPainter_FillRect6(void* ptr, void* rectangle, void* color)
{
static_cast<QPainter*>(ptr)->fillRect(*static_cast<QRect*>(rectangle), *static_cast<QColor*>(color));
}
void QPainter_FillRect12(void* ptr, void* rectangle, long long style)
{
static_cast<QPainter*>(ptr)->fillRect(*static_cast<QRectF*>(rectangle), static_cast<Qt::BrushStyle>(style));
}
void QPainter_FillRect9(void* ptr, void* rectangle, long long color)
{
static_cast<QPainter*>(ptr)->fillRect(*static_cast<QRectF*>(rectangle), static_cast<Qt::GlobalColor>(color));
}
void QPainter_FillRect(void* ptr, void* rectangle, void* brush)
{
static_cast<QPainter*>(ptr)->fillRect(*static_cast<QRectF*>(rectangle), *static_cast<QBrush*>(brush));
}
void QPainter_FillRect4(void* ptr, void* rectangle, void* color)
{
static_cast<QPainter*>(ptr)->fillRect(*static_cast<QRectF*>(rectangle), *static_cast<QColor*>(color));
}
void QPainter_FillRect10(void* ptr, int x, int y, int width, int height, long long style)
{
static_cast<QPainter*>(ptr)->fillRect(x, y, width, height, static_cast<Qt::BrushStyle>(style));
}
void QPainter_FillRect7(void* ptr, int x, int y, int width, int height, long long color)
{
static_cast<QPainter*>(ptr)->fillRect(x, y, width, height, static_cast<Qt::GlobalColor>(color));
}
void QPainter_FillRect2(void* ptr, int x, int y, int width, int height, void* brush)
{
static_cast<QPainter*>(ptr)->fillRect(x, y, width, height, *static_cast<QBrush*>(brush));
}
void QPainter_FillRect5(void* ptr, int x, int y, int width, int height, void* color)
{
static_cast<QPainter*>(ptr)->fillRect(x, y, width, height, *static_cast<QColor*>(color));
}
void QPainter_ResetTransform(void* ptr)
{
static_cast<QPainter*>(ptr)->resetTransform();
}
void QPainter_Restore(void* ptr)
{
static_cast<QPainter*>(ptr)->restore();
}
void QPainter_Rotate(void* ptr, double angle)
{
static_cast<QPainter*>(ptr)->rotate(angle);
}
void QPainter_Save(void* ptr)
{
static_cast<QPainter*>(ptr)->save();
}
void QPainter_Scale(void* ptr, double sx, double sy)
{
static_cast<QPainter*>(ptr)->scale(sx, sy);
}
void QPainter_SetBackground(void* ptr, void* brush)
{
static_cast<QPainter*>(ptr)->setBackground(*static_cast<QBrush*>(brush));
}
void QPainter_SetBackgroundMode(void* ptr, long long mode)
{
static_cast<QPainter*>(ptr)->setBackgroundMode(static_cast<Qt::BGMode>(mode));
}
void QPainter_SetBrush2(void* ptr, long long style)
{
static_cast<QPainter*>(ptr)->setBrush(static_cast<Qt::BrushStyle>(style));
}
void QPainter_SetBrush(void* ptr, void* brush)
{
static_cast<QPainter*>(ptr)->setBrush(*static_cast<QBrush*>(brush));
}
void QPainter_SetBrushOrigin2(void* ptr, void* position)
{
static_cast<QPainter*>(ptr)->setBrushOrigin(*static_cast<QPoint*>(position));
}
void QPainter_SetBrushOrigin(void* ptr, void* position)
{
static_cast<QPainter*>(ptr)->setBrushOrigin(*static_cast<QPointF*>(position));
}
void QPainter_SetBrushOrigin3(void* ptr, int x, int y)
{
static_cast<QPainter*>(ptr)->setBrushOrigin(x, y);
}
void QPainter_SetClipPath(void* ptr, void* path, long long operation)
{
static_cast<QPainter*>(ptr)->setClipPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ClipOperation>(operation));
}
void QPainter_SetClipRect2(void* ptr, void* rectangle, long long operation)
{
static_cast<QPainter*>(ptr)->setClipRect(*static_cast<QRect*>(rectangle), static_cast<Qt::ClipOperation>(operation));
}
void QPainter_SetClipRect(void* ptr, void* rectangle, long long operation)
{
static_cast<QPainter*>(ptr)->setClipRect(*static_cast<QRectF*>(rectangle), static_cast<Qt::ClipOperation>(operation));
}
void QPainter_SetClipRect3(void* ptr, int x, int y, int width, int height, long long operation)
{
static_cast<QPainter*>(ptr)->setClipRect(x, y, width, height, static_cast<Qt::ClipOperation>(operation));
}
void QPainter_SetClipRegion(void* ptr, void* region, long long operation)
{
static_cast<QPainter*>(ptr)->setClipRegion(*static_cast<QRegion*>(region), static_cast<Qt::ClipOperation>(operation));
}
void QPainter_SetClipping(void* ptr, char enable)
{
static_cast<QPainter*>(ptr)->setClipping(enable != 0);
}
void QPainter_SetCompositionMode(void* ptr, long long mode)
{
static_cast<QPainter*>(ptr)->setCompositionMode(static_cast<QPainter::CompositionMode>(mode));
}
void QPainter_SetFont(void* ptr, void* font)
{
static_cast<QPainter*>(ptr)->setFont(*static_cast<QFont*>(font));
}
void QPainter_SetLayoutDirection(void* ptr, long long direction)
{
static_cast<QPainter*>(ptr)->setLayoutDirection(static_cast<Qt::LayoutDirection>(direction));
}
void QPainter_SetOpacity(void* ptr, double opacity)
{
static_cast<QPainter*>(ptr)->setOpacity(opacity);
}
void QPainter_SetPen3(void* ptr, long long style)
{
static_cast<QPainter*>(ptr)->setPen(static_cast<Qt::PenStyle>(style));
}
void QPainter_SetPen2(void* ptr, void* color)
{
static_cast<QPainter*>(ptr)->setPen(*static_cast<QColor*>(color));
}
void QPainter_SetPen(void* ptr, void* pen)
{
static_cast<QPainter*>(ptr)->setPen(*static_cast<QPen*>(pen));
}
void QPainter_SetRenderHint(void* ptr, long long hint, char on)
{
static_cast<QPainter*>(ptr)->setRenderHint(static_cast<QPainter::RenderHint>(hint), on != 0);
}
void QPainter_SetRenderHints(void* ptr, long long hints, char on)
{
static_cast<QPainter*>(ptr)->setRenderHints(static_cast<QPainter::RenderHint>(hints), on != 0);
}
void QPainter_SetTransform(void* ptr, void* transform, char combine)
{
static_cast<QPainter*>(ptr)->setTransform(*static_cast<QTransform*>(transform), combine != 0);
}
void QPainter_SetViewTransformEnabled(void* ptr, char enable)
{
static_cast<QPainter*>(ptr)->setViewTransformEnabled(enable != 0);
}
void QPainter_SetViewport(void* ptr, void* rectangle)
{
static_cast<QPainter*>(ptr)->setViewport(*static_cast<QRect*>(rectangle));
}
void QPainter_SetViewport2(void* ptr, int x, int y, int width, int height)
{
static_cast<QPainter*>(ptr)->setViewport(x, y, width, height);
}
void QPainter_SetWindow(void* ptr, void* rectangle)
{
static_cast<QPainter*>(ptr)->setWindow(*static_cast<QRect*>(rectangle));
}
void QPainter_SetWindow2(void* ptr, int x, int y, int width, int height)
{
static_cast<QPainter*>(ptr)->setWindow(x, y, width, height);
}
void QPainter_SetWorldMatrixEnabled(void* ptr, char enable)
{
static_cast<QPainter*>(ptr)->setWorldMatrixEnabled(enable != 0);
}
void QPainter_SetWorldTransform(void* ptr, void* matrix, char combine)
{
static_cast<QPainter*>(ptr)->setWorldTransform(*static_cast<QTransform*>(matrix), combine != 0);
}
void QPainter_Shear(void* ptr, double sh, double sv)
{
static_cast<QPainter*>(ptr)->shear(sh, sv);
}
void QPainter_StrokePath(void* ptr, void* path, void* pen)
{
static_cast<QPainter*>(ptr)->strokePath(*static_cast<QPainterPath*>(path), *static_cast<QPen*>(pen));
}
void QPainter_Translate2(void* ptr, void* offset)
{
static_cast<QPainter*>(ptr)->translate(*static_cast<QPoint*>(offset));
}
void QPainter_Translate(void* ptr, void* offset)
{
static_cast<QPainter*>(ptr)->translate(*static_cast<QPointF*>(offset));
}
void QPainter_Translate3(void* ptr, double dx, double dy)
{
static_cast<QPainter*>(ptr)->translate(dx, dy);
}
void QPainter_DestroyQPainter(void* ptr)
{
static_cast<QPainter*>(ptr)->~QPainter();
}
void* QPainter_FontInfo(void* ptr)
{
return new QFontInfo(static_cast<QPainter*>(ptr)->fontInfo());
}
void* QPainter_FontMetrics(void* ptr)
{
return new QFontMetrics(static_cast<QPainter*>(ptr)->fontMetrics());
}
void* QPainter_Device(void* ptr)
{
return static_cast<QPainter*>(ptr)->device();
}
void* QPainter_PaintEngine(void* ptr)
{
return static_cast<QPainter*>(ptr)->paintEngine();
}
long long QPainter_CompositionMode(void* ptr)
{
return static_cast<QPainter*>(ptr)->compositionMode();
}
long long QPainter_RenderHints(void* ptr)
{
return static_cast<QPainter*>(ptr)->renderHints();
}
void* QPainter_ClipPath(void* ptr)
{
return new QPainterPath(static_cast<QPainter*>(ptr)->clipPath());
}
void* QPainter_BrushOrigin(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QPainter*>(ptr)->brushOrigin(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QPainter_Viewport(void* ptr)
{
return ({ QRect tmpValue = static_cast<QPainter*>(ptr)->viewport(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QPainter_Window(void* ptr)
{
return ({ QRect tmpValue = static_cast<QPainter*>(ptr)->window(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QPainter_ClipBoundingRect(void* ptr)
{
return ({ QRectF tmpValue = static_cast<QPainter*>(ptr)->clipBoundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QPainter_ClipRegion(void* ptr)
{
return new QRegion(static_cast<QPainter*>(ptr)->clipRegion());
}
void* QPainter_CombinedTransform(void* ptr)
{
return new QTransform(static_cast<QPainter*>(ptr)->combinedTransform());
}
long long QPainter_BackgroundMode(void* ptr)
{
return static_cast<QPainter*>(ptr)->backgroundMode();
}
long long QPainter_LayoutDirection(void* ptr)
{
return static_cast<QPainter*>(ptr)->layoutDirection();
}
char QPainter_HasClipping(void* ptr)
{
return static_cast<QPainter*>(ptr)->hasClipping();
}
char QPainter_IsActive(void* ptr)
{
return static_cast<QPainter*>(ptr)->isActive();
}
char QPainter_TestRenderHint(void* ptr, long long hint)
{
return static_cast<QPainter*>(ptr)->testRenderHint(static_cast<QPainter::RenderHint>(hint));
}
char QPainter_ViewTransformEnabled(void* ptr)
{
return static_cast<QPainter*>(ptr)->viewTransformEnabled();
}
char QPainter_WorldMatrixEnabled(void* ptr)
{
return static_cast<QPainter*>(ptr)->worldMatrixEnabled();
}
void* QPainter_Background(void* ptr)
{
return const_cast<QBrush*>(&static_cast<QPainter*>(ptr)->background());
}
void* QPainter_Brush(void* ptr)
{
return const_cast<QBrush*>(&static_cast<QPainter*>(ptr)->brush());
}
void* QPainter_Font(void* ptr)
{
return const_cast<QFont*>(&static_cast<QPainter*>(ptr)->font());
}
void* QPainter_Pen(void* ptr)
{
return const_cast<QPen*>(&static_cast<QPainter*>(ptr)->pen());
}
void* QPainter_DeviceTransform(void* ptr)
{
return const_cast<QTransform*>(&static_cast<QPainter*>(ptr)->deviceTransform());
}
void* QPainter_Transform(void* ptr)
{
return const_cast<QTransform*>(&static_cast<QPainter*>(ptr)->transform());
}
void* QPainter_WorldTransform(void* ptr)
{
return const_cast<QTransform*>(&static_cast<QPainter*>(ptr)->worldTransform());
}
double QPainter_Opacity(void* ptr)
{
return static_cast<QPainter*>(ptr)->opacity();
}
void* QPainter___drawLines_lines_atList6(void* ptr, int i)
{
return ({ QLine tmpValue = ({QLine tmp = static_cast<QVector<QLine>*>(ptr)->at(i); if (i == static_cast<QVector<QLine>*>(ptr)->size()-1) { static_cast<QVector<QLine>*>(ptr)->~QVector(); free(ptr); }; tmp; }); new QLine(tmpValue.p1(), tmpValue.p2()); });
}
void QPainter___drawLines_lines_setList6(void* ptr, void* i)
{
static_cast<QVector<QLine>*>(ptr)->append(*static_cast<QLine*>(i));
}
void* QPainter___drawLines_lines_newList6(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QLine>();
}
void* QPainter___drawLines_lines_atList2(void* ptr, int i)
{
return ({ QLineF tmpValue = ({QLineF tmp = static_cast<QVector<QLineF>*>(ptr)->at(i); if (i == static_cast<QVector<QLineF>*>(ptr)->size()-1) { static_cast<QVector<QLineF>*>(ptr)->~QVector(); free(ptr); }; tmp; }); new QLineF(tmpValue.p1(), tmpValue.p2()); });
}
void QPainter___drawLines_lines_setList2(void* ptr, void* i)
{
static_cast<QVector<QLineF>*>(ptr)->append(*static_cast<QLineF*>(i));
}
void* QPainter___drawLines_lines_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QLineF>();
}
void* QPainter___drawLines_pointPairs_atList8(void* ptr, int i)
{
return ({ QPoint tmpValue = ({QPoint tmp = static_cast<QVector<QPoint>*>(ptr)->at(i); if (i == static_cast<QVector<QPoint>*>(ptr)->size()-1) { static_cast<QVector<QPoint>*>(ptr)->~QVector(); free(ptr); }; tmp; }); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void QPainter___drawLines_pointPairs_setList8(void* ptr, void* i)
{
static_cast<QVector<QPoint>*>(ptr)->append(*static_cast<QPoint*>(i));
}
void* QPainter___drawLines_pointPairs_newList8(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QPoint>();
}
void* QPainter___drawLines_pointPairs_atList4(void* ptr, int i)
{
return ({ QPointF tmpValue = ({QPointF tmp = static_cast<QVector<QPointF>*>(ptr)->at(i); if (i == static_cast<QVector<QPointF>*>(ptr)->size()-1) { static_cast<QVector<QPointF>*>(ptr)->~QVector(); free(ptr); }; tmp; }); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QPainter___drawLines_pointPairs_setList4(void* ptr, void* i)
{
static_cast<QVector<QPointF>*>(ptr)->append(*static_cast<QPointF*>(i));
}
void* QPainter___drawLines_pointPairs_newList4(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QPointF>();
}
void* QPainter___drawRects_rectangles_atList4(void* ptr, int i)
{
return ({ QRect tmpValue = ({QRect tmp = static_cast<QVector<QRect>*>(ptr)->at(i); if (i == static_cast<QVector<QRect>*>(ptr)->size()-1) { static_cast<QVector<QRect>*>(ptr)->~QVector(); free(ptr); }; tmp; }); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void QPainter___drawRects_rectangles_setList4(void* ptr, void* i)
{
static_cast<QVector<QRect>*>(ptr)->append(*static_cast<QRect*>(i));
}
void* QPainter___drawRects_rectangles_newList4(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QRect>();
}
void* QPainter___drawRects_rectangles_atList2(void* ptr, int i)
{
return ({ QRectF tmpValue = ({QRectF tmp = static_cast<QVector<QRectF>*>(ptr)->at(i); if (i == static_cast<QVector<QRectF>*>(ptr)->size()-1) { static_cast<QVector<QRectF>*>(ptr)->~QVector(); free(ptr); }; tmp; }); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void QPainter___drawRects_rectangles_setList2(void* ptr, void* i)
{
static_cast<QVector<QRectF>*>(ptr)->append(*static_cast<QRectF*>(i));
}
void* QPainter___drawRects_rectangles_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QRectF>();
}
void* QPainterPath_NewQPainterPath()
{
return new QPainterPath();
}
void* QPainterPath_NewQPainterPath3(void* path)
{
return new QPainterPath(*static_cast<QPainterPath*>(path));
}
void* QPainterPath_NewQPainterPath2(void* startPoint)
{
return new QPainterPath(*static_cast<QPointF*>(startPoint));
}
void QPainterPath_AddEllipse3(void* ptr, void* center, double rx, double ry)
{
static_cast<QPainterPath*>(ptr)->addEllipse(*static_cast<QPointF*>(center), rx, ry);
}
void QPainterPath_AddEllipse(void* ptr, void* boundingRectangle)
{
static_cast<QPainterPath*>(ptr)->addEllipse(*static_cast<QRectF*>(boundingRectangle));
}
void QPainterPath_AddEllipse2(void* ptr, double x, double y, double width, double height)
{
static_cast<QPainterPath*>(ptr)->addEllipse(x, y, width, height);
}
void QPainterPath_AddPath(void* ptr, void* path)
{
static_cast<QPainterPath*>(ptr)->addPath(*static_cast<QPainterPath*>(path));
}
void QPainterPath_AddPolygon(void* ptr, void* polygon)
{
static_cast<QPainterPath*>(ptr)->addPolygon(*static_cast<QPolygonF*>(polygon));
}
void QPainterPath_AddRect(void* ptr, void* rectangle)
{
static_cast<QPainterPath*>(ptr)->addRect(*static_cast<QRectF*>(rectangle));
}
void QPainterPath_AddRect2(void* ptr, double x, double y, double width, double height)
{
static_cast<QPainterPath*>(ptr)->addRect(x, y, width, height);
}
void QPainterPath_AddRegion(void* ptr, void* region)
{
static_cast<QPainterPath*>(ptr)->addRegion(*static_cast<QRegion*>(region));
}
void QPainterPath_AddRoundedRect(void* ptr, void* rect, double xRadius, double yRadius, long long mode)
{
static_cast<QPainterPath*>(ptr)->addRoundedRect(*static_cast<QRectF*>(rect), xRadius, yRadius, static_cast<Qt::SizeMode>(mode));
}
void QPainterPath_AddRoundedRect2(void* ptr, double x, double y, double w, double h, double xRadius, double yRadius, long long mode)
{
static_cast<QPainterPath*>(ptr)->addRoundedRect(x, y, w, h, xRadius, yRadius, static_cast<Qt::SizeMode>(mode));
}
void QPainterPath_AddText(void* ptr, void* point, void* font, struct QtGui_PackedString text)
{
static_cast<QPainterPath*>(ptr)->addText(*static_cast<QPointF*>(point), *static_cast<QFont*>(font), QString::fromUtf8(text.data, text.len));
}
void QPainterPath_AddText2(void* ptr, double x, double y, void* font, struct QtGui_PackedString text)
{
static_cast<QPainterPath*>(ptr)->addText(x, y, *static_cast<QFont*>(font), QString::fromUtf8(text.data, text.len));
}
void QPainterPath_ArcMoveTo(void* ptr, void* rectangle, double angle)
{
static_cast<QPainterPath*>(ptr)->arcMoveTo(*static_cast<QRectF*>(rectangle), angle);
}
void QPainterPath_ArcMoveTo2(void* ptr, double x, double y, double width, double height, double angle)
{
static_cast<QPainterPath*>(ptr)->arcMoveTo(x, y, width, height, angle);
}
void QPainterPath_ArcTo(void* ptr, void* rectangle, double startAngle, double sweepLength)
{
static_cast<QPainterPath*>(ptr)->arcTo(*static_cast<QRectF*>(rectangle), startAngle, sweepLength);
}
void QPainterPath_ArcTo2(void* ptr, double x, double y, double width, double height, double startAngle, double sweepLength)
{
static_cast<QPainterPath*>(ptr)->arcTo(x, y, width, height, startAngle, sweepLength);
}
void QPainterPath_CloseSubpath(void* ptr)
{
static_cast<QPainterPath*>(ptr)->closeSubpath();
}
void QPainterPath_ConnectPath(void* ptr, void* path)
{
static_cast<QPainterPath*>(ptr)->connectPath(*static_cast<QPainterPath*>(path));
}
void QPainterPath_CubicTo(void* ptr, void* c1, void* c2, void* endPoint)
{
static_cast<QPainterPath*>(ptr)->cubicTo(*static_cast<QPointF*>(c1), *static_cast<QPointF*>(c2), *static_cast<QPointF*>(endPoint));
}
void QPainterPath_CubicTo2(void* ptr, double c1X, double c1Y, double c2X, double c2Y, double endPointX, double endPointY)
{
static_cast<QPainterPath*>(ptr)->cubicTo(c1X, c1Y, c2X, c2Y, endPointX, endPointY);
}
void QPainterPath_LineTo(void* ptr, void* endPoint)
{
static_cast<QPainterPath*>(ptr)->lineTo(*static_cast<QPointF*>(endPoint));
}
void QPainterPath_LineTo2(void* ptr, double x, double y)
{
static_cast<QPainterPath*>(ptr)->lineTo(x, y);
}
void QPainterPath_MoveTo(void* ptr, void* point)
{
static_cast<QPainterPath*>(ptr)->moveTo(*static_cast<QPointF*>(point));
}
void QPainterPath_MoveTo2(void* ptr, double x, double y)
{
static_cast<QPainterPath*>(ptr)->moveTo(x, y);
}
void QPainterPath_QuadTo(void* ptr, void* c, void* endPoint)
{
static_cast<QPainterPath*>(ptr)->quadTo(*static_cast<QPointF*>(c), *static_cast<QPointF*>(endPoint));
}
void QPainterPath_QuadTo2(void* ptr, double cx, double cy, double endPointX, double endPointY)
{
static_cast<QPainterPath*>(ptr)->quadTo(cx, cy, endPointX, endPointY);
}
void QPainterPath_SetElementPositionAt(void* ptr, int index, double x, double y)
{
static_cast<QPainterPath*>(ptr)->setElementPositionAt(index, x, y);
}
void QPainterPath_SetFillRule(void* ptr, long long fillRule)
{
static_cast<QPainterPath*>(ptr)->setFillRule(static_cast<Qt::FillRule>(fillRule));
}
void QPainterPath_Swap(void* ptr, void* other)
{
static_cast<QPainterPath*>(ptr)->swap(*static_cast<QPainterPath*>(other));
}
void QPainterPath_Translate2(void* ptr, void* offset)
{
static_cast<QPainterPath*>(ptr)->translate(*static_cast<QPointF*>(offset));
}
void QPainterPath_Translate(void* ptr, double dx, double dy)
{
static_cast<QPainterPath*>(ptr)->translate(dx, dy);
}
void QPainterPath_DestroyQPainterPath(void* ptr)
{
static_cast<QPainterPath*>(ptr)->~QPainterPath();
}
struct QtGui_PackedList QPainterPath_ToFillPolygons2(void* ptr, void* matrix)
{
return ({ QList<QPolygonF>* tmpValue = new QList<QPolygonF>(static_cast<QPainterPath*>(ptr)->toFillPolygons(*static_cast<QMatrix*>(matrix))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedList QPainterPath_ToFillPolygons(void* ptr, void* matrix)
{
return ({ QList<QPolygonF>* tmpValue = new QList<QPolygonF>(static_cast<QPainterPath*>(ptr)->toFillPolygons(*static_cast<QTransform*>(matrix))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedList QPainterPath_ToSubpathPolygons2(void* ptr, void* matrix)
{
return ({ QList<QPolygonF>* tmpValue = new QList<QPolygonF>(static_cast<QPainterPath*>(ptr)->toSubpathPolygons(*static_cast<QMatrix*>(matrix))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedList QPainterPath_ToSubpathPolygons(void* ptr, void* matrix)
{
return ({ QList<QPolygonF>* tmpValue = new QList<QPolygonF>(static_cast<QPainterPath*>(ptr)->toSubpathPolygons(*static_cast<QTransform*>(matrix))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QPainterPath_Intersected(void* ptr, void* p)
{
return new QPainterPath(static_cast<QPainterPath*>(ptr)->intersected(*static_cast<QPainterPath*>(p)));
}
void* QPainterPath_Simplified(void* ptr)
{
return new QPainterPath(static_cast<QPainterPath*>(ptr)->simplified());
}
void* QPainterPath_Subtracted(void* ptr, void* p)
{
return new QPainterPath(static_cast<QPainterPath*>(ptr)->subtracted(*static_cast<QPainterPath*>(p)));
}
void* QPainterPath_ToReversed(void* ptr)
{
return new QPainterPath(static_cast<QPainterPath*>(ptr)->toReversed());
}
void* QPainterPath_Translated2(void* ptr, void* offset)
{
return new QPainterPath(static_cast<QPainterPath*>(ptr)->translated(*static_cast<QPointF*>(offset)));
}
void* QPainterPath_Translated(void* ptr, double dx, double dy)
{
return new QPainterPath(static_cast<QPainterPath*>(ptr)->translated(dx, dy));
}
void* QPainterPath_United(void* ptr, void* p)
{
return new QPainterPath(static_cast<QPainterPath*>(ptr)->united(*static_cast<QPainterPath*>(p)));
}
void* QPainterPath_CurrentPosition(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QPainterPath*>(ptr)->currentPosition(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void* QPainterPath_PointAtPercent(void* ptr, double t)
{
return ({ QPointF tmpValue = static_cast<QPainterPath*>(ptr)->pointAtPercent(t); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void* QPainterPath_ToFillPolygon2(void* ptr, void* matrix)
{
return new QPolygonF(static_cast<QPainterPath*>(ptr)->toFillPolygon(*static_cast<QMatrix*>(matrix)));
}
void* QPainterPath_ToFillPolygon(void* ptr, void* matrix)
{
return new QPolygonF(static_cast<QPainterPath*>(ptr)->toFillPolygon(*static_cast<QTransform*>(matrix)));
}
void* QPainterPath_BoundingRect(void* ptr)
{
return ({ QRectF tmpValue = static_cast<QPainterPath*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QPainterPath_ControlPointRect(void* ptr)
{
return ({ QRectF tmpValue = static_cast<QPainterPath*>(ptr)->controlPointRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
long long QPainterPath_FillRule(void* ptr)
{
return static_cast<QPainterPath*>(ptr)->fillRule();
}
char QPainterPath_Contains3(void* ptr, void* p)
{
return static_cast<QPainterPath*>(ptr)->contains(*static_cast<QPainterPath*>(p));
}
char QPainterPath_Contains(void* ptr, void* point)
{
return static_cast<QPainterPath*>(ptr)->contains(*static_cast<QPointF*>(point));
}
char QPainterPath_Contains2(void* ptr, void* rectangle)
{
return static_cast<QPainterPath*>(ptr)->contains(*static_cast<QRectF*>(rectangle));
}
char QPainterPath_Intersects2(void* ptr, void* p)
{
return static_cast<QPainterPath*>(ptr)->intersects(*static_cast<QPainterPath*>(p));
}
char QPainterPath_Intersects(void* ptr, void* rectangle)
{
return static_cast<QPainterPath*>(ptr)->intersects(*static_cast<QRectF*>(rectangle));
}
char QPainterPath_IsEmpty(void* ptr)
{
return static_cast<QPainterPath*>(ptr)->isEmpty();
}
int QPainterPath_ElementCount(void* ptr)
{
return static_cast<QPainterPath*>(ptr)->elementCount();
}
double QPainterPath_AngleAtPercent(void* ptr, double t)
{
return static_cast<QPainterPath*>(ptr)->angleAtPercent(t);
}
double QPainterPath_Length(void* ptr)
{
return static_cast<QPainterPath*>(ptr)->length();
}
double QPainterPath_PercentAtLength(void* ptr, double l)
{
return static_cast<QPainterPath*>(ptr)->percentAtLength(l);
}
double QPainterPath_SlopeAtPercent(void* ptr, double t)
{
return static_cast<QPainterPath*>(ptr)->slopeAtPercent(t);
}
void* QPainterPath___toFillPolygons_atList2(void* ptr, int i)
{
return new QPolygonF(({QPolygonF tmp = static_cast<QList<QPolygonF>*>(ptr)->at(i); if (i == static_cast<QList<QPolygonF>*>(ptr)->size()-1) { static_cast<QList<QPolygonF>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QPainterPath___toFillPolygons_setList2(void* ptr, void* i)
{
static_cast<QList<QPolygonF>*>(ptr)->append(*static_cast<QPolygonF*>(i));
}
void* QPainterPath___toFillPolygons_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QPolygonF>();
}
void* QPainterPath___toFillPolygons_atList(void* ptr, int i)
{
return new QPolygonF(({QPolygonF tmp = static_cast<QList<QPolygonF>*>(ptr)->at(i); if (i == static_cast<QList<QPolygonF>*>(ptr)->size()-1) { static_cast<QList<QPolygonF>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QPainterPath___toFillPolygons_setList(void* ptr, void* i)
{
static_cast<QList<QPolygonF>*>(ptr)->append(*static_cast<QPolygonF*>(i));
}
void* QPainterPath___toFillPolygons_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QPolygonF>();
}
void* QPainterPath___toSubpathPolygons_atList2(void* ptr, int i)
{
return new QPolygonF(({QPolygonF tmp = static_cast<QList<QPolygonF>*>(ptr)->at(i); if (i == static_cast<QList<QPolygonF>*>(ptr)->size()-1) { static_cast<QList<QPolygonF>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QPainterPath___toSubpathPolygons_setList2(void* ptr, void* i)
{
static_cast<QList<QPolygonF>*>(ptr)->append(*static_cast<QPolygonF*>(i));
}
void* QPainterPath___toSubpathPolygons_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QPolygonF>();
}
void* QPainterPath___toSubpathPolygons_atList(void* ptr, int i)
{
return new QPolygonF(({QPolygonF tmp = static_cast<QList<QPolygonF>*>(ptr)->at(i); if (i == static_cast<QList<QPolygonF>*>(ptr)->size()-1) { static_cast<QList<QPolygonF>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QPainterPath___toSubpathPolygons_setList(void* ptr, void* i)
{
static_cast<QList<QPolygonF>*>(ptr)->append(*static_cast<QPolygonF*>(i));
}
void* QPainterPath___toSubpathPolygons_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QPolygonF>();
}
void* QPainterPathStroker_NewQPainterPathStroker()
{
return new QPainterPathStroker();
}
void* QPainterPathStroker_NewQPainterPathStroker2(void* pen)
{
return new QPainterPathStroker(*static_cast<QPen*>(pen));
}
void QPainterPathStroker_SetCapStyle(void* ptr, long long style)
{
static_cast<QPainterPathStroker*>(ptr)->setCapStyle(static_cast<Qt::PenCapStyle>(style));
}
void QPainterPathStroker_SetCurveThreshold(void* ptr, double threshold)
{
static_cast<QPainterPathStroker*>(ptr)->setCurveThreshold(threshold);
}
void QPainterPathStroker_SetDashOffset(void* ptr, double offset)
{
static_cast<QPainterPathStroker*>(ptr)->setDashOffset(offset);
}
void QPainterPathStroker_SetDashPattern(void* ptr, long long style)
{
static_cast<QPainterPathStroker*>(ptr)->setDashPattern(static_cast<Qt::PenStyle>(style));
}
void QPainterPathStroker_SetDashPattern2(void* ptr, void* dashPattern)
{
static_cast<QPainterPathStroker*>(ptr)->setDashPattern(*static_cast<QVector<qreal>*>(dashPattern));
}
void QPainterPathStroker_SetJoinStyle(void* ptr, long long style)
{
static_cast<QPainterPathStroker*>(ptr)->setJoinStyle(static_cast<Qt::PenJoinStyle>(style));
}
void QPainterPathStroker_SetMiterLimit(void* ptr, double limit)
{
static_cast<QPainterPathStroker*>(ptr)->setMiterLimit(limit);
}
void QPainterPathStroker_SetWidth(void* ptr, double width)
{
static_cast<QPainterPathStroker*>(ptr)->setWidth(width);
}
void QPainterPathStroker_DestroyQPainterPathStroker(void* ptr)
{
static_cast<QPainterPathStroker*>(ptr)->~QPainterPathStroker();
}
void* QPainterPathStroker_CreateStroke(void* ptr, void* path)
{
return new QPainterPath(static_cast<QPainterPathStroker*>(ptr)->createStroke(*static_cast<QPainterPath*>(path)));
}
struct QtGui_PackedList QPainterPathStroker_DashPattern(void* ptr)
{
return ({ QVector<qreal>* tmpValue = new QVector<qreal>(static_cast<QPainterPathStroker*>(ptr)->dashPattern()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
long long QPainterPathStroker_CapStyle(void* ptr)
{
return static_cast<QPainterPathStroker*>(ptr)->capStyle();
}
long long QPainterPathStroker_JoinStyle(void* ptr)
{
return static_cast<QPainterPathStroker*>(ptr)->joinStyle();
}
double QPainterPathStroker_CurveThreshold(void* ptr)
{
return static_cast<QPainterPathStroker*>(ptr)->curveThreshold();
}
double QPainterPathStroker_DashOffset(void* ptr)
{
return static_cast<QPainterPathStroker*>(ptr)->dashOffset();
}
double QPainterPathStroker_MiterLimit(void* ptr)
{
return static_cast<QPainterPathStroker*>(ptr)->miterLimit();
}
double QPainterPathStroker_Width(void* ptr)
{
return static_cast<QPainterPathStroker*>(ptr)->width();
}
double QPainterPathStroker___setDashPattern_dashPattern_atList2(void* ptr, int i)
{
return ({qreal tmp = static_cast<QVector<qreal>*>(ptr)->at(i); if (i == static_cast<QVector<qreal>*>(ptr)->size()-1) { static_cast<QVector<qreal>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QPainterPathStroker___setDashPattern_dashPattern_setList2(void* ptr, double i)
{
static_cast<QVector<qreal>*>(ptr)->append(i);
}
void* QPainterPathStroker___setDashPattern_dashPattern_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<qreal>();
}
double QPainterPathStroker___dashPattern_atList(void* ptr, int i)
{
return ({qreal tmp = static_cast<QVector<qreal>*>(ptr)->at(i); if (i == static_cast<QVector<qreal>*>(ptr)->size()-1) { static_cast<QVector<qreal>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QPainterPathStroker___dashPattern_setList(void* ptr, double i)
{
static_cast<QVector<qreal>*>(ptr)->append(i);
}
void* QPainterPathStroker___dashPattern_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<qreal>();
}
int QPalette_NColorRoles_Type()
{
return QPalette::NColorRoles;
}
void* QPalette_NewQPalette()
{
return new QPalette();
}
void* QPalette_NewQPalette8(void* other)
{
return new QPalette(*static_cast<QPalette*>(other));
}
void* QPalette_NewQPalette3(long long button)
{
return new QPalette(static_cast<Qt::GlobalColor>(button));
}
void* QPalette_NewQPalette5(void* windowText, void* button, void* light, void* dark, void* mid, void* text, void* bright_text, void* base, void* window)
{
return new QPalette(*static_cast<QBrush*>(windowText), *static_cast<QBrush*>(button), *static_cast<QBrush*>(light), *static_cast<QBrush*>(dark), *static_cast<QBrush*>(mid), *static_cast<QBrush*>(text), *static_cast<QBrush*>(bright_text), *static_cast<QBrush*>(base), *static_cast<QBrush*>(window));
}
void* QPalette_NewQPalette2(void* button)
{
return new QPalette(*static_cast<QColor*>(button));
}
void* QPalette_NewQPalette4(void* button, void* window)
{
return new QPalette(*static_cast<QColor*>(button), *static_cast<QColor*>(window));
}
void* QPalette_NewQPalette7(void* p)
{
return new QPalette(*static_cast<QPalette*>(p));
}
void QPalette_SetBrush2(void* ptr, long long group, long long role, void* brush)
{
static_cast<QPalette*>(ptr)->setBrush(static_cast<QPalette::ColorGroup>(group), static_cast<QPalette::ColorRole>(role), *static_cast<QBrush*>(brush));
}
void QPalette_SetBrush(void* ptr, long long role, void* brush)
{
static_cast<QPalette*>(ptr)->setBrush(static_cast<QPalette::ColorRole>(role), *static_cast<QBrush*>(brush));
}
void QPalette_SetColor(void* ptr, long long group, long long role, void* color)
{
static_cast<QPalette*>(ptr)->setColor(static_cast<QPalette::ColorGroup>(group), static_cast<QPalette::ColorRole>(role), *static_cast<QColor*>(color));
}
void QPalette_SetColor2(void* ptr, long long role, void* color)
{
static_cast<QPalette*>(ptr)->setColor(static_cast<QPalette::ColorRole>(role), *static_cast<QColor*>(color));
}
void QPalette_SetColorGroup(void* ptr, long long cg, void* windowText, void* button, void* light, void* dark, void* mid, void* text, void* bright_text, void* base, void* window)
{
static_cast<QPalette*>(ptr)->setColorGroup(static_cast<QPalette::ColorGroup>(cg), *static_cast<QBrush*>(windowText), *static_cast<QBrush*>(button), *static_cast<QBrush*>(light), *static_cast<QBrush*>(dark), *static_cast<QBrush*>(mid), *static_cast<QBrush*>(text), *static_cast<QBrush*>(bright_text), *static_cast<QBrush*>(base), *static_cast<QBrush*>(window));
}
void QPalette_SetCurrentColorGroup(void* ptr, long long cg)
{
static_cast<QPalette*>(ptr)->setCurrentColorGroup(static_cast<QPalette::ColorGroup>(cg));
}
void QPalette_Swap(void* ptr, void* other)
{
static_cast<QPalette*>(ptr)->swap(*static_cast<QPalette*>(other));
}
void QPalette_DestroyQPalette(void* ptr)
{
static_cast<QPalette*>(ptr)->~QPalette();
}
void* QPalette_Resolve(void* ptr, void* other)
{
return new QPalette(static_cast<QPalette*>(ptr)->resolve(*static_cast<QPalette*>(other)));
}
long long QPalette_CurrentColorGroup(void* ptr)
{
return static_cast<QPalette*>(ptr)->currentColorGroup();
}
char QPalette_IsBrushSet(void* ptr, long long cg, long long cr)
{
return static_cast<QPalette*>(ptr)->isBrushSet(static_cast<QPalette::ColorGroup>(cg), static_cast<QPalette::ColorRole>(cr));
}
char QPalette_IsCopyOf(void* ptr, void* p)
{
return static_cast<QPalette*>(ptr)->isCopyOf(*static_cast<QPalette*>(p));
}
char QPalette_IsEqual(void* ptr, long long cg1, long long cg2)
{
return static_cast<QPalette*>(ptr)->isEqual(static_cast<QPalette::ColorGroup>(cg1), static_cast<QPalette::ColorGroup>(cg2));
}
void* QPalette_AlternateBase(void* ptr)
{
return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->alternateBase());
}
void* QPalette_Base(void* ptr)
{
return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->base());
}
void* QPalette_BrightText(void* ptr)
{
return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->brightText());
}
void* QPalette_Brush(void* ptr, long long group, long long role)
{
return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->brush(static_cast<QPalette::ColorGroup>(group), static_cast<QPalette::ColorRole>(role)));
}
void* QPalette_Brush2(void* ptr, long long role)
{
return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->brush(static_cast<QPalette::ColorRole>(role)));
}
void* QPalette_Button(void* ptr)
{
return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->button());
}
void* QPalette_ButtonText(void* ptr)
{
return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->buttonText());
}
void* QPalette_Dark(void* ptr)
{
return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->dark());
}
void* QPalette_Highlight(void* ptr)
{
return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->highlight());
}
void* QPalette_HighlightedText(void* ptr)
{
return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->highlightedText());
}
void* QPalette_Light(void* ptr)
{
return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->light());
}
void* QPalette_Link(void* ptr)
{
return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->link());
}
void* QPalette_LinkVisited(void* ptr)
{
return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->linkVisited());
}
void* QPalette_Mid(void* ptr)
{
return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->mid());
}
void* QPalette_Midlight(void* ptr)
{
return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->midlight());
}
void* QPalette_Shadow(void* ptr)
{
return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->shadow());
}
void* QPalette_Text(void* ptr)
{
return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->text());
}
void* QPalette_ToolTipBase(void* ptr)
{
return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->toolTipBase());
}
void* QPalette_ToolTipText(void* ptr)
{
return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->toolTipText());
}
void* QPalette_Window(void* ptr)
{
return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->window());
}
void* QPalette_WindowText(void* ptr)
{
return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->windowText());
}
void* QPalette_Color(void* ptr, long long group, long long role)
{
return const_cast<QColor*>(&static_cast<QPalette*>(ptr)->color(static_cast<QPalette::ColorGroup>(group), static_cast<QPalette::ColorRole>(role)));
}
void* QPalette_Color2(void* ptr, long long role)
{
return const_cast<QColor*>(&static_cast<QPalette*>(ptr)->color(static_cast<QPalette::ColorRole>(role)));
}
long long QPalette_CacheKey(void* ptr)
{
return static_cast<QPalette*>(ptr)->cacheKey();
}
class MyQPdfWriter: public QPdfWriter
{
public:
MyQPdfWriter(QIODevice *device) : QPdfWriter(device) {QPdfWriter_QPdfWriter_QRegisterMetaType();};
MyQPdfWriter(const QString &filename) : QPdfWriter(filename) {QPdfWriter_QPdfWriter_QRegisterMetaType();};
bool newPage() { return callbackQPdfWriter_NewPage(this) != 0; };
~MyQPdfWriter() { callbackQPdfWriter_DestroyQPdfWriter(this); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQPdfWriter_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQPdfWriter_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQPdfWriter_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQPdfWriter_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQPdfWriter_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQPdfWriter_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQPdfWriter_CustomEvent(this, event); };
void deleteLater() { callbackQPdfWriter_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQPdfWriter_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQPdfWriter_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQPdfWriter_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQPdfWriter_TimerEvent(this, event); };
void setPageSize(QPagedPaintDevice::PageSize size) { callbackQPagedPaintDevice_SetPageSize2(this, size); };
void setPageSizeMM(const QSizeF & size) { callbackQPagedPaintDevice_SetPageSizeMM(this, const_cast<QSizeF*>(&size)); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPaintDevice_Metric(const_cast<void*>(static_cast<const void*>(this)), metric); };
};
Q_DECLARE_METATYPE(MyQPdfWriter*)
int QPdfWriter_QPdfWriter_QRegisterMetaType(){qRegisterMetaType<QPdfWriter*>(); return qRegisterMetaType<MyQPdfWriter*>();}
void* QPdfWriter_NewQPdfWriter2(void* device)
{
return new MyQPdfWriter(static_cast<QIODevice*>(device));
}
void* QPdfWriter_NewQPdfWriter(struct QtGui_PackedString filename)
{
return new MyQPdfWriter(QString::fromUtf8(filename.data, filename.len));
}
struct QtGui_PackedString QPdfWriter_QPdfWriter_Tr(char* s, char* c, int n)
{
return ({ QByteArray tc3b60c = QPdfWriter::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(tc3b60c.prepend("WHITESPACE").constData()+10), tc3b60c.size()-10 }; });
}
struct QtGui_PackedString QPdfWriter_QPdfWriter_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray t3ab033 = QPdfWriter::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t3ab033.prepend("WHITESPACE").constData()+10), t3ab033.size()-10 }; });
}
char QPdfWriter_NewPage(void* ptr)
{
return static_cast<QPdfWriter*>(ptr)->newPage();
}
char QPdfWriter_NewPageDefault(void* ptr)
{
return static_cast<QPdfWriter*>(ptr)->QPdfWriter::newPage();
}
void QPdfWriter_SetCreator(void* ptr, struct QtGui_PackedString creator)
{
static_cast<QPdfWriter*>(ptr)->setCreator(QString::fromUtf8(creator.data, creator.len));
}
void QPdfWriter_SetPdfVersion(void* ptr, long long version)
{
static_cast<QPdfWriter*>(ptr)->setPdfVersion(static_cast<QPagedPaintDevice::PdfVersion>(version));
}
void QPdfWriter_SetResolution(void* ptr, int resolution)
{
static_cast<QPdfWriter*>(ptr)->setResolution(resolution);
}
void QPdfWriter_SetTitle(void* ptr, struct QtGui_PackedString title)
{
static_cast<QPdfWriter*>(ptr)->setTitle(QString::fromUtf8(title.data, title.len));
}
void QPdfWriter_DestroyQPdfWriter(void* ptr)
{
static_cast<QPdfWriter*>(ptr)->~QPdfWriter();
}
void QPdfWriter_DestroyQPdfWriterDefault(void* ptr)
{
Q_UNUSED(ptr);
}
long long QPdfWriter_PdfVersion(void* ptr)
{
return static_cast<QPdfWriter*>(ptr)->pdfVersion();
}
void* QPdfWriter_PaintEngine(void* ptr)
{
return static_cast<QPdfWriter*>(ptr)->paintEngine();
}
void* QPdfWriter_PaintEngineDefault(void* ptr)
{
return static_cast<QPdfWriter*>(ptr)->QPdfWriter::paintEngine();
}
struct QtGui_PackedString QPdfWriter_Creator(void* ptr)
{
return ({ QByteArray te95fa2 = static_cast<QPdfWriter*>(ptr)->creator().toUtf8(); QtGui_PackedString { const_cast<char*>(te95fa2.prepend("WHITESPACE").constData()+10), te95fa2.size()-10 }; });
}
struct QtGui_PackedString QPdfWriter_Title(void* ptr)
{
return ({ QByteArray t5cd62a = static_cast<QPdfWriter*>(ptr)->title().toUtf8(); QtGui_PackedString { const_cast<char*>(t5cd62a.prepend("WHITESPACE").constData()+10), t5cd62a.size()-10 }; });
}
void* QPdfWriter_MetaObject(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QPdfWriter*>(ptr)->metaObject());
}
void* QPdfWriter_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QPdfWriter*>(ptr)->QPdfWriter::metaObject());
}
int QPdfWriter_Resolution(void* ptr)
{
return static_cast<QPdfWriter*>(ptr)->resolution();
}
void* QPdfWriter___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QPdfWriter___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QPdfWriter___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QPdfWriter___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPdfWriter___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPdfWriter___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPdfWriter___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPdfWriter___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPdfWriter___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPdfWriter___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPdfWriter___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPdfWriter___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPdfWriter___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPdfWriter___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPdfWriter___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QPdfWriter_Event(void* ptr, void* e)
{
return static_cast<QPdfWriter*>(ptr)->event(static_cast<QEvent*>(e));
}
char QPdfWriter_EventDefault(void* ptr, void* e)
{
return static_cast<QPdfWriter*>(ptr)->QPdfWriter::event(static_cast<QEvent*>(e));
}
char QPdfWriter_EventFilter(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QPdfWriter*>(ptr)->eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QPdfWriter*>(ptr)->eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QPdfWriter*>(ptr)->eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QPdfWriter*>(ptr)->eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QPdfWriter*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
char QPdfWriter_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QPdfWriter*>(ptr)->QPdfWriter::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QPdfWriter*>(ptr)->QPdfWriter::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QPdfWriter*>(ptr)->QPdfWriter::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QPdfWriter*>(ptr)->QPdfWriter::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QPdfWriter*>(ptr)->QPdfWriter::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QPdfWriter_ChildEvent(void* ptr, void* event)
{
static_cast<QPdfWriter*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}
void QPdfWriter_ChildEventDefault(void* ptr, void* event)
{
static_cast<QPdfWriter*>(ptr)->QPdfWriter::childEvent(static_cast<QChildEvent*>(event));
}
void QPdfWriter_ConnectNotify(void* ptr, void* sign)
{
static_cast<QPdfWriter*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QPdfWriter_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QPdfWriter*>(ptr)->QPdfWriter::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QPdfWriter_CustomEvent(void* ptr, void* event)
{
static_cast<QPdfWriter*>(ptr)->customEvent(static_cast<QEvent*>(event));
}
void QPdfWriter_CustomEventDefault(void* ptr, void* event)
{
static_cast<QPdfWriter*>(ptr)->QPdfWriter::customEvent(static_cast<QEvent*>(event));
}
void QPdfWriter_DeleteLater(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QPdfWriter*>(ptr), "deleteLater");
}
void QPdfWriter_DeleteLaterDefault(void* ptr)
{
static_cast<QPdfWriter*>(ptr)->QPdfWriter::deleteLater();
}
void QPdfWriter_DisconnectNotify(void* ptr, void* sign)
{
static_cast<QPdfWriter*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QPdfWriter_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QPdfWriter*>(ptr)->QPdfWriter::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QPdfWriter_TimerEvent(void* ptr, void* event)
{
static_cast<QPdfWriter*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}
void QPdfWriter_TimerEventDefault(void* ptr, void* event)
{
static_cast<QPdfWriter*>(ptr)->QPdfWriter::timerEvent(static_cast<QTimerEvent*>(event));
}
void* QPen_NewQPen()
{
return new QPen();
}
void* QPen_NewQPen6(void* pen)
{
return new QPen(*static_cast<QPen*>(pen));
}
void* QPen_NewQPen2(long long style)
{
return new QPen(static_cast<Qt::PenStyle>(style));
}
void* QPen_NewQPen4(void* brush, double width, long long style, long long cap, long long join)
{
return new QPen(*static_cast<QBrush*>(brush), width, static_cast<Qt::PenStyle>(style), static_cast<Qt::PenCapStyle>(cap), static_cast<Qt::PenJoinStyle>(join));
}
void* QPen_NewQPen3(void* color)
{
return new QPen(*static_cast<QColor*>(color));
}
void* QPen_NewQPen5(void* pen)
{
return new QPen(*static_cast<QPen*>(pen));
}
void QPen_SetBrush(void* ptr, void* brush)
{
static_cast<QPen*>(ptr)->setBrush(*static_cast<QBrush*>(brush));
}
void QPen_SetCapStyle(void* ptr, long long style)
{
static_cast<QPen*>(ptr)->setCapStyle(static_cast<Qt::PenCapStyle>(style));
}
void QPen_SetColor(void* ptr, void* color)
{
static_cast<QPen*>(ptr)->setColor(*static_cast<QColor*>(color));
}
void QPen_SetCosmetic(void* ptr, char cosmetic)
{
static_cast<QPen*>(ptr)->setCosmetic(cosmetic != 0);
}
void QPen_SetDashOffset(void* ptr, double offset)
{
static_cast<QPen*>(ptr)->setDashOffset(offset);
}
void QPen_SetDashPattern(void* ptr, void* pattern)
{
static_cast<QPen*>(ptr)->setDashPattern(*static_cast<QVector<qreal>*>(pattern));
}
void QPen_SetJoinStyle(void* ptr, long long style)
{
static_cast<QPen*>(ptr)->setJoinStyle(static_cast<Qt::PenJoinStyle>(style));
}
void QPen_SetMiterLimit(void* ptr, double limit)
{
static_cast<QPen*>(ptr)->setMiterLimit(limit);
}
void QPen_SetStyle(void* ptr, long long style)
{
static_cast<QPen*>(ptr)->setStyle(static_cast<Qt::PenStyle>(style));
}
void QPen_SetWidth(void* ptr, int width)
{
static_cast<QPen*>(ptr)->setWidth(width);
}
void QPen_SetWidthF(void* ptr, double width)
{
static_cast<QPen*>(ptr)->setWidthF(width);
}
void QPen_Swap(void* ptr, void* other)
{
static_cast<QPen*>(ptr)->swap(*static_cast<QPen*>(other));
}
void QPen_DestroyQPen(void* ptr)
{
static_cast<QPen*>(ptr)->~QPen();
}
void* QPen_Brush(void* ptr)
{
return new QBrush(static_cast<QPen*>(ptr)->brush());
}
void* QPen_Color(void* ptr)
{
return new QColor(static_cast<QPen*>(ptr)->color());
}
struct QtGui_PackedList QPen_DashPattern(void* ptr)
{
return ({ QVector<qreal>* tmpValue = new QVector<qreal>(static_cast<QPen*>(ptr)->dashPattern()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
long long QPen_CapStyle(void* ptr)
{
return static_cast<QPen*>(ptr)->capStyle();
}
long long QPen_JoinStyle(void* ptr)
{
return static_cast<QPen*>(ptr)->joinStyle();
}
long long QPen_Style(void* ptr)
{
return static_cast<QPen*>(ptr)->style();
}
char QPen_IsCosmetic(void* ptr)
{
return static_cast<QPen*>(ptr)->isCosmetic();
}
char QPen_IsSolid(void* ptr)
{
return static_cast<QPen*>(ptr)->isSolid();
}
int QPen_Width(void* ptr)
{
return static_cast<QPen*>(ptr)->width();
}
double QPen_DashOffset(void* ptr)
{
return static_cast<QPen*>(ptr)->dashOffset();
}
double QPen_MiterLimit(void* ptr)
{
return static_cast<QPen*>(ptr)->miterLimit();
}
double QPen_WidthF(void* ptr)
{
return static_cast<QPen*>(ptr)->widthF();
}
double QPen___setDashPattern_pattern_atList(void* ptr, int i)
{
return ({qreal tmp = static_cast<QVector<qreal>*>(ptr)->at(i); if (i == static_cast<QVector<qreal>*>(ptr)->size()-1) { static_cast<QVector<qreal>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QPen___setDashPattern_pattern_setList(void* ptr, double i)
{
static_cast<QVector<qreal>*>(ptr)->append(i);
}
void* QPen___setDashPattern_pattern_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<qreal>();
}
double QPen___dashPattern_atList(void* ptr, int i)
{
return ({qreal tmp = static_cast<QVector<qreal>*>(ptr)->at(i); if (i == static_cast<QVector<qreal>*>(ptr)->size()-1) { static_cast<QVector<qreal>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QPen___dashPattern_setList(void* ptr, double i)
{
static_cast<QVector<qreal>*>(ptr)->append(i);
}
void* QPen___dashPattern_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<qreal>();
}
class MyQPicture: public QPicture
{
public:
MyQPicture(const QPicture &pic) : QPicture(pic) {};
MyQPicture(int formatVersion = -1) : QPicture(formatVersion) {};
void setData(const char * data, uint size) { QtGui_PackedString dataPacked = { const_cast<char*>(data), size };callbackQPicture_SetData(this, dataPacked, size); };
~MyQPicture() { callbackQPicture_DestroyQPicture(this); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQPicture_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPaintDevice_Metric(const_cast<void*>(static_cast<const void*>(this)), metric); };
};
void* QPicture_NewQPicture2(void* pic)
{
return new MyQPicture(*static_cast<QPicture*>(pic));
}
void* QPicture_NewQPicture(int formatVersion)
{
return new MyQPicture(formatVersion);
}
char QPicture_Load2(void* ptr, void* dev, char* format)
{
return static_cast<QPicture*>(ptr)->load(static_cast<QIODevice*>(dev), const_cast<const char*>(format));
}
char QPicture_Load(void* ptr, struct QtGui_PackedString fileName, char* format)
{
return static_cast<QPicture*>(ptr)->load(QString::fromUtf8(fileName.data, fileName.len), const_cast<const char*>(format));
}
char QPicture_Play(void* ptr, void* painter)
{
return static_cast<QPicture*>(ptr)->play(static_cast<QPainter*>(painter));
}
char QPicture_Save2(void* ptr, void* dev, char* format)
{
return static_cast<QPicture*>(ptr)->save(static_cast<QIODevice*>(dev), const_cast<const char*>(format));
}
char QPicture_Save(void* ptr, struct QtGui_PackedString fileName, char* format)
{
return static_cast<QPicture*>(ptr)->save(QString::fromUtf8(fileName.data, fileName.len), const_cast<const char*>(format));
}
void QPicture_SetBoundingRect(void* ptr, void* r)
{
static_cast<QPicture*>(ptr)->setBoundingRect(*static_cast<QRect*>(r));
}
void QPicture_SetData(void* ptr, char* data, unsigned int size)
{
static_cast<QPicture*>(ptr)->setData(const_cast<const char*>(data), size);
}
void QPicture_SetDataDefault(void* ptr, char* data, unsigned int size)
{
static_cast<QPicture*>(ptr)->QPicture::setData(const_cast<const char*>(data), size);
}
void QPicture_Swap(void* ptr, void* other)
{
static_cast<QPicture*>(ptr)->swap(*static_cast<QPicture*>(other));
}
void QPicture_DestroyQPicture(void* ptr)
{
static_cast<QPicture*>(ptr)->~QPicture();
}
void QPicture_DestroyQPictureDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QPicture_BoundingRect(void* ptr)
{
return ({ QRect tmpValue = static_cast<QPicture*>(ptr)->boundingRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
char QPicture_IsNull(void* ptr)
{
return static_cast<QPicture*>(ptr)->isNull();
}
struct QtGui_PackedString QPicture_Data(void* ptr)
{
return QtGui_PackedString { const_cast<char*>(static_cast<QPicture*>(ptr)->data()), static_cast<QPicture*>(ptr)->size() };
}
unsigned int QPicture_Size(void* ptr)
{
return static_cast<QPicture*>(ptr)->size();
}
void* QPicture___inputFormats_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QPicture___inputFormats_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QPicture___inputFormats_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QPicture___outputFormats_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QPicture___outputFormats_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QPicture___outputFormats_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QPicture_PaintEngine(void* ptr)
{
return static_cast<QPicture*>(ptr)->paintEngine();
}
void* QPicture_PaintEngineDefault(void* ptr)
{
return static_cast<QPicture*>(ptr)->QPicture::paintEngine();
}
class MyQPictureFormatPlugin: public QPictureFormatPlugin
{
public:
MyQPictureFormatPlugin(QObject *parent = Q_NULLPTR) : QPictureFormatPlugin(parent) {QPictureFormatPlugin_QPictureFormatPlugin_QRegisterMetaType();};
bool installIOHandler(const QString & format) { QByteArray t785987 = format.toUtf8(); QtGui_PackedString formatPacked = { const_cast<char*>(t785987.prepend("WHITESPACE").constData()+10), t785987.size()-10 };return callbackQPictureFormatPlugin_InstallIOHandler(this, formatPacked) != 0; };
bool loadPicture(const QString & format, const QString & fileName, QPicture * picture) { QByteArray t785987 = format.toUtf8(); QtGui_PackedString formatPacked = { const_cast<char*>(t785987.prepend("WHITESPACE").constData()+10), t785987.size()-10 };QByteArray td83e09 = fileName.toUtf8(); QtGui_PackedString fileNamePacked = { const_cast<char*>(td83e09.prepend("WHITESPACE").constData()+10), td83e09.size()-10 };return callbackQPictureFormatPlugin_LoadPicture(this, formatPacked, fileNamePacked, picture) != 0; };
bool savePicture(const QString & format, const QString & fileName, const QPicture & picture) { QByteArray t785987 = format.toUtf8(); QtGui_PackedString formatPacked = { const_cast<char*>(t785987.prepend("WHITESPACE").constData()+10), t785987.size()-10 };QByteArray td83e09 = fileName.toUtf8(); QtGui_PackedString fileNamePacked = { const_cast<char*>(td83e09.prepend("WHITESPACE").constData()+10), td83e09.size()-10 };return callbackQPictureFormatPlugin_SavePicture(this, formatPacked, fileNamePacked, const_cast<QPicture*>(&picture)) != 0; };
~MyQPictureFormatPlugin() { callbackQPictureFormatPlugin_DestroyQPictureFormatPlugin(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQPictureFormatPlugin_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQPictureFormatPlugin_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQPictureFormatPlugin_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQPictureFormatPlugin_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQPictureFormatPlugin_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQPictureFormatPlugin_CustomEvent(this, event); };
void deleteLater() { callbackQPictureFormatPlugin_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQPictureFormatPlugin_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQPictureFormatPlugin_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQPictureFormatPlugin_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQPictureFormatPlugin_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQPictureFormatPlugin*)
int QPictureFormatPlugin_QPictureFormatPlugin_QRegisterMetaType(){qRegisterMetaType<QPictureFormatPlugin*>(); return qRegisterMetaType<MyQPictureFormatPlugin*>();}
void* QPictureFormatPlugin_NewQPictureFormatPlugin(void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQPictureFormatPlugin(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQPictureFormatPlugin(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQPictureFormatPlugin(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQPictureFormatPlugin(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQPictureFormatPlugin(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQPictureFormatPlugin(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQPictureFormatPlugin(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQPictureFormatPlugin(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQPictureFormatPlugin(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQPictureFormatPlugin(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQPictureFormatPlugin(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQPictureFormatPlugin(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQPictureFormatPlugin(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQPictureFormatPlugin(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQPictureFormatPlugin(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQPictureFormatPlugin(static_cast<QWindow*>(parent));
} else {
return new MyQPictureFormatPlugin(static_cast<QObject*>(parent));
}
}
struct QtGui_PackedString QPictureFormatPlugin_QPictureFormatPlugin_Tr(char* s, char* c, int n)
{
return ({ QByteArray t7a788b = QPictureFormatPlugin::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t7a788b.prepend("WHITESPACE").constData()+10), t7a788b.size()-10 }; });
}
struct QtGui_PackedString QPictureFormatPlugin_QPictureFormatPlugin_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray t956923 = QPictureFormatPlugin::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t956923.prepend("WHITESPACE").constData()+10), t956923.size()-10 }; });
}
char QPictureFormatPlugin_InstallIOHandler(void* ptr, struct QtGui_PackedString format)
{
return static_cast<QPictureFormatPlugin*>(ptr)->installIOHandler(QString::fromUtf8(format.data, format.len));
}
char QPictureFormatPlugin_LoadPicture(void* ptr, struct QtGui_PackedString format, struct QtGui_PackedString fileName, void* picture)
{
return static_cast<QPictureFormatPlugin*>(ptr)->loadPicture(QString::fromUtf8(format.data, format.len), QString::fromUtf8(fileName.data, fileName.len), static_cast<QPicture*>(picture));
}
char QPictureFormatPlugin_LoadPictureDefault(void* ptr, struct QtGui_PackedString format, struct QtGui_PackedString fileName, void* picture)
{
return static_cast<QPictureFormatPlugin*>(ptr)->QPictureFormatPlugin::loadPicture(QString::fromUtf8(format.data, format.len), QString::fromUtf8(fileName.data, fileName.len), static_cast<QPicture*>(picture));
}
char QPictureFormatPlugin_SavePicture(void* ptr, struct QtGui_PackedString format, struct QtGui_PackedString fileName, void* picture)
{
return static_cast<QPictureFormatPlugin*>(ptr)->savePicture(QString::fromUtf8(format.data, format.len), QString::fromUtf8(fileName.data, fileName.len), *static_cast<QPicture*>(picture));
}
char QPictureFormatPlugin_SavePictureDefault(void* ptr, struct QtGui_PackedString format, struct QtGui_PackedString fileName, void* picture)
{
return static_cast<QPictureFormatPlugin*>(ptr)->QPictureFormatPlugin::savePicture(QString::fromUtf8(format.data, format.len), QString::fromUtf8(fileName.data, fileName.len), *static_cast<QPicture*>(picture));
}
void QPictureFormatPlugin_DestroyQPictureFormatPlugin(void* ptr)
{
static_cast<QPictureFormatPlugin*>(ptr)->~QPictureFormatPlugin();
}
void QPictureFormatPlugin_DestroyQPictureFormatPluginDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QPictureFormatPlugin_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QPictureFormatPlugin*>(ptr)->QPictureFormatPlugin::metaObject());
}
void* QPictureFormatPlugin___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QPictureFormatPlugin___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QPictureFormatPlugin___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QPictureFormatPlugin___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPictureFormatPlugin___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPictureFormatPlugin___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPictureFormatPlugin___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPictureFormatPlugin___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPictureFormatPlugin___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPictureFormatPlugin___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPictureFormatPlugin___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPictureFormatPlugin___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPictureFormatPlugin___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPictureFormatPlugin___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPictureFormatPlugin___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QPictureFormatPlugin_EventDefault(void* ptr, void* e)
{
return static_cast<QPictureFormatPlugin*>(ptr)->QPictureFormatPlugin::event(static_cast<QEvent*>(e));
}
char QPictureFormatPlugin_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QPictureFormatPlugin*>(ptr)->QPictureFormatPlugin::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QPictureFormatPlugin*>(ptr)->QPictureFormatPlugin::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QPictureFormatPlugin*>(ptr)->QPictureFormatPlugin::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QPictureFormatPlugin*>(ptr)->QPictureFormatPlugin::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QPictureFormatPlugin*>(ptr)->QPictureFormatPlugin::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QPictureFormatPlugin_ChildEventDefault(void* ptr, void* event)
{
static_cast<QPictureFormatPlugin*>(ptr)->QPictureFormatPlugin::childEvent(static_cast<QChildEvent*>(event));
}
void QPictureFormatPlugin_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QPictureFormatPlugin*>(ptr)->QPictureFormatPlugin::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QPictureFormatPlugin_CustomEventDefault(void* ptr, void* event)
{
static_cast<QPictureFormatPlugin*>(ptr)->QPictureFormatPlugin::customEvent(static_cast<QEvent*>(event));
}
void QPictureFormatPlugin_DeleteLaterDefault(void* ptr)
{
static_cast<QPictureFormatPlugin*>(ptr)->QPictureFormatPlugin::deleteLater();
}
void QPictureFormatPlugin_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QPictureFormatPlugin*>(ptr)->QPictureFormatPlugin::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QPictureFormatPlugin_TimerEventDefault(void* ptr, void* event)
{
static_cast<QPictureFormatPlugin*>(ptr)->QPictureFormatPlugin::timerEvent(static_cast<QTimerEvent*>(event));
}
void* QPictureIO_QPictureIO_PictureFormat2(void* d)
{
return new QByteArray(QPictureIO::pictureFormat(static_cast<QIODevice*>(d)));
}
void* QPictureIO_QPictureIO_PictureFormat(struct QtGui_PackedString fileName)
{
return new QByteArray(QPictureIO::pictureFormat(QString::fromUtf8(fileName.data, fileName.len)));
}
struct QtGui_PackedList QPictureIO_QPictureIO_InputFormats()
{
return ({ QList<QByteArray>* tmpValue = new QList<QByteArray>(QPictureIO::inputFormats()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedList QPictureIO_QPictureIO_OutputFormats()
{
return ({ QList<QByteArray>* tmpValue = new QList<QByteArray>(QPictureIO::outputFormats()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QPictureIO_NewQPictureIO()
{
return new QPictureIO();
}
void* QPictureIO_NewQPictureIO2(void* ioDevice, char* format)
{
return new QPictureIO(static_cast<QIODevice*>(ioDevice), const_cast<const char*>(format));
}
void* QPictureIO_NewQPictureIO3(struct QtGui_PackedString fileName, char* format)
{
return new QPictureIO(QString::fromUtf8(fileName.data, fileName.len), const_cast<const char*>(format));
}
char QPictureIO_Read(void* ptr)
{
return static_cast<QPictureIO*>(ptr)->read();
}
char QPictureIO_Write(void* ptr)
{
return static_cast<QPictureIO*>(ptr)->write();
}
void QPictureIO_SetDescription(void* ptr, struct QtGui_PackedString description)
{
static_cast<QPictureIO*>(ptr)->setDescription(QString::fromUtf8(description.data, description.len));
}
void QPictureIO_SetFileName(void* ptr, struct QtGui_PackedString fileName)
{
static_cast<QPictureIO*>(ptr)->setFileName(QString::fromUtf8(fileName.data, fileName.len));
}
void QPictureIO_SetFormat(void* ptr, char* format)
{
static_cast<QPictureIO*>(ptr)->setFormat(const_cast<const char*>(format));
}
void QPictureIO_SetGamma(void* ptr, float gamma)
{
static_cast<QPictureIO*>(ptr)->setGamma(gamma);
}
void QPictureIO_SetIODevice(void* ptr, void* ioDevice)
{
static_cast<QPictureIO*>(ptr)->setIODevice(static_cast<QIODevice*>(ioDevice));
}
void QPictureIO_SetParameters(void* ptr, char* parameters)
{
static_cast<QPictureIO*>(ptr)->setParameters(const_cast<const char*>(parameters));
}
void QPictureIO_SetPicture(void* ptr, void* picture)
{
static_cast<QPictureIO*>(ptr)->setPicture(*static_cast<QPicture*>(picture));
}
void QPictureIO_SetQuality(void* ptr, int q)
{
static_cast<QPictureIO*>(ptr)->setQuality(q);
}
void QPictureIO_SetStatus(void* ptr, int status)
{
static_cast<QPictureIO*>(ptr)->setStatus(status);
}
void QPictureIO_DestroyQPictureIO(void* ptr)
{
static_cast<QPictureIO*>(ptr)->~QPictureIO();
}
void* QPictureIO_IoDevice(void* ptr)
{
return static_cast<QPictureIO*>(ptr)->ioDevice();
}
struct QtGui_PackedString QPictureIO_Description(void* ptr)
{
return ({ QByteArray te4ace0 = static_cast<QPictureIO*>(ptr)->description().toUtf8(); QtGui_PackedString { const_cast<char*>(te4ace0.prepend("WHITESPACE").constData()+10), te4ace0.size()-10 }; });
}
struct QtGui_PackedString QPictureIO_FileName(void* ptr)
{
return ({ QByteArray t48ef9a = static_cast<QPictureIO*>(ptr)->fileName().toUtf8(); QtGui_PackedString { const_cast<char*>(t48ef9a.prepend("WHITESPACE").constData()+10), t48ef9a.size()-10 }; });
}
void* QPictureIO_Picture(void* ptr)
{
return const_cast<QPicture*>(&static_cast<QPictureIO*>(ptr)->picture());
}
struct QtGui_PackedString QPictureIO_Format(void* ptr)
{
return QtGui_PackedString { const_cast<char*>(static_cast<QPictureIO*>(ptr)->format()), -1 };
}
struct QtGui_PackedString QPictureIO_Parameters(void* ptr)
{
return QtGui_PackedString { const_cast<char*>(static_cast<QPictureIO*>(ptr)->parameters()), -1 };
}
float QPictureIO_Gamma(void* ptr)
{
return static_cast<QPictureIO*>(ptr)->gamma();
}
int QPictureIO_Quality(void* ptr)
{
return static_cast<QPictureIO*>(ptr)->quality();
}
int QPictureIO_Status(void* ptr)
{
return static_cast<QPictureIO*>(ptr)->status();
}
void* QPictureIO___inputFormats_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QPictureIO___inputFormats_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QPictureIO___inputFormats_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QPictureIO___outputFormats_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QPictureIO___outputFormats_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QPictureIO___outputFormats_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QPixelFormat_NewQPixelFormat()
{
return new QPixelFormat();
}
void* QPixelFormat_NewQPixelFormat2(long long colorModel, char* firstSize, char* secondSize, char* thirdSize, char* fourthSize, char* fifthSize, char* alphaSize, long long alphaUsage, long long alphaPosition, long long premultiplied, long long typeInterpretation, long long byteOrder, char* subEnum)
{
return new QPixelFormat(static_cast<QPixelFormat::ColorModel>(colorModel), *static_cast<uchar*>(static_cast<void*>(firstSize)), *static_cast<uchar*>(static_cast<void*>(secondSize)), *static_cast<uchar*>(static_cast<void*>(thirdSize)), *static_cast<uchar*>(static_cast<void*>(fourthSize)), *static_cast<uchar*>(static_cast<void*>(fifthSize)), *static_cast<uchar*>(static_cast<void*>(alphaSize)), static_cast<QPixelFormat::AlphaUsage>(alphaUsage), static_cast<QPixelFormat::AlphaPosition>(alphaPosition), static_cast<QPixelFormat::AlphaPremultiplied>(premultiplied), static_cast<QPixelFormat::TypeInterpretation>(typeInterpretation), static_cast<QPixelFormat::ByteOrder>(byteOrder), *static_cast<uchar*>(static_cast<void*>(subEnum)));
}
long long QPixelFormat_AlphaPosition(void* ptr)
{
return static_cast<QPixelFormat*>(ptr)->alphaPosition();
}
long long QPixelFormat_Premultiplied(void* ptr)
{
return static_cast<QPixelFormat*>(ptr)->premultiplied();
}
long long QPixelFormat_AlphaUsage(void* ptr)
{
return static_cast<QPixelFormat*>(ptr)->alphaUsage();
}
long long QPixelFormat_ByteOrder(void* ptr)
{
return static_cast<QPixelFormat*>(ptr)->byteOrder();
}
long long QPixelFormat_ColorModel(void* ptr)
{
return static_cast<QPixelFormat*>(ptr)->colorModel();
}
long long QPixelFormat_TypeInterpretation(void* ptr)
{
return static_cast<QPixelFormat*>(ptr)->typeInterpretation();
}
long long QPixelFormat_YuvLayout(void* ptr)
{
return static_cast<QPixelFormat*>(ptr)->yuvLayout();
}
struct QtGui_PackedString QPixelFormat_AlphaSize(void* ptr)
{
return ({ uchar pret9daa6f = static_cast<QPixelFormat*>(ptr)->alphaSize(); char* t9daa6f = static_cast<char*>(static_cast<void*>(&pret9daa6f)); QtGui_PackedString { t9daa6f, -1 }; });
}
struct QtGui_PackedString QPixelFormat_BitsPerPixel(void* ptr)
{
return ({ uchar preta6a744 = static_cast<QPixelFormat*>(ptr)->bitsPerPixel(); char* ta6a744 = static_cast<char*>(static_cast<void*>(&preta6a744)); QtGui_PackedString { ta6a744, -1 }; });
}
struct QtGui_PackedString QPixelFormat_BlackSize(void* ptr)
{
return ({ uchar pretb1416d = static_cast<QPixelFormat*>(ptr)->blackSize(); char* tb1416d = static_cast<char*>(static_cast<void*>(&pretb1416d)); QtGui_PackedString { tb1416d, -1 }; });
}
struct QtGui_PackedString QPixelFormat_BlueSize(void* ptr)
{
return ({ uchar pretf9134a = static_cast<QPixelFormat*>(ptr)->blueSize(); char* tf9134a = static_cast<char*>(static_cast<void*>(&pretf9134a)); QtGui_PackedString { tf9134a, -1 }; });
}
struct QtGui_PackedString QPixelFormat_BrightnessSize(void* ptr)
{
return ({ uchar pretd53fac = static_cast<QPixelFormat*>(ptr)->brightnessSize(); char* td53fac = static_cast<char*>(static_cast<void*>(&pretd53fac)); QtGui_PackedString { td53fac, -1 }; });
}
struct QtGui_PackedString QPixelFormat_ChannelCount(void* ptr)
{
return ({ uchar pret704cf3 = static_cast<QPixelFormat*>(ptr)->channelCount(); char* t704cf3 = static_cast<char*>(static_cast<void*>(&pret704cf3)); QtGui_PackedString { t704cf3, -1 }; });
}
struct QtGui_PackedString QPixelFormat_CyanSize(void* ptr)
{
return ({ uchar pret19e508 = static_cast<QPixelFormat*>(ptr)->cyanSize(); char* t19e508 = static_cast<char*>(static_cast<void*>(&pret19e508)); QtGui_PackedString { t19e508, -1 }; });
}
struct QtGui_PackedString QPixelFormat_GreenSize(void* ptr)
{
return ({ uchar pret2cbd5e = static_cast<QPixelFormat*>(ptr)->greenSize(); char* t2cbd5e = static_cast<char*>(static_cast<void*>(&pret2cbd5e)); QtGui_PackedString { t2cbd5e, -1 }; });
}
struct QtGui_PackedString QPixelFormat_HueSize(void* ptr)
{
return ({ uchar pret0f029c = static_cast<QPixelFormat*>(ptr)->hueSize(); char* t0f029c = static_cast<char*>(static_cast<void*>(&pret0f029c)); QtGui_PackedString { t0f029c, -1 }; });
}
struct QtGui_PackedString QPixelFormat_LightnessSize(void* ptr)
{
return ({ uchar pretdfc9b5 = static_cast<QPixelFormat*>(ptr)->lightnessSize(); char* tdfc9b5 = static_cast<char*>(static_cast<void*>(&pretdfc9b5)); QtGui_PackedString { tdfc9b5, -1 }; });
}
struct QtGui_PackedString QPixelFormat_MagentaSize(void* ptr)
{
return ({ uchar pret78ac06 = static_cast<QPixelFormat*>(ptr)->magentaSize(); char* t78ac06 = static_cast<char*>(static_cast<void*>(&pret78ac06)); QtGui_PackedString { t78ac06, -1 }; });
}
struct QtGui_PackedString QPixelFormat_RedSize(void* ptr)
{
return ({ uchar pret1a20f5 = static_cast<QPixelFormat*>(ptr)->redSize(); char* t1a20f5 = static_cast<char*>(static_cast<void*>(&pret1a20f5)); QtGui_PackedString { t1a20f5, -1 }; });
}
struct QtGui_PackedString QPixelFormat_SaturationSize(void* ptr)
{
return ({ uchar pretff1cd0 = static_cast<QPixelFormat*>(ptr)->saturationSize(); char* tff1cd0 = static_cast<char*>(static_cast<void*>(&pretff1cd0)); QtGui_PackedString { tff1cd0, -1 }; });
}
struct QtGui_PackedString QPixelFormat_YellowSize(void* ptr)
{
return ({ uchar pret7b52e4 = static_cast<QPixelFormat*>(ptr)->yellowSize(); char* t7b52e4 = static_cast<char*>(static_cast<void*>(&pret7b52e4)); QtGui_PackedString { t7b52e4, -1 }; });
}
class MyQPixmap: public QPixmap
{
public:
MyQPixmap() : QPixmap() {};
MyQPixmap(const QPixmap &pixmap) : QPixmap(pixmap) {};
MyQPixmap(const QSize &size) : QPixmap(size) {};
MyQPixmap(const QString &fileName, const char *format = Q_NULLPTR, Qt::ImageConversionFlags flags = Qt::AutoColor) : QPixmap(fileName, format, flags) {};
MyQPixmap(int width, int height) : QPixmap(width, height) {};
~MyQPixmap() { callbackQPixmap_DestroyQPixmap(this); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQPixmap_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPaintDevice_Metric(const_cast<void*>(static_cast<const void*>(this)), metric); };
};
void* QPixmap_QPixmap_TrueMatrix2(void* m, int w, int h)
{
return new QMatrix(QPixmap::trueMatrix(*static_cast<QMatrix*>(m), w, h));
}
void* QPixmap_QPixmap_FromImage2(void* image, long long flags)
{
return new QPixmap(QPixmap::fromImage(*static_cast<QImage*>(image), static_cast<Qt::ImageConversionFlag>(flags)));
}
void* QPixmap_QPixmap_FromImage(void* image, long long flags)
{
return new QPixmap(QPixmap::fromImage(*static_cast<QImage*>(image), static_cast<Qt::ImageConversionFlag>(flags)));
}
void* QPixmap_QPixmap_FromImageReader(void* imageReader, long long flags)
{
return new QPixmap(QPixmap::fromImageReader(static_cast<QImageReader*>(imageReader), static_cast<Qt::ImageConversionFlag>(flags)));
}
void* QPixmap_NewQPixmap()
{
return new MyQPixmap();
}
void* QPixmap_NewQPixmap7(void* pixmap)
{
return new MyQPixmap(*static_cast<QPixmap*>(pixmap));
}
void* QPixmap_NewQPixmap4(void* size)
{
return new MyQPixmap(*static_cast<QSize*>(size));
}
void* QPixmap_NewQPixmap5(struct QtGui_PackedString fileName, char* format, long long flags)
{
return new MyQPixmap(QString::fromUtf8(fileName.data, fileName.len), const_cast<const char*>(format), static_cast<Qt::ImageConversionFlag>(flags));
}
void* QPixmap_NewQPixmap3(int width, int height)
{
return new MyQPixmap(width, height);
}
void* QPixmap_QPixmap_TrueMatrix(void* matrix, int width, int height)
{
return new QTransform(QPixmap::trueMatrix(*static_cast<QTransform*>(matrix), width, height));
}
char QPixmap_ConvertFromImage(void* ptr, void* image, long long flags)
{
return static_cast<QPixmap*>(ptr)->convertFromImage(*static_cast<QImage*>(image), static_cast<Qt::ImageConversionFlag>(flags));
}
char QPixmap_Load(void* ptr, struct QtGui_PackedString fileName, char* format, long long flags)
{
return static_cast<QPixmap*>(ptr)->load(QString::fromUtf8(fileName.data, fileName.len), const_cast<const char*>(format), static_cast<Qt::ImageConversionFlag>(flags));
}
char QPixmap_LoadFromData2(void* ptr, void* data, char* format, long long flags)
{
return static_cast<QPixmap*>(ptr)->loadFromData(*static_cast<QByteArray*>(data), const_cast<const char*>(format), static_cast<Qt::ImageConversionFlag>(flags));
}
char QPixmap_LoadFromData(void* ptr, char* data, unsigned int l, char* format, long long flags)
{
return static_cast<QPixmap*>(ptr)->loadFromData(const_cast<const uchar*>(static_cast<uchar*>(static_cast<void*>(data))), l, const_cast<const char*>(format), static_cast<Qt::ImageConversionFlag>(flags));
}
int QPixmap_QPixmap_DefaultDepth()
{
return QPixmap::defaultDepth();
}
void QPixmap_Detach(void* ptr)
{
static_cast<QPixmap*>(ptr)->detach();
}
void QPixmap_Fill(void* ptr, void* color)
{
static_cast<QPixmap*>(ptr)->fill(*static_cast<QColor*>(color));
}
void QPixmap_Scroll2(void* ptr, int dx, int dy, void* rect, void* exposed)
{
static_cast<QPixmap*>(ptr)->scroll(dx, dy, *static_cast<QRect*>(rect), static_cast<QRegion*>(exposed));
}
void QPixmap_Scroll(void* ptr, int dx, int dy, int x, int y, int width, int height, void* exposed)
{
static_cast<QPixmap*>(ptr)->scroll(dx, dy, x, y, width, height, static_cast<QRegion*>(exposed));
}
void QPixmap_SetDevicePixelRatio(void* ptr, double scaleFactor)
{
static_cast<QPixmap*>(ptr)->setDevicePixelRatio(scaleFactor);
}
void QPixmap_SetMask(void* ptr, void* mask)
{
static_cast<QPixmap*>(ptr)->setMask(*static_cast<QBitmap*>(mask));
}
void QPixmap_Swap(void* ptr, void* other)
{
static_cast<QPixmap*>(ptr)->swap(*static_cast<QPixmap*>(other));
}
void QPixmap_DestroyQPixmap(void* ptr)
{
static_cast<QPixmap*>(ptr)->~QPixmap();
}
void QPixmap_DestroyQPixmapDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QPixmap_CreateHeuristicMask(void* ptr, char clipTight)
{
return new QBitmap(static_cast<QPixmap*>(ptr)->createHeuristicMask(clipTight != 0));
}
void* QPixmap_CreateMaskFromColor(void* ptr, void* maskColor, long long mode)
{
return new QBitmap(static_cast<QPixmap*>(ptr)->createMaskFromColor(*static_cast<QColor*>(maskColor), static_cast<Qt::MaskMode>(mode)));
}
void* QPixmap_Mask(void* ptr)
{
return new QBitmap(static_cast<QPixmap*>(ptr)->mask());
}
void* QPixmap_ToImage(void* ptr)
{
return new QImage(static_cast<QPixmap*>(ptr)->toImage());
}
void* QPixmap_Copy(void* ptr, void* rectangle)
{
return new QPixmap(static_cast<QPixmap*>(ptr)->copy(*static_cast<QRect*>(rectangle)));
}
void* QPixmap_Copy2(void* ptr, int x, int y, int width, int height)
{
return new QPixmap(static_cast<QPixmap*>(ptr)->copy(x, y, width, height));
}
void* QPixmap_Scaled(void* ptr, void* size, long long aspectRatioMode, long long transformMode)
{
return new QPixmap(static_cast<QPixmap*>(ptr)->scaled(*static_cast<QSize*>(size), static_cast<Qt::AspectRatioMode>(aspectRatioMode), static_cast<Qt::TransformationMode>(transformMode)));
}
void* QPixmap_Scaled2(void* ptr, int width, int height, long long aspectRatioMode, long long transformMode)
{
return new QPixmap(static_cast<QPixmap*>(ptr)->scaled(width, height, static_cast<Qt::AspectRatioMode>(aspectRatioMode), static_cast<Qt::TransformationMode>(transformMode)));
}
void* QPixmap_ScaledToHeight(void* ptr, int height, long long mode)
{
return new QPixmap(static_cast<QPixmap*>(ptr)->scaledToHeight(height, static_cast<Qt::TransformationMode>(mode)));
}
void* QPixmap_ScaledToWidth(void* ptr, int width, long long mode)
{
return new QPixmap(static_cast<QPixmap*>(ptr)->scaledToWidth(width, static_cast<Qt::TransformationMode>(mode)));
}
void* QPixmap_Transformed2(void* ptr, void* matrix, long long mode)
{
return new QPixmap(static_cast<QPixmap*>(ptr)->transformed(*static_cast<QMatrix*>(matrix), static_cast<Qt::TransformationMode>(mode)));
}
void* QPixmap_Transformed(void* ptr, void* transform, long long mode)
{
return new QPixmap(static_cast<QPixmap*>(ptr)->transformed(*static_cast<QTransform*>(transform), static_cast<Qt::TransformationMode>(mode)));
}
void* QPixmap_Rect(void* ptr)
{
return ({ QRect tmpValue = static_cast<QPixmap*>(ptr)->rect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QPixmap_Size(void* ptr)
{
return ({ QSize tmpValue = static_cast<QPixmap*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
}
char QPixmap_HasAlpha(void* ptr)
{
return static_cast<QPixmap*>(ptr)->hasAlpha();
}
char QPixmap_HasAlphaChannel(void* ptr)
{
return static_cast<QPixmap*>(ptr)->hasAlphaChannel();
}
char QPixmap_IsNull(void* ptr)
{
return static_cast<QPixmap*>(ptr)->isNull();
}
char QPixmap_IsQBitmap(void* ptr)
{
return static_cast<QPixmap*>(ptr)->isQBitmap();
}
char QPixmap_Save2(void* ptr, void* device, char* format, int quality)
{
return static_cast<QPixmap*>(ptr)->save(static_cast<QIODevice*>(device), const_cast<const char*>(format), quality);
}
char QPixmap_Save(void* ptr, struct QtGui_PackedString fileName, char* format, int quality)
{
return static_cast<QPixmap*>(ptr)->save(QString::fromUtf8(fileName.data, fileName.len), const_cast<const char*>(format), quality);
}
long long QPixmap_CacheKey(void* ptr)
{
return static_cast<QPixmap*>(ptr)->cacheKey();
}
double QPixmap_DevicePixelRatio(void* ptr)
{
return static_cast<QPixmap*>(ptr)->devicePixelRatio();
}
void* QPixmap_PaintEngine(void* ptr)
{
return static_cast<QPixmap*>(ptr)->paintEngine();
}
void* QPixmap_PaintEngineDefault(void* ptr)
{
if (dynamic_cast<QBitmap*>(static_cast<QPixmap*>(ptr))) {
return static_cast<QBitmap*>(ptr)->QBitmap::paintEngine();
} else {
return static_cast<QPixmap*>(ptr)->QPixmap::paintEngine();
}
}
char QPixmapCache_QPixmapCache_Find(struct QtGui_PackedString key, void* pixmap)
{
return QPixmapCache::find(QString::fromUtf8(key.data, key.len), static_cast<QPixmap*>(pixmap));
}
char QPixmapCache_QPixmapCache_Insert(struct QtGui_PackedString key, void* pixmap)
{
return QPixmapCache::insert(QString::fromUtf8(key.data, key.len), *static_cast<QPixmap*>(pixmap));
}
int QPixmapCache_QPixmapCache_CacheLimit()
{
return QPixmapCache::cacheLimit();
}
void QPixmapCache_QPixmapCache_Clear()
{
QPixmapCache::clear();
}
void QPixmapCache_QPixmapCache_Remove(struct QtGui_PackedString key)
{
QPixmapCache::remove(QString::fromUtf8(key.data, key.len));
}
void QPixmapCache_QPixmapCache_SetCacheLimit(int n)
{
QPixmapCache::setCacheLimit(n);
}
class MyQPlatformSurfaceEvent: public QPlatformSurfaceEvent
{
public:
MyQPlatformSurfaceEvent(QPlatformSurfaceEvent::SurfaceEventType surfaceEventType) : QPlatformSurfaceEvent(surfaceEventType) {};
};
void* QPlatformSurfaceEvent_NewQPlatformSurfaceEvent(long long surfaceEventType)
{
return new MyQPlatformSurfaceEvent(static_cast<QPlatformSurfaceEvent::SurfaceEventType>(surfaceEventType));
}
long long QPlatformSurfaceEvent_SurfaceEventType(void* ptr)
{
return static_cast<QPlatformSurfaceEvent*>(ptr)->surfaceEventType();
}
long long QPlatformSurfaceEvent_M_surfaceEventType(void* ptr)
{
return static_cast<QPlatformSurfaceEvent*>(ptr)->m_surfaceEventType;
}
void QPlatformSurfaceEvent_SetM_surfaceEventType(void* ptr, long long vqp)
{
static_cast<QPlatformSurfaceEvent*>(ptr)->m_surfaceEventType = static_cast<QPlatformSurfaceEvent::SurfaceEventType>(vqp);
}
void* QPointingDeviceUniqueId_QPointingDeviceUniqueId_FromNumericId(long long id)
{
return new QPointingDeviceUniqueId(QPointingDeviceUniqueId::fromNumericId(id));
}
void* QPointingDeviceUniqueId_NewQPointingDeviceUniqueId()
{
return new QPointingDeviceUniqueId();
}
char QPointingDeviceUniqueId_IsValid(void* ptr)
{
return static_cast<QPointingDeviceUniqueId*>(ptr)->isValid();
}
long long QPointingDeviceUniqueId_NumericId(void* ptr)
{
return static_cast<QPointingDeviceUniqueId*>(ptr)->numericId();
}
void* QPolygon_NewQPolygon()
{
return new QPolygon();
}
void* QPolygon_NewQPolygon8(void* other)
{
return new QPolygon(*static_cast<QPolygon*>(other));
}
void* QPolygon_NewQPolygon4(void* v)
{
return new QPolygon(({ QVector<QPoint>* tmpP = static_cast<QVector<QPoint>*>(v); QVector<QPoint> tmpV = *tmpP; tmpP->~QVector(); free(tmpP); tmpV; }));
}
void* QPolygon_NewQPolygon7(void* polygon)
{
return new QPolygon(*static_cast<QPolygon*>(polygon));
}
void* QPolygon_NewQPolygon5(void* rectangle, char closed)
{
return new QPolygon(*static_cast<QRect*>(rectangle), closed != 0);
}
void* QPolygon_NewQPolygon3(void* points)
{
return new QPolygon(*static_cast<QVector<QPoint>*>(points));
}
void* QPolygon_NewQPolygon2(int size)
{
return new QPolygon(size);
}
void QPolygon_PutPoints3(void* ptr, int index, int nPoints, void* fromPolygon, int fromIndex)
{
static_cast<QPolygon*>(ptr)->putPoints(index, nPoints, *static_cast<QPolygon*>(fromPolygon), fromIndex);
}
void QPolygon_SetPoint2(void* ptr, int index, void* point)
{
static_cast<QPolygon*>(ptr)->setPoint(index, *static_cast<QPoint*>(point));
}
void QPolygon_SetPoint(void* ptr, int index, int x, int y)
{
static_cast<QPolygon*>(ptr)->setPoint(index, x, y);
}
void QPolygon_SetPoints(void* ptr, int nPoints, int points)
{
static_cast<QPolygon*>(ptr)->setPoints(nPoints, const_cast<const int*>(&points));
}
void QPolygon_Swap(void* ptr, void* other)
{
static_cast<QPolygon*>(ptr)->swap(*static_cast<QPolygon*>(other));
}
void QPolygon_Translate2(void* ptr, void* offset)
{
static_cast<QPolygon*>(ptr)->translate(*static_cast<QPoint*>(offset));
}
void QPolygon_Translate(void* ptr, int dx, int dy)
{
static_cast<QPolygon*>(ptr)->translate(dx, dy);
}
void QPolygon_DestroyQPolygon(void* ptr)
{
static_cast<QPolygon*>(ptr)->~QPolygon();
}
void* QPolygon_Point2(void* ptr, int index)
{
return ({ QPoint tmpValue = static_cast<QPolygon*>(ptr)->point(index); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QPolygon_Intersected(void* ptr, void* r)
{
return new QPolygon(static_cast<QPolygon*>(ptr)->intersected(*static_cast<QPolygon*>(r)));
}
void* QPolygon_Subtracted(void* ptr, void* r)
{
return new QPolygon(static_cast<QPolygon*>(ptr)->subtracted(*static_cast<QPolygon*>(r)));
}
void* QPolygon_Translated2(void* ptr, void* offset)
{
return new QPolygon(static_cast<QPolygon*>(ptr)->translated(*static_cast<QPoint*>(offset)));
}
void* QPolygon_Translated(void* ptr, int dx, int dy)
{
return new QPolygon(static_cast<QPolygon*>(ptr)->translated(dx, dy));
}
void* QPolygon_United(void* ptr, void* r)
{
return new QPolygon(static_cast<QPolygon*>(ptr)->united(*static_cast<QPolygon*>(r)));
}
void* QPolygon_BoundingRect(void* ptr)
{
return ({ QRect tmpValue = static_cast<QPolygon*>(ptr)->boundingRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
char QPolygon_ContainsPoint(void* ptr, void* point, long long fillRule)
{
return static_cast<QPolygon*>(ptr)->containsPoint(*static_cast<QPoint*>(point), static_cast<Qt::FillRule>(fillRule));
}
char QPolygon_Intersects(void* ptr, void* p)
{
return static_cast<QPolygon*>(ptr)->intersects(*static_cast<QPolygon*>(p));
}
void QPolygon_Point(void* ptr, int index, int x, int y)
{
static_cast<QPolygon*>(ptr)->point(index, &x, &y);
}
void* QPolygon___QPolygon_v_atList4(void* ptr, int i)
{
return ({ QPoint tmpValue = ({QPoint tmp = static_cast<QVector<QPoint>*>(ptr)->at(i); if (i == static_cast<QVector<QPoint>*>(ptr)->size()-1) { static_cast<QVector<QPoint>*>(ptr)->~QVector(); free(ptr); }; tmp; }); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void QPolygon___QPolygon_v_setList4(void* ptr, void* i)
{
static_cast<QVector<QPoint>*>(ptr)->append(*static_cast<QPoint*>(i));
}
void* QPolygon___QPolygon_v_newList4(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QPoint>();
}
void* QPolygon___QPolygon_points_atList3(void* ptr, int i)
{
return ({ QPoint tmpValue = ({QPoint tmp = static_cast<QVector<QPoint>*>(ptr)->at(i); if (i == static_cast<QVector<QPoint>*>(ptr)->size()-1) { static_cast<QVector<QPoint>*>(ptr)->~QVector(); free(ptr); }; tmp; }); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void QPolygon___QPolygon_points_setList3(void* ptr, void* i)
{
static_cast<QVector<QPoint>*>(ptr)->append(*static_cast<QPoint*>(i));
}
void* QPolygon___QPolygon_points_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QPoint>();
}
void* QPolygon___QVector_other_atList5(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPolygon___QVector_other_setList5(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPolygon___QVector_other_newList5(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPolygon___QVector_other_atList4(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPolygon___QVector_other_setList4(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPolygon___QVector_other_newList4(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPolygon___fill_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPolygon___fill_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPolygon___fill_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPolygon___fromList_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPolygon___fromList_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPolygon___fromList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPolygon___fromList_list_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPolygon___fromList_list_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPolygon___fromList_list_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPolygon___fromStdVector_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPolygon___fromStdVector_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPolygon___fromStdVector_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPolygon___append_value_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPolygon___append_value_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPolygon___append_value_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPolygon___swap_other_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPolygon___swap_other_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPolygon___swap_other_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPolygon___toList_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPolygon___toList_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPolygon___toList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPolygon___mid_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPolygon___mid_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPolygon___mid_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPolygonF_NewQPolygonF()
{
return new QPolygonF();
}
void* QPolygonF_NewQPolygonF8(void* other)
{
return new QPolygonF(*static_cast<QPolygonF*>(other));
}
void* QPolygonF_NewQPolygonF4(void* v)
{
return new QPolygonF(({ QVector<QPointF>* tmpP = static_cast<QVector<QPointF>*>(v); QVector<QPointF> tmpV = *tmpP; tmpP->~QVector(); free(tmpP); tmpV; }));
}
void* QPolygonF_NewQPolygonF6(void* polygon)
{
return new QPolygonF(*static_cast<QPolygon*>(polygon));
}
void* QPolygonF_NewQPolygonF7(void* polygon)
{
return new QPolygonF(*static_cast<QPolygonF*>(polygon));
}
void* QPolygonF_NewQPolygonF5(void* rectangle)
{
return new QPolygonF(*static_cast<QRectF*>(rectangle));
}
void* QPolygonF_NewQPolygonF3(void* points)
{
return new QPolygonF(*static_cast<QVector<QPointF>*>(points));
}
void* QPolygonF_NewQPolygonF2(int size)
{
return new QPolygonF(size);
}
void QPolygonF_Swap(void* ptr, void* other)
{
static_cast<QPolygonF*>(ptr)->swap(*static_cast<QPolygonF*>(other));
}
void QPolygonF_Translate(void* ptr, void* offset)
{
static_cast<QPolygonF*>(ptr)->translate(*static_cast<QPointF*>(offset));
}
void QPolygonF_Translate2(void* ptr, double dx, double dy)
{
static_cast<QPolygonF*>(ptr)->translate(dx, dy);
}
void QPolygonF_DestroyQPolygonF(void* ptr)
{
static_cast<QPolygonF*>(ptr)->~QPolygonF();
}
void* QPolygonF_ToPolygon(void* ptr)
{
return new QPolygon(static_cast<QPolygonF*>(ptr)->toPolygon());
}
void* QPolygonF_Intersected(void* ptr, void* r)
{
return new QPolygonF(static_cast<QPolygonF*>(ptr)->intersected(*static_cast<QPolygonF*>(r)));
}
void* QPolygonF_Subtracted(void* ptr, void* r)
{
return new QPolygonF(static_cast<QPolygonF*>(ptr)->subtracted(*static_cast<QPolygonF*>(r)));
}
void* QPolygonF_Translated(void* ptr, void* offset)
{
return new QPolygonF(static_cast<QPolygonF*>(ptr)->translated(*static_cast<QPointF*>(offset)));
}
void* QPolygonF_Translated2(void* ptr, double dx, double dy)
{
return new QPolygonF(static_cast<QPolygonF*>(ptr)->translated(dx, dy));
}
void* QPolygonF_United(void* ptr, void* r)
{
return new QPolygonF(static_cast<QPolygonF*>(ptr)->united(*static_cast<QPolygonF*>(r)));
}
void* QPolygonF_BoundingRect(void* ptr)
{
return ({ QRectF tmpValue = static_cast<QPolygonF*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
char QPolygonF_ContainsPoint(void* ptr, void* point, long long fillRule)
{
return static_cast<QPolygonF*>(ptr)->containsPoint(*static_cast<QPointF*>(point), static_cast<Qt::FillRule>(fillRule));
}
char QPolygonF_Intersects(void* ptr, void* p)
{
return static_cast<QPolygonF*>(ptr)->intersects(*static_cast<QPolygonF*>(p));
}
char QPolygonF_IsClosed(void* ptr)
{
return static_cast<QPolygonF*>(ptr)->isClosed();
}
void* QPolygonF___QPolygonF_v_atList4(void* ptr, int i)
{
return ({ QPointF tmpValue = ({QPointF tmp = static_cast<QVector<QPointF>*>(ptr)->at(i); if (i == static_cast<QVector<QPointF>*>(ptr)->size()-1) { static_cast<QVector<QPointF>*>(ptr)->~QVector(); free(ptr); }; tmp; }); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QPolygonF___QPolygonF_v_setList4(void* ptr, void* i)
{
static_cast<QVector<QPointF>*>(ptr)->append(*static_cast<QPointF*>(i));
}
void* QPolygonF___QPolygonF_v_newList4(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QPointF>();
}
void* QPolygonF___QPolygonF_points_atList3(void* ptr, int i)
{
return ({ QPointF tmpValue = ({QPointF tmp = static_cast<QVector<QPointF>*>(ptr)->at(i); if (i == static_cast<QVector<QPointF>*>(ptr)->size()-1) { static_cast<QVector<QPointF>*>(ptr)->~QVector(); free(ptr); }; tmp; }); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QPolygonF___QPolygonF_points_setList3(void* ptr, void* i)
{
static_cast<QVector<QPointF>*>(ptr)->append(*static_cast<QPointF*>(i));
}
void* QPolygonF___QPolygonF_points_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QPointF>();
}
void* QPolygonF___QVector_other_atList5(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPolygonF___QVector_other_setList5(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPolygonF___QVector_other_newList5(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPolygonF___QVector_other_atList4(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPolygonF___QVector_other_setList4(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPolygonF___QVector_other_newList4(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPolygonF___fill_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPolygonF___fill_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPolygonF___fill_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPolygonF___fromList_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPolygonF___fromList_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPolygonF___fromList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPolygonF___fromList_list_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPolygonF___fromList_list_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPolygonF___fromList_list_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPolygonF___fromStdVector_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPolygonF___fromStdVector_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPolygonF___fromStdVector_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPolygonF___append_value_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPolygonF___append_value_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPolygonF___append_value_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPolygonF___swap_other_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPolygonF___swap_other_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPolygonF___swap_other_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPolygonF___toList_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPolygonF___toList_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPolygonF___toList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QPolygonF___mid_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPolygonF___mid_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QPolygonF___mid_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QQuaternion_QQuaternion_FromAxes(void* xAxis, void* yAxis, void* zAxis)
{
return new QQuaternion(QQuaternion::fromAxes(*static_cast<QVector3D*>(xAxis), *static_cast<QVector3D*>(yAxis), *static_cast<QVector3D*>(zAxis)));
}
void* QQuaternion_QQuaternion_FromAxisAndAngle(void* axis, float angle)
{
return new QQuaternion(QQuaternion::fromAxisAndAngle(*static_cast<QVector3D*>(axis), angle));
}
void* QQuaternion_QQuaternion_FromAxisAndAngle2(float x, float y, float z, float angle)
{
return new QQuaternion(QQuaternion::fromAxisAndAngle(x, y, z, angle));
}
void* QQuaternion_QQuaternion_FromDirection(void* direction, void* up)
{
return new QQuaternion(QQuaternion::fromDirection(*static_cast<QVector3D*>(direction), *static_cast<QVector3D*>(up)));
}
void* QQuaternion_QQuaternion_FromEulerAngles2(void* eulerAngles)
{
return new QQuaternion(QQuaternion::fromEulerAngles(*static_cast<QVector3D*>(eulerAngles)));
}
void* QQuaternion_QQuaternion_FromEulerAngles(float pitch, float yaw, float roll)
{
return new QQuaternion(QQuaternion::fromEulerAngles(pitch, yaw, roll));
}
void* QQuaternion_QQuaternion_Nlerp(void* q1, void* q2, float t)
{
return new QQuaternion(QQuaternion::nlerp(*static_cast<QQuaternion*>(q1), *static_cast<QQuaternion*>(q2), t));
}
void* QQuaternion_QQuaternion_RotationTo(void* from, void* to)
{
return new QQuaternion(QQuaternion::rotationTo(*static_cast<QVector3D*>(from), *static_cast<QVector3D*>(to)));
}
void* QQuaternion_QQuaternion_Slerp(void* q1, void* q2, float t)
{
return new QQuaternion(QQuaternion::slerp(*static_cast<QQuaternion*>(q1), *static_cast<QQuaternion*>(q2), t));
}
void* QQuaternion_NewQQuaternion()
{
return new QQuaternion();
}
void* QQuaternion_NewQQuaternion5(void* vector)
{
return new QQuaternion(*static_cast<QVector4D*>(vector));
}
void* QQuaternion_NewQQuaternion4(float scalar, void* vector)
{
return new QQuaternion(scalar, *static_cast<QVector3D*>(vector));
}
void* QQuaternion_NewQQuaternion3(float scalar, float xpos, float ypos, float zpos)
{
return new QQuaternion(scalar, xpos, ypos, zpos);
}
float QQuaternion_QQuaternion_DotProduct(void* q1, void* q2)
{
return QQuaternion::dotProduct(*static_cast<QQuaternion*>(q1), *static_cast<QQuaternion*>(q2));
}
void QQuaternion_Normalize(void* ptr)
{
static_cast<QQuaternion*>(ptr)->normalize();
}
void QQuaternion_SetScalar(void* ptr, float scalar)
{
static_cast<QQuaternion*>(ptr)->setScalar(scalar);
}
void QQuaternion_SetVector(void* ptr, void* vector)
{
static_cast<QQuaternion*>(ptr)->setVector(*static_cast<QVector3D*>(vector));
}
void QQuaternion_SetVector2(void* ptr, float x, float y, float z)
{
static_cast<QQuaternion*>(ptr)->setVector(x, y, z);
}
void QQuaternion_SetX(void* ptr, float x)
{
static_cast<QQuaternion*>(ptr)->setX(x);
}
void QQuaternion_SetY(void* ptr, float y)
{
static_cast<QQuaternion*>(ptr)->setY(y);
}
void QQuaternion_SetZ(void* ptr, float z)
{
static_cast<QQuaternion*>(ptr)->setZ(z);
}
void* QQuaternion_Conjugated(void* ptr)
{
return new QQuaternion(static_cast<QQuaternion*>(ptr)->conjugated());
}
void* QQuaternion_Inverted(void* ptr)
{
return new QQuaternion(static_cast<QQuaternion*>(ptr)->inverted());
}
void* QQuaternion_Normalized(void* ptr)
{
return new QQuaternion(static_cast<QQuaternion*>(ptr)->normalized());
}
void* QQuaternion_RotatedVector(void* ptr, void* vector)
{
return new QVector3D(static_cast<QQuaternion*>(ptr)->rotatedVector(*static_cast<QVector3D*>(vector)));
}
void* QQuaternion_ToEulerAngles(void* ptr)
{
return new QVector3D(static_cast<QQuaternion*>(ptr)->toEulerAngles());
}
void* QQuaternion_Vector(void* ptr)
{
return new QVector3D(static_cast<QQuaternion*>(ptr)->vector());
}
void* QQuaternion_ToVector4D(void* ptr)
{
return new QVector4D(static_cast<QQuaternion*>(ptr)->toVector4D());
}
char QQuaternion_IsIdentity(void* ptr)
{
return static_cast<QQuaternion*>(ptr)->isIdentity();
}
char QQuaternion_IsNull(void* ptr)
{
return static_cast<QQuaternion*>(ptr)->isNull();
}
float QQuaternion_Length(void* ptr)
{
return static_cast<QQuaternion*>(ptr)->length();
}
float QQuaternion_LengthSquared(void* ptr)
{
return static_cast<QQuaternion*>(ptr)->lengthSquared();
}
float QQuaternion_Scalar(void* ptr)
{
return static_cast<QQuaternion*>(ptr)->scalar();
}
float QQuaternion_X(void* ptr)
{
return static_cast<QQuaternion*>(ptr)->x();
}
float QQuaternion_Y(void* ptr)
{
return static_cast<QQuaternion*>(ptr)->y();
}
float QQuaternion_Z(void* ptr)
{
return static_cast<QQuaternion*>(ptr)->z();
}
void QQuaternion_GetAxes(void* ptr, void* xAxis, void* yAxis, void* zAxis)
{
static_cast<QQuaternion*>(ptr)->getAxes(static_cast<QVector3D*>(xAxis), static_cast<QVector3D*>(yAxis), static_cast<QVector3D*>(zAxis));
}
void QQuaternion_GetAxisAndAngle2(void* ptr, void* axis, float angle)
{
static_cast<QQuaternion*>(ptr)->getAxisAndAngle(static_cast<QVector3D*>(axis), &angle);
}
void QQuaternion_GetAxisAndAngle(void* ptr, float x, float y, float z, float angle)
{
static_cast<QQuaternion*>(ptr)->getAxisAndAngle(&x, &y, &z, &angle);
}
void QQuaternion_GetEulerAngles(void* ptr, float pitch, float yaw, float roll)
{
static_cast<QQuaternion*>(ptr)->getEulerAngles(&pitch, &yaw, &roll);
}
void* QRadialGradient_NewQRadialGradient()
{
return new QRadialGradient();
}
void* QRadialGradient_NewQRadialGradient6(void* center, double centerRadius, void* focalPoint, double focalRadius)
{
return new QRadialGradient(*static_cast<QPointF*>(center), centerRadius, *static_cast<QPointF*>(focalPoint), focalRadius);
}
void* QRadialGradient_NewQRadialGradient4(void* center, double radius)
{
return new QRadialGradient(*static_cast<QPointF*>(center), radius);
}
void* QRadialGradient_NewQRadialGradient2(void* center, double radius, void* focalPoint)
{
return new QRadialGradient(*static_cast<QPointF*>(center), radius, *static_cast<QPointF*>(focalPoint));
}
void* QRadialGradient_NewQRadialGradient7(double cx, double cy, double centerRadius, double fx, double fy, double focalRadius)
{
return new QRadialGradient(cx, cy, centerRadius, fx, fy, focalRadius);
}
void* QRadialGradient_NewQRadialGradient5(double cx, double cy, double radius)
{
return new QRadialGradient(cx, cy, radius);
}
void* QRadialGradient_NewQRadialGradient3(double cx, double cy, double radius, double fx, double fy)
{
return new QRadialGradient(cx, cy, radius, fx, fy);
}
void QRadialGradient_SetCenter(void* ptr, void* center)
{
static_cast<QRadialGradient*>(ptr)->setCenter(*static_cast<QPointF*>(center));
}
void QRadialGradient_SetCenter2(void* ptr, double x, double y)
{
static_cast<QRadialGradient*>(ptr)->setCenter(x, y);
}
void QRadialGradient_SetCenterRadius(void* ptr, double radius)
{
static_cast<QRadialGradient*>(ptr)->setCenterRadius(radius);
}
void QRadialGradient_SetFocalPoint(void* ptr, void* focalPoint)
{
static_cast<QRadialGradient*>(ptr)->setFocalPoint(*static_cast<QPointF*>(focalPoint));
}
void QRadialGradient_SetFocalPoint2(void* ptr, double x, double y)
{
static_cast<QRadialGradient*>(ptr)->setFocalPoint(x, y);
}
void QRadialGradient_SetFocalRadius(void* ptr, double radius)
{
static_cast<QRadialGradient*>(ptr)->setFocalRadius(radius);
}
void QRadialGradient_SetRadius(void* ptr, double radius)
{
static_cast<QRadialGradient*>(ptr)->setRadius(radius);
}
void* QRadialGradient_Center(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QRadialGradient*>(ptr)->center(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void* QRadialGradient_FocalPoint(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QRadialGradient*>(ptr)->focalPoint(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
double QRadialGradient_CenterRadius(void* ptr)
{
return static_cast<QRadialGradient*>(ptr)->centerRadius();
}
double QRadialGradient_FocalRadius(void* ptr)
{
return static_cast<QRadialGradient*>(ptr)->focalRadius();
}
double QRadialGradient_Radius(void* ptr)
{
return static_cast<QRadialGradient*>(ptr)->radius();
}
class MyQRasterWindow: public QRasterWindow
{
public:
MyQRasterWindow(QWindow *parent = Q_NULLPTR) : QRasterWindow(parent) {QRasterWindow_QRasterWindow_QRegisterMetaType();};
~MyQRasterWindow() { callbackQRasterWindow_DestroyQRasterWindow(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWindow_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void paintEvent(QPaintEvent * event) { callbackQPaintDeviceWindow_PaintEvent(this, event); };
void update() { callbackQPaintDeviceWindow_Update3(this); };
bool close() { return callbackQWindow_Close(this) != 0; };
bool event(QEvent * ev) { return callbackQWindow_Event(this, ev) != 0; };
void Signal_ActiveChanged() { callbackQWindow_ActiveChanged(this); };
void alert(int msec) { callbackQWindow_Alert(this, msec); };
void Signal_ContentOrientationChanged(Qt::ScreenOrientation orientation) { callbackQWindow_ContentOrientationChanged(this, orientation); };
void exposeEvent(QExposeEvent * ev) { callbackQWindow_ExposeEvent(this, ev); };
void focusInEvent(QFocusEvent * ev) { callbackQWindow_FocusInEvent(this, ev); };
void Signal_FocusObjectChanged(QObject * object) { callbackQWindow_FocusObjectChanged(this, object); };
void focusOutEvent(QFocusEvent * ev) { callbackQWindow_FocusOutEvent(this, ev); };
void Signal_HeightChanged(int arg) { callbackQWindow_HeightChanged(this, arg); };
void hide() { callbackQWindow_Hide(this); };
void hideEvent(QHideEvent * ev) { callbackQWindow_HideEvent(this, ev); };
void keyPressEvent(QKeyEvent * ev) { callbackQWindow_KeyPressEvent(this, ev); };
void keyReleaseEvent(QKeyEvent * ev) { callbackQWindow_KeyReleaseEvent(this, ev); };
void lower() { callbackQWindow_Lower(this); };
void Signal_MaximumHeightChanged(int arg) { callbackQWindow_MaximumHeightChanged(this, arg); };
void Signal_MaximumWidthChanged(int arg) { callbackQWindow_MaximumWidthChanged(this, arg); };
void Signal_MinimumHeightChanged(int arg) { callbackQWindow_MinimumHeightChanged(this, arg); };
void Signal_MinimumWidthChanged(int arg) { callbackQWindow_MinimumWidthChanged(this, arg); };
void Signal_ModalityChanged(Qt::WindowModality modality) { callbackQWindow_ModalityChanged(this, modality); };
void mouseDoubleClickEvent(QMouseEvent * ev) { callbackQWindow_MouseDoubleClickEvent(this, ev); };
void mouseMoveEvent(QMouseEvent * ev) { callbackQWindow_MouseMoveEvent(this, ev); };
void mousePressEvent(QMouseEvent * ev) { callbackQWindow_MousePressEvent(this, ev); };
void mouseReleaseEvent(QMouseEvent * ev) { callbackQWindow_MouseReleaseEvent(this, ev); };
void moveEvent(QMoveEvent * ev) { callbackQWindow_MoveEvent(this, ev); };
void Signal_OpacityChanged(qreal opacity) { callbackQWindow_OpacityChanged(this, opacity); };
void raise() { callbackQWindow_Raise(this); };
void requestActivate() { callbackQWindow_RequestActivate(this); };
void requestUpdate() { callbackQWindow_RequestUpdate(this); };
void resizeEvent(QResizeEvent * ev) { callbackQWindow_ResizeEvent(this, ev); };
void Signal_ScreenChanged(QScreen * screen) { callbackQWindow_ScreenChanged(this, screen); };
void setGeometry(const QRect & rect) { callbackQWindow_SetGeometry2(this, const_cast<QRect*>(&rect)); };
void setGeometry(int posx, int posy, int w, int h) { callbackQWindow_SetGeometry(this, posx, posy, w, h); };
void setHeight(int arg) { callbackQWindow_SetHeight(this, arg); };
void setMaximumHeight(int h) { callbackQWindow_SetMaximumHeight(this, h); };
void setMaximumWidth(int w) { callbackQWindow_SetMaximumWidth(this, w); };
void setMinimumHeight(int h) { callbackQWindow_SetMinimumHeight(this, h); };
void setMinimumWidth(int w) { callbackQWindow_SetMinimumWidth(this, w); };
void setTitle(const QString & vqs) { QByteArray tda39a3 = vqs.toUtf8(); QtGui_PackedString vqsPacked = { const_cast<char*>(tda39a3.prepend("WHITESPACE").constData()+10), tda39a3.size()-10 };callbackQWindow_SetTitle(this, vqsPacked); };
void setVisible(bool visible) { callbackQWindow_SetVisible(this, visible); };
void setWidth(int arg) { callbackQWindow_SetWidth(this, arg); };
void setX(int arg) { callbackQWindow_SetX(this, arg); };
void setY(int arg) { callbackQWindow_SetY(this, arg); };
void show() { callbackQWindow_Show(this); };
void showEvent(QShowEvent * ev) { callbackQWindow_ShowEvent(this, ev); };
void showFullScreen() { callbackQWindow_ShowFullScreen(this); };
void showMaximized() { callbackQWindow_ShowMaximized(this); };
void showMinimized() { callbackQWindow_ShowMinimized(this); };
void showNormal() { callbackQWindow_ShowNormal(this); };
void tabletEvent(QTabletEvent * ev) { callbackQWindow_TabletEvent(this, ev); };
void touchEvent(QTouchEvent * ev) { callbackQWindow_TouchEvent(this, ev); };
void Signal_VisibilityChanged(QWindow::Visibility visibility) { callbackQWindow_VisibilityChanged(this, visibility); };
void Signal_VisibleChanged(bool arg) { callbackQWindow_VisibleChanged(this, arg); };
void wheelEvent(QWheelEvent * ev) { callbackQWindow_WheelEvent(this, ev); };
void Signal_WidthChanged(int arg) { callbackQWindow_WidthChanged(this, arg); };
void Signal_WindowStateChanged(Qt::WindowState windowState) { callbackQWindow_WindowStateChanged(this, windowState); };
void Signal_WindowTitleChanged(const QString & title) { QByteArray t3c6de1 = title.toUtf8(); QtGui_PackedString titlePacked = { const_cast<char*>(t3c6de1.prepend("WHITESPACE").constData()+10), t3c6de1.size()-10 };callbackQWindow_WindowTitleChanged(this, titlePacked); };
void Signal_XChanged(int arg) { callbackQWindow_XChanged(this, arg); };
void Signal_YChanged(int arg) { callbackQWindow_YChanged(this, arg); };
QObject * focusObject() const { return static_cast<QObject*>(callbackQWindow_FocusObject(const_cast<void*>(static_cast<const void*>(this)))); };
QSize size() const { return *static_cast<QSize*>(callbackQWindow_Size(const_cast<void*>(static_cast<const void*>(this)))); };
QSurface::SurfaceType surfaceType() const { return static_cast<QSurface::SurfaceType>(callbackQWindow_SurfaceType(const_cast<void*>(static_cast<const void*>(this)))); };
QSurfaceFormat format() const { return *static_cast<QSurfaceFormat*>(callbackQWindow_Format(const_cast<void*>(static_cast<const void*>(this)))); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQWindow_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQWindow_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQWindow_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQWindow_CustomEvent(this, event); };
void deleteLater() { callbackQWindow_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQWindow_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQWindow_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQWindow_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQWindow_TimerEvent(this, event); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQPaintDeviceWindow_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPaintDevice_Metric(const_cast<void*>(static_cast<const void*>(this)), metric); };
};
Q_DECLARE_METATYPE(MyQRasterWindow*)
int QRasterWindow_QRasterWindow_QRegisterMetaType(){qRegisterMetaType<QRasterWindow*>(); return qRegisterMetaType<MyQRasterWindow*>();}
void* QRasterWindow_NewQRasterWindow(void* parent)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQRasterWindow(static_cast<QPaintDeviceWindow*>(parent));
} else {
return new MyQRasterWindow(static_cast<QWindow*>(parent));
}
}
void QRasterWindow_DestroyQRasterWindow(void* ptr)
{
static_cast<QRasterWindow*>(ptr)->~QRasterWindow();
}
void QRasterWindow_DestroyQRasterWindowDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QRawFont_QRawFont_FromFont(void* font, long long writingSystem)
{
return new QRawFont(QRawFont::fromFont(*static_cast<QFont*>(font), static_cast<QFontDatabase::WritingSystem>(writingSystem)));
}
void* QRawFont_NewQRawFont()
{
return new QRawFont();
}
void* QRawFont_NewQRawFont3(void* fontData, double pixelSize, long long hintingPreference)
{
return new QRawFont(*static_cast<QByteArray*>(fontData), pixelSize, static_cast<QFont::HintingPreference>(hintingPreference));
}
void* QRawFont_NewQRawFont4(void* other)
{
return new QRawFont(*static_cast<QRawFont*>(other));
}
void* QRawFont_NewQRawFont2(struct QtGui_PackedString fileName, double pixelSize, long long hintingPreference)
{
return new QRawFont(QString::fromUtf8(fileName.data, fileName.len), pixelSize, static_cast<QFont::HintingPreference>(hintingPreference));
}
void QRawFont_LoadFromData(void* ptr, void* fontData, double pixelSize, long long hintingPreference)
{
static_cast<QRawFont*>(ptr)->loadFromData(*static_cast<QByteArray*>(fontData), pixelSize, static_cast<QFont::HintingPreference>(hintingPreference));
}
void QRawFont_LoadFromFile(void* ptr, struct QtGui_PackedString fileName, double pixelSize, long long hintingPreference)
{
static_cast<QRawFont*>(ptr)->loadFromFile(QString::fromUtf8(fileName.data, fileName.len), pixelSize, static_cast<QFont::HintingPreference>(hintingPreference));
}
void QRawFont_SetPixelSize(void* ptr, double pixelSize)
{
static_cast<QRawFont*>(ptr)->setPixelSize(pixelSize);
}
void QRawFont_Swap(void* ptr, void* other)
{
static_cast<QRawFont*>(ptr)->swap(*static_cast<QRawFont*>(other));
}
void QRawFont_DestroyQRawFont(void* ptr)
{
static_cast<QRawFont*>(ptr)->~QRawFont();
}
void* QRawFont_FontTable(void* ptr, char* tagName)
{
return new QByteArray(static_cast<QRawFont*>(ptr)->fontTable(const_cast<const char*>(tagName)));
}
long long QRawFont_HintingPreference(void* ptr)
{
return static_cast<QRawFont*>(ptr)->hintingPreference();
}
long long QRawFont_Style(void* ptr)
{
return static_cast<QRawFont*>(ptr)->style();
}
void* QRawFont_AlphaMapForGlyph(void* ptr, unsigned int glyphIndex, long long antialiasingType, void* transform)
{
return new QImage(static_cast<QRawFont*>(ptr)->alphaMapForGlyph(glyphIndex, static_cast<QRawFont::AntialiasingType>(antialiasingType), *static_cast<QTransform*>(transform)));
}
struct QtGui_PackedList QRawFont_SupportedWritingSystems(void* ptr)
{
return ({ QList<QFontDatabase::WritingSystem>* tmpValue = new QList<QFontDatabase::WritingSystem>(static_cast<QRawFont*>(ptr)->supportedWritingSystems()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QRawFont_PathForGlyph(void* ptr, unsigned int glyphIndex)
{
return new QPainterPath(static_cast<QRawFont*>(ptr)->pathForGlyph(glyphIndex));
}
void* QRawFont_BoundingRect(void* ptr, unsigned int glyphIndex)
{
return ({ QRectF tmpValue = static_cast<QRawFont*>(ptr)->boundingRect(glyphIndex); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
struct QtGui_PackedString QRawFont_FamilyName(void* ptr)
{
return ({ QByteArray t8c920d = static_cast<QRawFont*>(ptr)->familyName().toUtf8(); QtGui_PackedString { const_cast<char*>(t8c920d.prepend("WHITESPACE").constData()+10), t8c920d.size()-10 }; });
}
struct QtGui_PackedString QRawFont_StyleName(void* ptr)
{
return ({ QByteArray t6b9c52 = static_cast<QRawFont*>(ptr)->styleName().toUtf8(); QtGui_PackedString { const_cast<char*>(t6b9c52.prepend("WHITESPACE").constData()+10), t6b9c52.size()-10 }; });
}
struct QtGui_PackedList QRawFont_AdvancesForGlyphIndexes2(void* ptr, void* glyphIndexes)
{
return ({ QVector<QPointF>* tmpValue = new QVector<QPointF>(static_cast<QRawFont*>(ptr)->advancesForGlyphIndexes(*static_cast<QVector<quint32>*>(glyphIndexes))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedList QRawFont_AdvancesForGlyphIndexes(void* ptr, void* glyphIndexes, long long layoutFlags)
{
return ({ QVector<QPointF>* tmpValue = new QVector<QPointF>(static_cast<QRawFont*>(ptr)->advancesForGlyphIndexes(*static_cast<QVector<quint32>*>(glyphIndexes), static_cast<QRawFont::LayoutFlag>(layoutFlags))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedList QRawFont_GlyphIndexesForString(void* ptr, struct QtGui_PackedString text)
{
return ({ QVector<quint32>* tmpValue = new QVector<quint32>(static_cast<QRawFont*>(ptr)->glyphIndexesForString(QString::fromUtf8(text.data, text.len))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
char QRawFont_AdvancesForGlyphIndexes3(void* ptr, unsigned int glyphIndexes, void* advances, int numGlyphs)
{
return static_cast<QRawFont*>(ptr)->advancesForGlyphIndexes(const_cast<const quint32*>(&glyphIndexes), static_cast<QPointF*>(advances), numGlyphs);
}
char QRawFont_AdvancesForGlyphIndexes4(void* ptr, unsigned int glyphIndexes, void* advances, int numGlyphs, long long layoutFlags)
{
return static_cast<QRawFont*>(ptr)->advancesForGlyphIndexes(const_cast<const quint32*>(&glyphIndexes), static_cast<QPointF*>(advances), numGlyphs, static_cast<QRawFont::LayoutFlag>(layoutFlags));
}
char QRawFont_GlyphIndexesForChars(void* ptr, void* chars, int numChars, unsigned int glyphIndexes, int numGlyphs)
{
return static_cast<QRawFont*>(ptr)->glyphIndexesForChars(static_cast<QChar*>(chars), numChars, &glyphIndexes, &numGlyphs);
}
char QRawFont_IsValid(void* ptr)
{
return static_cast<QRawFont*>(ptr)->isValid();
}
char QRawFont_SupportsCharacter(void* ptr, void* character)
{
return static_cast<QRawFont*>(ptr)->supportsCharacter(*static_cast<QChar*>(character));
}
char QRawFont_SupportsCharacter2(void* ptr, unsigned int ucs4)
{
return static_cast<QRawFont*>(ptr)->supportsCharacter(ucs4);
}
int QRawFont_Weight(void* ptr)
{
return static_cast<QRawFont*>(ptr)->weight();
}
double QRawFont_Ascent(void* ptr)
{
return static_cast<QRawFont*>(ptr)->ascent();
}
double QRawFont_AverageCharWidth(void* ptr)
{
return static_cast<QRawFont*>(ptr)->averageCharWidth();
}
double QRawFont_CapHeight(void* ptr)
{
return static_cast<QRawFont*>(ptr)->capHeight();
}
double QRawFont_Descent(void* ptr)
{
return static_cast<QRawFont*>(ptr)->descent();
}
double QRawFont_Leading(void* ptr)
{
return static_cast<QRawFont*>(ptr)->leading();
}
double QRawFont_LineThickness(void* ptr)
{
return static_cast<QRawFont*>(ptr)->lineThickness();
}
double QRawFont_MaxCharWidth(void* ptr)
{
return static_cast<QRawFont*>(ptr)->maxCharWidth();
}
double QRawFont_PixelSize(void* ptr)
{
return static_cast<QRawFont*>(ptr)->pixelSize();
}
double QRawFont_UnderlinePosition(void* ptr)
{
return static_cast<QRawFont*>(ptr)->underlinePosition();
}
double QRawFont_UnitsPerEm(void* ptr)
{
return static_cast<QRawFont*>(ptr)->unitsPerEm();
}
double QRawFont_XHeight(void* ptr)
{
return static_cast<QRawFont*>(ptr)->xHeight();
}
long long QRawFont___supportedWritingSystems_atList(void* ptr, int i)
{
return ({QFontDatabase::WritingSystem tmp = static_cast<QList<QFontDatabase::WritingSystem>*>(ptr)->at(i); if (i == static_cast<QList<QFontDatabase::WritingSystem>*>(ptr)->size()-1) { static_cast<QList<QFontDatabase::WritingSystem>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QRawFont___supportedWritingSystems_setList(void* ptr, long long i)
{
static_cast<QList<QFontDatabase::WritingSystem>*>(ptr)->append(static_cast<QFontDatabase::WritingSystem>(i));
}
void* QRawFont___supportedWritingSystems_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QFontDatabase::WritingSystem>();
}
void* QRawFont___advancesForGlyphIndexes_atList2(void* ptr, int i)
{
return ({ QPointF tmpValue = ({QPointF tmp = static_cast<QVector<QPointF>*>(ptr)->at(i); if (i == static_cast<QVector<QPointF>*>(ptr)->size()-1) { static_cast<QVector<QPointF>*>(ptr)->~QVector(); free(ptr); }; tmp; }); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QRawFont___advancesForGlyphIndexes_setList2(void* ptr, void* i)
{
static_cast<QVector<QPointF>*>(ptr)->append(*static_cast<QPointF*>(i));
}
void* QRawFont___advancesForGlyphIndexes_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QPointF>();
}
unsigned int QRawFont___advancesForGlyphIndexes_glyphIndexes_atList2(void* ptr, int i)
{
return ({quint32 tmp = static_cast<QVector<quint32>*>(ptr)->at(i); if (i == static_cast<QVector<quint32>*>(ptr)->size()-1) { static_cast<QVector<quint32>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QRawFont___advancesForGlyphIndexes_glyphIndexes_setList2(void* ptr, unsigned int i)
{
static_cast<QVector<quint32>*>(ptr)->append(i);
}
void* QRawFont___advancesForGlyphIndexes_glyphIndexes_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<quint32>();
}
void* QRawFont___advancesForGlyphIndexes_atList(void* ptr, int i)
{
return ({ QPointF tmpValue = ({QPointF tmp = static_cast<QVector<QPointF>*>(ptr)->at(i); if (i == static_cast<QVector<QPointF>*>(ptr)->size()-1) { static_cast<QVector<QPointF>*>(ptr)->~QVector(); free(ptr); }; tmp; }); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QRawFont___advancesForGlyphIndexes_setList(void* ptr, void* i)
{
static_cast<QVector<QPointF>*>(ptr)->append(*static_cast<QPointF*>(i));
}
void* QRawFont___advancesForGlyphIndexes_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QPointF>();
}
unsigned int QRawFont___advancesForGlyphIndexes_glyphIndexes_atList(void* ptr, int i)
{
return ({quint32 tmp = static_cast<QVector<quint32>*>(ptr)->at(i); if (i == static_cast<QVector<quint32>*>(ptr)->size()-1) { static_cast<QVector<quint32>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QRawFont___advancesForGlyphIndexes_glyphIndexes_setList(void* ptr, unsigned int i)
{
static_cast<QVector<quint32>*>(ptr)->append(i);
}
void* QRawFont___advancesForGlyphIndexes_glyphIndexes_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<quint32>();
}
unsigned int QRawFont___glyphIndexesForString_atList(void* ptr, int i)
{
return ({quint32 tmp = static_cast<QVector<quint32>*>(ptr)->at(i); if (i == static_cast<QVector<quint32>*>(ptr)->size()-1) { static_cast<QVector<quint32>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QRawFont___glyphIndexesForString_setList(void* ptr, unsigned int i)
{
static_cast<QVector<quint32>*>(ptr)->append(i);
}
void* QRawFont___glyphIndexesForString_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<quint32>();
}
class MyQRegExpValidator: public QRegExpValidator
{
public:
MyQRegExpValidator(QObject *parent = Q_NULLPTR) : QRegExpValidator(parent) {QRegExpValidator_QRegExpValidator_QRegisterMetaType();};
MyQRegExpValidator(const QRegExp &rx, QObject *parent = Q_NULLPTR) : QRegExpValidator(rx, parent) {QRegExpValidator_QRegExpValidator_QRegisterMetaType();};
~MyQRegExpValidator() { callbackQRegExpValidator_DestroyQRegExpValidator(this); };
QValidator::State validate(QString & input, int & pos) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };return static_cast<QValidator::State>(callbackQRegExpValidator_Validate(const_cast<void*>(static_cast<const void*>(this)), inputPacked, pos)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQValidator_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_Changed() { callbackQValidator_Changed(this); };
void fixup(QString & input) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };callbackQValidator_Fixup(const_cast<void*>(static_cast<const void*>(this)), inputPacked); };
bool event(QEvent * e) { return callbackQValidator_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQValidator_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQValidator_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQValidator_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQValidator_CustomEvent(this, event); };
void deleteLater() { callbackQValidator_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQValidator_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQValidator_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQValidator_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQValidator_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQRegExpValidator*)
int QRegExpValidator_QRegExpValidator_QRegisterMetaType(){qRegisterMetaType<QRegExpValidator*>(); return qRegisterMetaType<MyQRegExpValidator*>();}
void* QRegExpValidator_NewQRegExpValidator(void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(static_cast<QWindow*>(parent));
} else {
return new MyQRegExpValidator(static_cast<QObject*>(parent));
}
}
void* QRegExpValidator_NewQRegExpValidator2(void* rx, void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(*static_cast<QRegExp*>(rx), static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(*static_cast<QRegExp*>(rx), static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(*static_cast<QRegExp*>(rx), static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(*static_cast<QRegExp*>(rx), static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(*static_cast<QRegExp*>(rx), static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(*static_cast<QRegExp*>(rx), static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(*static_cast<QRegExp*>(rx), static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(*static_cast<QRegExp*>(rx), static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(*static_cast<QRegExp*>(rx), static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(*static_cast<QRegExp*>(rx), static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(*static_cast<QRegExp*>(rx), static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(*static_cast<QRegExp*>(rx), static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(*static_cast<QRegExp*>(rx), static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(*static_cast<QRegExp*>(rx), static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(*static_cast<QRegExp*>(rx), static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQRegExpValidator(*static_cast<QRegExp*>(rx), static_cast<QWindow*>(parent));
} else {
return new MyQRegExpValidator(*static_cast<QRegExp*>(rx), static_cast<QObject*>(parent));
}
}
void QRegExpValidator_SetRegExp(void* ptr, void* rx)
{
static_cast<QRegExpValidator*>(ptr)->setRegExp(*static_cast<QRegExp*>(rx));
}
void QRegExpValidator_DestroyQRegExpValidator(void* ptr)
{
static_cast<QRegExpValidator*>(ptr)->~QRegExpValidator();
}
void QRegExpValidator_DestroyQRegExpValidatorDefault(void* ptr)
{
Q_UNUSED(ptr);
}
long long QRegExpValidator_Validate(void* ptr, struct QtGui_PackedString input, int pos)
{
return static_cast<QRegExpValidator*>(ptr)->validate(*(new QString(QString::fromUtf8(input.data, input.len))), pos);
}
long long QRegExpValidator_ValidateDefault(void* ptr, struct QtGui_PackedString input, int pos)
{
return static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::validate(*(new QString(QString::fromUtf8(input.data, input.len))), pos);
}
void* QRegExpValidator_RegExp(void* ptr)
{
return const_cast<QRegExp*>(&static_cast<QRegExpValidator*>(ptr)->regExp());
}
void* QRegion_NewQRegion()
{
return new QRegion();
}
void* QRegion_NewQRegion6(void* other)
{
return new QRegion(*static_cast<QRegion*>(other));
}
void* QRegion_NewQRegion7(void* bm)
{
return new QRegion(*static_cast<QBitmap*>(bm));
}
void* QRegion_NewQRegion4(void* a, long long fillRule)
{
return new QRegion(*static_cast<QPolygon*>(a), static_cast<Qt::FillRule>(fillRule));
}
void* QRegion_NewQRegion3(void* r, long long t)
{
return new QRegion(*static_cast<QRect*>(r), static_cast<QRegion::RegionType>(t));
}
void* QRegion_NewQRegion5(void* r)
{
return new QRegion(*static_cast<QRegion*>(r));
}
void* QRegion_NewQRegion2(int x, int y, int w, int h, long long t)
{
return new QRegion(x, y, w, h, static_cast<QRegion::RegionType>(t));
}
void QRegion_SetRects(void* ptr, void* rects, int number)
{
static_cast<QRegion*>(ptr)->setRects(static_cast<QRect*>(rects), number);
}
void QRegion_Swap(void* ptr, void* other)
{
static_cast<QRegion*>(ptr)->swap(*static_cast<QRegion*>(other));
}
void QRegion_Translate2(void* ptr, void* point)
{
static_cast<QRegion*>(ptr)->translate(*static_cast<QPoint*>(point));
}
void QRegion_Translate(void* ptr, int dx, int dy)
{
static_cast<QRegion*>(ptr)->translate(dx, dy);
}
void* QRegion_BoundingRect(void* ptr)
{
return ({ QRect tmpValue = static_cast<QRegion*>(ptr)->boundingRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QRegion_Intersected2(void* ptr, void* rect)
{
return new QRegion(static_cast<QRegion*>(ptr)->intersected(*static_cast<QRect*>(rect)));
}
void* QRegion_Intersected(void* ptr, void* r)
{
return new QRegion(static_cast<QRegion*>(ptr)->intersected(*static_cast<QRegion*>(r)));
}
void* QRegion_Subtracted(void* ptr, void* r)
{
return new QRegion(static_cast<QRegion*>(ptr)->subtracted(*static_cast<QRegion*>(r)));
}
void* QRegion_Translated2(void* ptr, void* p)
{
return new QRegion(static_cast<QRegion*>(ptr)->translated(*static_cast<QPoint*>(p)));
}
void* QRegion_Translated(void* ptr, int dx, int dy)
{
return new QRegion(static_cast<QRegion*>(ptr)->translated(dx, dy));
}
void* QRegion_United2(void* ptr, void* rect)
{
return new QRegion(static_cast<QRegion*>(ptr)->united(*static_cast<QRect*>(rect)));
}
void* QRegion_United(void* ptr, void* r)
{
return new QRegion(static_cast<QRegion*>(ptr)->united(*static_cast<QRegion*>(r)));
}
void* QRegion_Xored(void* ptr, void* r)
{
return new QRegion(static_cast<QRegion*>(ptr)->xored(*static_cast<QRegion*>(r)));
}
char QRegion_Contains(void* ptr, void* p)
{
return static_cast<QRegion*>(ptr)->contains(*static_cast<QPoint*>(p));
}
char QRegion_Contains2(void* ptr, void* r)
{
return static_cast<QRegion*>(ptr)->contains(*static_cast<QRect*>(r));
}
char QRegion_Intersects2(void* ptr, void* rect)
{
return static_cast<QRegion*>(ptr)->intersects(*static_cast<QRect*>(rect));
}
char QRegion_Intersects(void* ptr, void* region)
{
return static_cast<QRegion*>(ptr)->intersects(*static_cast<QRegion*>(region));
}
char QRegion_IsEmpty(void* ptr)
{
return static_cast<QRegion*>(ptr)->isEmpty();
}
char QRegion_IsNull(void* ptr)
{
return static_cast<QRegion*>(ptr)->isNull();
}
int QRegion_RectCount(void* ptr)
{
return static_cast<QRegion*>(ptr)->rectCount();
}
void* QRegion___rects_atList(void* ptr, int i)
{
return ({ QRect tmpValue = ({QRect tmp = static_cast<QVector<QRect>*>(ptr)->at(i); if (i == static_cast<QVector<QRect>*>(ptr)->size()-1) { static_cast<QVector<QRect>*>(ptr)->~QVector(); free(ptr); }; tmp; }); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void QRegion___rects_setList(void* ptr, void* i)
{
static_cast<QVector<QRect>*>(ptr)->append(*static_cast<QRect*>(i));
}
void* QRegion___rects_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QRect>();
}
class MyQRegularExpressionValidator: public QRegularExpressionValidator
{
public:
MyQRegularExpressionValidator(QObject *parent = Q_NULLPTR) : QRegularExpressionValidator(parent) {QRegularExpressionValidator_QRegularExpressionValidator_QRegisterMetaType();};
MyQRegularExpressionValidator(const QRegularExpression &re, QObject *parent = Q_NULLPTR) : QRegularExpressionValidator(re, parent) {QRegularExpressionValidator_QRegularExpressionValidator_QRegisterMetaType();};
void Signal_RegularExpressionChanged(const QRegularExpression & re) { callbackQRegularExpressionValidator_RegularExpressionChanged(this, const_cast<QRegularExpression*>(&re)); };
void setRegularExpression(const QRegularExpression & re) { callbackQRegularExpressionValidator_SetRegularExpression(this, const_cast<QRegularExpression*>(&re)); };
~MyQRegularExpressionValidator() { callbackQRegularExpressionValidator_DestroyQRegularExpressionValidator(this); };
QValidator::State validate(QString & input, int & pos) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };return static_cast<QValidator::State>(callbackQRegularExpressionValidator_Validate(const_cast<void*>(static_cast<const void*>(this)), inputPacked, pos)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQValidator_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_Changed() { callbackQValidator_Changed(this); };
void fixup(QString & input) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };callbackQValidator_Fixup(const_cast<void*>(static_cast<const void*>(this)), inputPacked); };
bool event(QEvent * e) { return callbackQValidator_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQValidator_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQValidator_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQValidator_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQValidator_CustomEvent(this, event); };
void deleteLater() { callbackQValidator_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQValidator_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQValidator_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQValidator_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQValidator_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQRegularExpressionValidator*)
int QRegularExpressionValidator_QRegularExpressionValidator_QRegisterMetaType(){qRegisterMetaType<QRegularExpressionValidator*>(); return qRegisterMetaType<MyQRegularExpressionValidator*>();}
void* QRegularExpressionValidator_NewQRegularExpressionValidator(void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(static_cast<QWindow*>(parent));
} else {
return new MyQRegularExpressionValidator(static_cast<QObject*>(parent));
}
}
void* QRegularExpressionValidator_NewQRegularExpressionValidator2(void* re, void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(*static_cast<QRegularExpression*>(re), static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(*static_cast<QRegularExpression*>(re), static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(*static_cast<QRegularExpression*>(re), static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(*static_cast<QRegularExpression*>(re), static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(*static_cast<QRegularExpression*>(re), static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(*static_cast<QRegularExpression*>(re), static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(*static_cast<QRegularExpression*>(re), static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(*static_cast<QRegularExpression*>(re), static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(*static_cast<QRegularExpression*>(re), static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(*static_cast<QRegularExpression*>(re), static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(*static_cast<QRegularExpression*>(re), static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(*static_cast<QRegularExpression*>(re), static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(*static_cast<QRegularExpression*>(re), static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(*static_cast<QRegularExpression*>(re), static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(*static_cast<QRegularExpression*>(re), static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQRegularExpressionValidator(*static_cast<QRegularExpression*>(re), static_cast<QWindow*>(parent));
} else {
return new MyQRegularExpressionValidator(*static_cast<QRegularExpression*>(re), static_cast<QObject*>(parent));
}
}
void QRegularExpressionValidator_ConnectRegularExpressionChanged(void* ptr)
{
QObject::connect(static_cast<QRegularExpressionValidator*>(ptr), static_cast<void (QRegularExpressionValidator::*)(const QRegularExpression &)>(&QRegularExpressionValidator::regularExpressionChanged), static_cast<MyQRegularExpressionValidator*>(ptr), static_cast<void (MyQRegularExpressionValidator::*)(const QRegularExpression &)>(&MyQRegularExpressionValidator::Signal_RegularExpressionChanged));
}
void QRegularExpressionValidator_DisconnectRegularExpressionChanged(void* ptr)
{
QObject::disconnect(static_cast<QRegularExpressionValidator*>(ptr), static_cast<void (QRegularExpressionValidator::*)(const QRegularExpression &)>(&QRegularExpressionValidator::regularExpressionChanged), static_cast<MyQRegularExpressionValidator*>(ptr), static_cast<void (MyQRegularExpressionValidator::*)(const QRegularExpression &)>(&MyQRegularExpressionValidator::Signal_RegularExpressionChanged));
}
void QRegularExpressionValidator_RegularExpressionChanged(void* ptr, void* re)
{
static_cast<QRegularExpressionValidator*>(ptr)->regularExpressionChanged(*static_cast<QRegularExpression*>(re));
}
void QRegularExpressionValidator_SetRegularExpression(void* ptr, void* re)
{
QMetaObject::invokeMethod(static_cast<QRegularExpressionValidator*>(ptr), "setRegularExpression", Q_ARG(const QRegularExpression, *static_cast<QRegularExpression*>(re)));
}
void QRegularExpressionValidator_SetRegularExpressionDefault(void* ptr, void* re)
{
static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::setRegularExpression(*static_cast<QRegularExpression*>(re));
}
void QRegularExpressionValidator_DestroyQRegularExpressionValidator(void* ptr)
{
static_cast<QRegularExpressionValidator*>(ptr)->~QRegularExpressionValidator();
}
void QRegularExpressionValidator_DestroyQRegularExpressionValidatorDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QRegularExpressionValidator_RegularExpression(void* ptr)
{
return new QRegularExpression(static_cast<QRegularExpressionValidator*>(ptr)->regularExpression());
}
long long QRegularExpressionValidator_Validate(void* ptr, struct QtGui_PackedString input, int pos)
{
return static_cast<QRegularExpressionValidator*>(ptr)->validate(*(new QString(QString::fromUtf8(input.data, input.len))), pos);
}
long long QRegularExpressionValidator_ValidateDefault(void* ptr, struct QtGui_PackedString input, int pos)
{
return static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::validate(*(new QString(QString::fromUtf8(input.data, input.len))), pos);
}
class MyQResizeEvent: public QResizeEvent
{
public:
MyQResizeEvent(const QSize &size, const QSize &oldSize) : QResizeEvent(size, oldSize) {};
};
void* QResizeEvent_NewQResizeEvent(void* size, void* oldSize)
{
return new MyQResizeEvent(*static_cast<QSize*>(size), *static_cast<QSize*>(oldSize));
}
void* QResizeEvent_OldSize(void* ptr)
{
return const_cast<QSize*>(&static_cast<QResizeEvent*>(ptr)->oldSize());
}
void* QResizeEvent_Size(void* ptr)
{
return const_cast<QSize*>(&static_cast<QResizeEvent*>(ptr)->size());
}
void* QResizeEvent_Olds(void* ptr)
{
return ({ QSize tmpValue = static_cast<QResizeEvent*>(ptr)->olds; new QSize(tmpValue.width(), tmpValue.height()); });
}
void QResizeEvent_SetOlds(void* ptr, void* vqs)
{
static_cast<QResizeEvent*>(ptr)->olds = *static_cast<QSize*>(vqs);
}
void* QResizeEvent_S(void* ptr)
{
return ({ QSize tmpValue = static_cast<QResizeEvent*>(ptr)->s; new QSize(tmpValue.width(), tmpValue.height()); });
}
void QResizeEvent_SetS(void* ptr, void* vqs)
{
static_cast<QResizeEvent*>(ptr)->s = *static_cast<QSize*>(vqs);
}
void* QRgba64_QRgba64_FromArgb32(unsigned int rgb)
{
return new QRgba64(QRgba64::fromArgb32(rgb));
}
void* QRgba64_QRgba64_FromRgba(char* red, char* green, char* blue, char* alpha)
{
return new QRgba64(QRgba64::fromRgba(*static_cast<quint8*>(static_cast<void*>(red)), *static_cast<quint8*>(static_cast<void*>(green)), *static_cast<quint8*>(static_cast<void*>(blue)), *static_cast<quint8*>(static_cast<void*>(alpha))));
}
void* QRgba64_QRgba64_FromRgba642(unsigned short r, unsigned short g, unsigned short b, unsigned short a)
{
return new QRgba64(QRgba64::fromRgba64(r, g, b, a));
}
void* QRgba64_QRgba64_FromRgba64(unsigned long long c)
{
return new QRgba64(QRgba64::fromRgba64(c));
}
void* QRgba64_NewQRgba64()
{
return new QRgba64();
}
void QRgba64_SetAlpha(void* ptr, unsigned short alpha)
{
static_cast<QRgba64*>(ptr)->setAlpha(alpha);
}
void QRgba64_SetBlue(void* ptr, unsigned short blue)
{
static_cast<QRgba64*>(ptr)->setBlue(blue);
}
void QRgba64_SetGreen(void* ptr, unsigned short green)
{
static_cast<QRgba64*>(ptr)->setGreen(green);
}
void QRgba64_SetRed(void* ptr, unsigned short red)
{
static_cast<QRgba64*>(ptr)->setRed(red);
}
void* QRgba64_Premultiplied(void* ptr)
{
return new QRgba64(static_cast<QRgba64*>(ptr)->premultiplied());
}
void* QRgba64_Unpremultiplied(void* ptr)
{
return new QRgba64(static_cast<QRgba64*>(ptr)->unpremultiplied());
}
char QRgba64_IsOpaque(void* ptr)
{
return static_cast<QRgba64*>(ptr)->isOpaque();
}
char QRgba64_IsTransparent(void* ptr)
{
return static_cast<QRgba64*>(ptr)->isTransparent();
}
unsigned short QRgba64_Alpha(void* ptr)
{
return static_cast<QRgba64*>(ptr)->alpha();
}
unsigned short QRgba64_Blue(void* ptr)
{
return static_cast<QRgba64*>(ptr)->blue();
}
unsigned short QRgba64_Green(void* ptr)
{
return static_cast<QRgba64*>(ptr)->green();
}
unsigned short QRgba64_Red(void* ptr)
{
return static_cast<QRgba64*>(ptr)->red();
}
struct QtGui_PackedString QRgba64_Alpha8(void* ptr)
{
return ({ quint8 pret13de7c = static_cast<QRgba64*>(ptr)->alpha8(); char* t13de7c = static_cast<char*>(static_cast<void*>(&pret13de7c)); QtGui_PackedString { t13de7c, -1 }; });
}
struct QtGui_PackedString QRgba64_Blue8(void* ptr)
{
return ({ quint8 pret2116e7 = static_cast<QRgba64*>(ptr)->blue8(); char* t2116e7 = static_cast<char*>(static_cast<void*>(&pret2116e7)); QtGui_PackedString { t2116e7, -1 }; });
}
struct QtGui_PackedString QRgba64_Green8(void* ptr)
{
return ({ quint8 pret72b7b3 = static_cast<QRgba64*>(ptr)->green8(); char* t72b7b3 = static_cast<char*>(static_cast<void*>(&pret72b7b3)); QtGui_PackedString { t72b7b3, -1 }; });
}
struct QtGui_PackedString QRgba64_Red8(void* ptr)
{
return ({ quint8 pretd7bc71 = static_cast<QRgba64*>(ptr)->red8(); char* td7bc71 = static_cast<char*>(static_cast<void*>(&pretd7bc71)); QtGui_PackedString { td7bc71, -1 }; });
}
unsigned int QRgba64_ToArgb32(void* ptr)
{
return static_cast<QRgba64*>(ptr)->toArgb32();
}
unsigned short QRgba64_ToRgb16(void* ptr)
{
return static_cast<QRgba64*>(ptr)->toRgb16();
}
class MyQScreen: public QScreen
{
public:
void Signal_AvailableGeometryChanged(const QRect & geometry) { callbackQScreen_AvailableGeometryChanged(this, const_cast<QRect*>(&geometry)); };
void Signal_GeometryChanged(const QRect & geometry) { callbackQScreen_GeometryChanged(this, const_cast<QRect*>(&geometry)); };
void Signal_LogicalDotsPerInchChanged(qreal dpi) { callbackQScreen_LogicalDotsPerInchChanged(this, dpi); };
void Signal_OrientationChanged(Qt::ScreenOrientation orientation) { callbackQScreen_OrientationChanged(this, orientation); };
void Signal_PhysicalDotsPerInchChanged(qreal dpi) { callbackQScreen_PhysicalDotsPerInchChanged(this, dpi); };
void Signal_PhysicalSizeChanged(const QSizeF & size) { callbackQScreen_PhysicalSizeChanged(this, const_cast<QSizeF*>(&size)); };
void Signal_PrimaryOrientationChanged(Qt::ScreenOrientation orientation) { callbackQScreen_PrimaryOrientationChanged(this, orientation); };
void Signal_RefreshRateChanged(qreal refreshRate) { callbackQScreen_RefreshRateChanged(this, refreshRate); };
void Signal_VirtualGeometryChanged(const QRect & rect) { callbackQScreen_VirtualGeometryChanged(this, const_cast<QRect*>(&rect)); };
~MyQScreen() { callbackQScreen_DestroyQScreen(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQScreen_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQScreen_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQScreen_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQScreen_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQScreen_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQScreen_CustomEvent(this, event); };
void deleteLater() { callbackQScreen_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQScreen_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQScreen_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQScreen_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQScreen_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQScreen*)
int QScreen_QScreen_QRegisterMetaType(){qRegisterMetaType<QScreen*>(); return qRegisterMetaType<MyQScreen*>();}
void* QScreen_GrabWindow(void* ptr, uintptr_t window, int x, int y, int width, int height)
{
return new QPixmap(static_cast<QScreen*>(ptr)->grabWindow(window, x, y, width, height));
}
struct QtGui_PackedString QScreen_QScreen_Tr(char* s, char* c, int n)
{
return ({ QByteArray t3d32c2 = QScreen::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t3d32c2.prepend("WHITESPACE").constData()+10), t3d32c2.size()-10 }; });
}
struct QtGui_PackedString QScreen_QScreen_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray tc52969 = QScreen::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(tc52969.prepend("WHITESPACE").constData()+10), tc52969.size()-10 }; });
}
void QScreen_ConnectAvailableGeometryChanged(void* ptr)
{
QObject::connect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(const QRect &)>(&QScreen::availableGeometryChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(const QRect &)>(&MyQScreen::Signal_AvailableGeometryChanged));
}
void QScreen_DisconnectAvailableGeometryChanged(void* ptr)
{
QObject::disconnect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(const QRect &)>(&QScreen::availableGeometryChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(const QRect &)>(&MyQScreen::Signal_AvailableGeometryChanged));
}
void QScreen_AvailableGeometryChanged(void* ptr, void* geometry)
{
static_cast<QScreen*>(ptr)->availableGeometryChanged(*static_cast<QRect*>(geometry));
}
void QScreen_ConnectGeometryChanged(void* ptr)
{
QObject::connect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(const QRect &)>(&QScreen::geometryChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(const QRect &)>(&MyQScreen::Signal_GeometryChanged));
}
void QScreen_DisconnectGeometryChanged(void* ptr)
{
QObject::disconnect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(const QRect &)>(&QScreen::geometryChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(const QRect &)>(&MyQScreen::Signal_GeometryChanged));
}
void QScreen_GeometryChanged(void* ptr, void* geometry)
{
static_cast<QScreen*>(ptr)->geometryChanged(*static_cast<QRect*>(geometry));
}
void QScreen_ConnectLogicalDotsPerInchChanged(void* ptr)
{
QObject::connect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(qreal)>(&QScreen::logicalDotsPerInchChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(qreal)>(&MyQScreen::Signal_LogicalDotsPerInchChanged));
}
void QScreen_DisconnectLogicalDotsPerInchChanged(void* ptr)
{
QObject::disconnect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(qreal)>(&QScreen::logicalDotsPerInchChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(qreal)>(&MyQScreen::Signal_LogicalDotsPerInchChanged));
}
void QScreen_LogicalDotsPerInchChanged(void* ptr, double dpi)
{
static_cast<QScreen*>(ptr)->logicalDotsPerInchChanged(dpi);
}
void QScreen_ConnectOrientationChanged(void* ptr)
{
qRegisterMetaType<Qt::ScreenOrientation>();
QObject::connect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(Qt::ScreenOrientation)>(&QScreen::orientationChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(Qt::ScreenOrientation)>(&MyQScreen::Signal_OrientationChanged));
}
void QScreen_DisconnectOrientationChanged(void* ptr)
{
QObject::disconnect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(Qt::ScreenOrientation)>(&QScreen::orientationChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(Qt::ScreenOrientation)>(&MyQScreen::Signal_OrientationChanged));
}
void QScreen_OrientationChanged(void* ptr, long long orientation)
{
static_cast<QScreen*>(ptr)->orientationChanged(static_cast<Qt::ScreenOrientation>(orientation));
}
void QScreen_ConnectPhysicalDotsPerInchChanged(void* ptr)
{
QObject::connect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(qreal)>(&QScreen::physicalDotsPerInchChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(qreal)>(&MyQScreen::Signal_PhysicalDotsPerInchChanged));
}
void QScreen_DisconnectPhysicalDotsPerInchChanged(void* ptr)
{
QObject::disconnect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(qreal)>(&QScreen::physicalDotsPerInchChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(qreal)>(&MyQScreen::Signal_PhysicalDotsPerInchChanged));
}
void QScreen_PhysicalDotsPerInchChanged(void* ptr, double dpi)
{
static_cast<QScreen*>(ptr)->physicalDotsPerInchChanged(dpi);
}
void QScreen_ConnectPhysicalSizeChanged(void* ptr)
{
QObject::connect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(const QSizeF &)>(&QScreen::physicalSizeChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(const QSizeF &)>(&MyQScreen::Signal_PhysicalSizeChanged));
}
void QScreen_DisconnectPhysicalSizeChanged(void* ptr)
{
QObject::disconnect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(const QSizeF &)>(&QScreen::physicalSizeChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(const QSizeF &)>(&MyQScreen::Signal_PhysicalSizeChanged));
}
void QScreen_PhysicalSizeChanged(void* ptr, void* size)
{
static_cast<QScreen*>(ptr)->physicalSizeChanged(*static_cast<QSizeF*>(size));
}
void QScreen_ConnectPrimaryOrientationChanged(void* ptr)
{
qRegisterMetaType<Qt::ScreenOrientation>();
QObject::connect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(Qt::ScreenOrientation)>(&QScreen::primaryOrientationChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(Qt::ScreenOrientation)>(&MyQScreen::Signal_PrimaryOrientationChanged));
}
void QScreen_DisconnectPrimaryOrientationChanged(void* ptr)
{
QObject::disconnect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(Qt::ScreenOrientation)>(&QScreen::primaryOrientationChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(Qt::ScreenOrientation)>(&MyQScreen::Signal_PrimaryOrientationChanged));
}
void QScreen_PrimaryOrientationChanged(void* ptr, long long orientation)
{
static_cast<QScreen*>(ptr)->primaryOrientationChanged(static_cast<Qt::ScreenOrientation>(orientation));
}
void QScreen_ConnectRefreshRateChanged(void* ptr)
{
QObject::connect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(qreal)>(&QScreen::refreshRateChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(qreal)>(&MyQScreen::Signal_RefreshRateChanged));
}
void QScreen_DisconnectRefreshRateChanged(void* ptr)
{
QObject::disconnect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(qreal)>(&QScreen::refreshRateChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(qreal)>(&MyQScreen::Signal_RefreshRateChanged));
}
void QScreen_RefreshRateChanged(void* ptr, double refreshRate)
{
static_cast<QScreen*>(ptr)->refreshRateChanged(refreshRate);
}
void QScreen_SetOrientationUpdateMask(void* ptr, long long mask)
{
static_cast<QScreen*>(ptr)->setOrientationUpdateMask(static_cast<Qt::ScreenOrientation>(mask));
}
void QScreen_ConnectVirtualGeometryChanged(void* ptr)
{
QObject::connect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(const QRect &)>(&QScreen::virtualGeometryChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(const QRect &)>(&MyQScreen::Signal_VirtualGeometryChanged));
}
void QScreen_DisconnectVirtualGeometryChanged(void* ptr)
{
QObject::disconnect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(const QRect &)>(&QScreen::virtualGeometryChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(const QRect &)>(&MyQScreen::Signal_VirtualGeometryChanged));
}
void QScreen_VirtualGeometryChanged(void* ptr, void* rect)
{
static_cast<QScreen*>(ptr)->virtualGeometryChanged(*static_cast<QRect*>(rect));
}
void QScreen_DestroyQScreen(void* ptr)
{
static_cast<QScreen*>(ptr)->~QScreen();
}
void QScreen_DestroyQScreenDefault(void* ptr)
{
Q_UNUSED(ptr);
}
struct QtGui_PackedList QScreen_VirtualSiblings(void* ptr)
{
return ({ QList<QScreen *>* tmpValue = new QList<QScreen *>(static_cast<QScreen*>(ptr)->virtualSiblings()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QScreen_AvailableGeometry(void* ptr)
{
return ({ QRect tmpValue = static_cast<QScreen*>(ptr)->availableGeometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QScreen_AvailableVirtualGeometry(void* ptr)
{
return ({ QRect tmpValue = static_cast<QScreen*>(ptr)->availableVirtualGeometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QScreen_Geometry(void* ptr)
{
return ({ QRect tmpValue = static_cast<QScreen*>(ptr)->geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QScreen_MapBetween(void* ptr, long long a, long long b, void* rect)
{
return ({ QRect tmpValue = static_cast<QScreen*>(ptr)->mapBetween(static_cast<Qt::ScreenOrientation>(a), static_cast<Qt::ScreenOrientation>(b), *static_cast<QRect*>(rect)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QScreen_VirtualGeometry(void* ptr)
{
return ({ QRect tmpValue = static_cast<QScreen*>(ptr)->virtualGeometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QScreen_AvailableSize(void* ptr)
{
return ({ QSize tmpValue = static_cast<QScreen*>(ptr)->availableSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}
void* QScreen_AvailableVirtualSize(void* ptr)
{
return ({ QSize tmpValue = static_cast<QScreen*>(ptr)->availableVirtualSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}
void* QScreen_Size(void* ptr)
{
return ({ QSize tmpValue = static_cast<QScreen*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
}
void* QScreen_VirtualSize(void* ptr)
{
return ({ QSize tmpValue = static_cast<QScreen*>(ptr)->virtualSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}
void* QScreen_PhysicalSize(void* ptr)
{
return ({ QSizeF tmpValue = static_cast<QScreen*>(ptr)->physicalSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}
struct QtGui_PackedString QScreen_Manufacturer(void* ptr)
{
return ({ QByteArray tb12da7 = static_cast<QScreen*>(ptr)->manufacturer().toUtf8(); QtGui_PackedString { const_cast<char*>(tb12da7.prepend("WHITESPACE").constData()+10), tb12da7.size()-10 }; });
}
struct QtGui_PackedString QScreen_Model(void* ptr)
{
#ifndef Q_OS_WIN
return ({ QByteArray t131f94 = static_cast<QScreen*>(ptr)->model().toUtf8(); QtGui_PackedString { const_cast<char*>(t131f94.prepend("WHITESPACE").constData()+10), t131f94.size()-10 }; });
#endif
}
struct QtGui_PackedString QScreen_Name(void* ptr)
{
return ({ QByteArray tc60f02 = static_cast<QScreen*>(ptr)->name().toUtf8(); QtGui_PackedString { const_cast<char*>(tc60f02.prepend("WHITESPACE").constData()+10), tc60f02.size()-10 }; });
}
struct QtGui_PackedString QScreen_SerialNumber(void* ptr)
{
return ({ QByteArray tff6367 = static_cast<QScreen*>(ptr)->serialNumber().toUtf8(); QtGui_PackedString { const_cast<char*>(tff6367.prepend("WHITESPACE").constData()+10), tff6367.size()-10 }; });
}
void* QScreen_TransformBetween(void* ptr, long long a, long long b, void* target)
{
return new QTransform(static_cast<QScreen*>(ptr)->transformBetween(static_cast<Qt::ScreenOrientation>(a), static_cast<Qt::ScreenOrientation>(b), *static_cast<QRect*>(target)));
}
long long QScreen_NativeOrientation(void* ptr)
{
return static_cast<QScreen*>(ptr)->nativeOrientation();
}
long long QScreen_Orientation(void* ptr)
{
return static_cast<QScreen*>(ptr)->orientation();
}
long long QScreen_PrimaryOrientation(void* ptr)
{
return static_cast<QScreen*>(ptr)->primaryOrientation();
}
long long QScreen_OrientationUpdateMask(void* ptr)
{
return static_cast<QScreen*>(ptr)->orientationUpdateMask();
}
char QScreen_IsLandscape(void* ptr, long long o)
{
return static_cast<QScreen*>(ptr)->isLandscape(static_cast<Qt::ScreenOrientation>(o));
}
char QScreen_IsPortrait(void* ptr, long long o)
{
return static_cast<QScreen*>(ptr)->isPortrait(static_cast<Qt::ScreenOrientation>(o));
}
void* QScreen_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QScreen*>(ptr)->QScreen::metaObject());
}
int QScreen_AngleBetween(void* ptr, long long a, long long b)
{
return static_cast<QScreen*>(ptr)->angleBetween(static_cast<Qt::ScreenOrientation>(a), static_cast<Qt::ScreenOrientation>(b));
}
int QScreen_Depth(void* ptr)
{
return static_cast<QScreen*>(ptr)->depth();
}
double QScreen_DevicePixelRatio(void* ptr)
{
return static_cast<QScreen*>(ptr)->devicePixelRatio();
}
double QScreen_LogicalDotsPerInch(void* ptr)
{
return static_cast<QScreen*>(ptr)->logicalDotsPerInch();
}
double QScreen_LogicalDotsPerInchX(void* ptr)
{
return static_cast<QScreen*>(ptr)->logicalDotsPerInchX();
}
double QScreen_LogicalDotsPerInchY(void* ptr)
{
return static_cast<QScreen*>(ptr)->logicalDotsPerInchY();
}
double QScreen_PhysicalDotsPerInch(void* ptr)
{
return static_cast<QScreen*>(ptr)->physicalDotsPerInch();
}
double QScreen_PhysicalDotsPerInchX(void* ptr)
{
return static_cast<QScreen*>(ptr)->physicalDotsPerInchX();
}
double QScreen_PhysicalDotsPerInchY(void* ptr)
{
return static_cast<QScreen*>(ptr)->physicalDotsPerInchY();
}
double QScreen_RefreshRate(void* ptr)
{
return static_cast<QScreen*>(ptr)->refreshRate();
}
void* QScreen___virtualSiblings_atList(void* ptr, int i)
{
return ({QScreen * tmp = static_cast<QList<QScreen *>*>(ptr)->at(i); if (i == static_cast<QList<QScreen *>*>(ptr)->size()-1) { static_cast<QList<QScreen *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QScreen___virtualSiblings_setList(void* ptr, void* i)
{
static_cast<QList<QScreen *>*>(ptr)->append(static_cast<QScreen*>(i));
}
void* QScreen___virtualSiblings_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QScreen *>();
}
void* QScreen___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QScreen___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QScreen___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QScreen___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QScreen___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QScreen___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QScreen___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QScreen___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QScreen___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QScreen___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QScreen___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QScreen___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QScreen___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QScreen___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QScreen___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QScreen_EventDefault(void* ptr, void* e)
{
return static_cast<QScreen*>(ptr)->QScreen::event(static_cast<QEvent*>(e));
}
char QScreen_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QScreen*>(ptr)->QScreen::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QScreen*>(ptr)->QScreen::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QScreen*>(ptr)->QScreen::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QScreen*>(ptr)->QScreen::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QScreen*>(ptr)->QScreen::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QScreen_ChildEventDefault(void* ptr, void* event)
{
static_cast<QScreen*>(ptr)->QScreen::childEvent(static_cast<QChildEvent*>(event));
}
void QScreen_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QScreen*>(ptr)->QScreen::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QScreen_CustomEventDefault(void* ptr, void* event)
{
static_cast<QScreen*>(ptr)->QScreen::customEvent(static_cast<QEvent*>(event));
}
void QScreen_DeleteLaterDefault(void* ptr)
{
static_cast<QScreen*>(ptr)->QScreen::deleteLater();
}
void QScreen_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QScreen*>(ptr)->QScreen::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QScreen_TimerEventDefault(void* ptr, void* event)
{
static_cast<QScreen*>(ptr)->QScreen::timerEvent(static_cast<QTimerEvent*>(event));
}
class MyQScrollEvent: public QScrollEvent
{
public:
MyQScrollEvent(const QPointF &contentPos, const QPointF &overshootDistance, QScrollEvent::ScrollState scrollState) : QScrollEvent(contentPos, overshootDistance, scrollState) {};
~MyQScrollEvent() { callbackQScrollEvent_DestroyQScrollEvent(this); };
};
void* QScrollEvent_NewQScrollEvent(void* contentPos, void* overshootDistance, long long scrollState)
{
return new MyQScrollEvent(*static_cast<QPointF*>(contentPos), *static_cast<QPointF*>(overshootDistance), static_cast<QScrollEvent::ScrollState>(scrollState));
}
void QScrollEvent_DestroyQScrollEvent(void* ptr)
{
static_cast<QScrollEvent*>(ptr)->~QScrollEvent();
}
void QScrollEvent_DestroyQScrollEventDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QScrollEvent_ContentPos(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QScrollEvent*>(ptr)->contentPos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void* QScrollEvent_OvershootDistance(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QScrollEvent*>(ptr)->overshootDistance(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
long long QScrollEvent_ScrollState(void* ptr)
{
return static_cast<QScrollEvent*>(ptr)->scrollState();
}
class MyQScrollPrepareEvent: public QScrollPrepareEvent
{
public:
MyQScrollPrepareEvent(const QPointF &startPos) : QScrollPrepareEvent(startPos) {};
~MyQScrollPrepareEvent() { callbackQScrollPrepareEvent_DestroyQScrollPrepareEvent(this); };
};
void* QScrollPrepareEvent_NewQScrollPrepareEvent(void* startPos)
{
return new MyQScrollPrepareEvent(*static_cast<QPointF*>(startPos));
}
void QScrollPrepareEvent_SetContentPos(void* ptr, void* pos)
{
static_cast<QScrollPrepareEvent*>(ptr)->setContentPos(*static_cast<QPointF*>(pos));
}
void QScrollPrepareEvent_SetContentPosRange(void* ptr, void* rect)
{
static_cast<QScrollPrepareEvent*>(ptr)->setContentPosRange(*static_cast<QRectF*>(rect));
}
void QScrollPrepareEvent_SetViewportSize(void* ptr, void* size)
{
static_cast<QScrollPrepareEvent*>(ptr)->setViewportSize(*static_cast<QSizeF*>(size));
}
void QScrollPrepareEvent_DestroyQScrollPrepareEvent(void* ptr)
{
static_cast<QScrollPrepareEvent*>(ptr)->~QScrollPrepareEvent();
}
void QScrollPrepareEvent_DestroyQScrollPrepareEventDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QScrollPrepareEvent_ContentPos(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QScrollPrepareEvent*>(ptr)->contentPos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void* QScrollPrepareEvent_StartPos(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QScrollPrepareEvent*>(ptr)->startPos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void* QScrollPrepareEvent_ContentPosRange(void* ptr)
{
return ({ QRectF tmpValue = static_cast<QScrollPrepareEvent*>(ptr)->contentPosRange(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QScrollPrepareEvent_ViewportSize(void* ptr)
{
return ({ QSizeF tmpValue = static_cast<QScrollPrepareEvent*>(ptr)->viewportSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}
class MyQSessionManager: public QSessionManager
{
public:
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQSessionManager_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQSessionManager_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQSessionManager_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQSessionManager_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQSessionManager_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQSessionManager_CustomEvent(this, event); };
void deleteLater() { callbackQSessionManager_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQSessionManager_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQSessionManager_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQSessionManager_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQSessionManager_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQSessionManager*)
int QSessionManager_QSessionManager_QRegisterMetaType(){qRegisterMetaType<QSessionManager*>(); return qRegisterMetaType<MyQSessionManager*>();}
struct QtGui_PackedString QSessionManager_QSessionManager_Tr(char* s, char* c, int n)
{
return ({ QByteArray t6fbc5e = QSessionManager::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t6fbc5e.prepend("WHITESPACE").constData()+10), t6fbc5e.size()-10 }; });
}
struct QtGui_PackedString QSessionManager_QSessionManager_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray tf5c1ae = QSessionManager::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(tf5c1ae.prepend("WHITESPACE").constData()+10), tf5c1ae.size()-10 }; });
}
char QSessionManager_AllowsErrorInteraction(void* ptr)
{
return static_cast<QSessionManager*>(ptr)->allowsErrorInteraction();
}
char QSessionManager_AllowsInteraction(void* ptr)
{
return static_cast<QSessionManager*>(ptr)->allowsInteraction();
}
void QSessionManager_Cancel(void* ptr)
{
static_cast<QSessionManager*>(ptr)->cancel();
}
void QSessionManager_Release(void* ptr)
{
static_cast<QSessionManager*>(ptr)->release();
}
void QSessionManager_RequestPhase2(void* ptr)
{
static_cast<QSessionManager*>(ptr)->requestPhase2();
}
void QSessionManager_SetDiscardCommand(void* ptr, struct QtGui_PackedString command)
{
static_cast<QSessionManager*>(ptr)->setDiscardCommand(QString::fromUtf8(command.data, command.len).split("|", QString::SkipEmptyParts));
}
void QSessionManager_SetManagerProperty2(void* ptr, struct QtGui_PackedString name, struct QtGui_PackedString value)
{
static_cast<QSessionManager*>(ptr)->setManagerProperty(QString::fromUtf8(name.data, name.len), QString::fromUtf8(value.data, value.len));
}
void QSessionManager_SetManagerProperty(void* ptr, struct QtGui_PackedString name, struct QtGui_PackedString value)
{
static_cast<QSessionManager*>(ptr)->setManagerProperty(QString::fromUtf8(name.data, name.len), QString::fromUtf8(value.data, value.len).split("|", QString::SkipEmptyParts));
}
void QSessionManager_SetRestartCommand(void* ptr, struct QtGui_PackedString command)
{
static_cast<QSessionManager*>(ptr)->setRestartCommand(QString::fromUtf8(command.data, command.len).split("|", QString::SkipEmptyParts));
}
void QSessionManager_SetRestartHint(void* ptr, long long hint)
{
static_cast<QSessionManager*>(ptr)->setRestartHint(static_cast<QSessionManager::RestartHint>(hint));
}
long long QSessionManager_RestartHint(void* ptr)
{
return static_cast<QSessionManager*>(ptr)->restartHint();
}
struct QtGui_PackedString QSessionManager_SessionId(void* ptr)
{
return ({ QByteArray t8eaf8d = static_cast<QSessionManager*>(ptr)->sessionId().toUtf8(); QtGui_PackedString { const_cast<char*>(t8eaf8d.prepend("WHITESPACE").constData()+10), t8eaf8d.size()-10 }; });
}
struct QtGui_PackedString QSessionManager_SessionKey(void* ptr)
{
return ({ QByteArray tb1e419 = static_cast<QSessionManager*>(ptr)->sessionKey().toUtf8(); QtGui_PackedString { const_cast<char*>(tb1e419.prepend("WHITESPACE").constData()+10), tb1e419.size()-10 }; });
}
struct QtGui_PackedString QSessionManager_DiscardCommand(void* ptr)
{
return ({ QByteArray t7ed2e8 = static_cast<QSessionManager*>(ptr)->discardCommand().join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t7ed2e8.prepend("WHITESPACE").constData()+10), t7ed2e8.size()-10 }; });
}
struct QtGui_PackedString QSessionManager_RestartCommand(void* ptr)
{
return ({ QByteArray t8b3c52 = static_cast<QSessionManager*>(ptr)->restartCommand().join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t8b3c52.prepend("WHITESPACE").constData()+10), t8b3c52.size()-10 }; });
}
char QSessionManager_IsPhase2(void* ptr)
{
return static_cast<QSessionManager*>(ptr)->isPhase2();
}
void* QSessionManager_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QSessionManager*>(ptr)->QSessionManager::metaObject());
}
void* QSessionManager___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QSessionManager___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QSessionManager___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QSessionManager___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QSessionManager___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QSessionManager___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QSessionManager___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QSessionManager___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QSessionManager___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QSessionManager___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QSessionManager___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QSessionManager___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QSessionManager___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QSessionManager___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QSessionManager___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QSessionManager_EventDefault(void* ptr, void* e)
{
return static_cast<QSessionManager*>(ptr)->QSessionManager::event(static_cast<QEvent*>(e));
}
char QSessionManager_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QSessionManager*>(ptr)->QSessionManager::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QSessionManager*>(ptr)->QSessionManager::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QSessionManager*>(ptr)->QSessionManager::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QSessionManager*>(ptr)->QSessionManager::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QSessionManager*>(ptr)->QSessionManager::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QSessionManager_ChildEventDefault(void* ptr, void* event)
{
static_cast<QSessionManager*>(ptr)->QSessionManager::childEvent(static_cast<QChildEvent*>(event));
}
void QSessionManager_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QSessionManager*>(ptr)->QSessionManager::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QSessionManager_CustomEventDefault(void* ptr, void* event)
{
static_cast<QSessionManager*>(ptr)->QSessionManager::customEvent(static_cast<QEvent*>(event));
}
void QSessionManager_DeleteLaterDefault(void* ptr)
{
static_cast<QSessionManager*>(ptr)->QSessionManager::deleteLater();
}
void QSessionManager_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QSessionManager*>(ptr)->QSessionManager::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QSessionManager_TimerEventDefault(void* ptr, void* event)
{
static_cast<QSessionManager*>(ptr)->QSessionManager::timerEvent(static_cast<QTimerEvent*>(event));
}
class MyQShortcutEvent: public QShortcutEvent
{
public:
MyQShortcutEvent(const QKeySequence &key, int id, bool ambiguous = false) : QShortcutEvent(key, id, ambiguous) {};
~MyQShortcutEvent() { callbackQShortcutEvent_DestroyQShortcutEvent(this); };
};
void* QShortcutEvent_NewQShortcutEvent(void* key, int id, char ambiguous)
{
return new MyQShortcutEvent(*static_cast<QKeySequence*>(key), id, ambiguous != 0);
}
void QShortcutEvent_DestroyQShortcutEvent(void* ptr)
{
static_cast<QShortcutEvent*>(ptr)->~QShortcutEvent();
}
void QShortcutEvent_DestroyQShortcutEventDefault(void* ptr)
{
Q_UNUSED(ptr);
}
char QShortcutEvent_IsAmbiguous(void* ptr)
{
return static_cast<QShortcutEvent*>(ptr)->isAmbiguous();
}
void* QShortcutEvent_Key(void* ptr)
{
return const_cast<QKeySequence*>(&static_cast<QShortcutEvent*>(ptr)->key());
}
int QShortcutEvent_ShortcutId(void* ptr)
{
return static_cast<QShortcutEvent*>(ptr)->shortcutId();
}
char QShortcutEvent_Ambig(void* ptr)
{
return static_cast<QShortcutEvent*>(ptr)->ambig;
}
void QShortcutEvent_SetAmbig(void* ptr, char vbo)
{
static_cast<QShortcutEvent*>(ptr)->ambig = vbo != 0;
}
void* QShortcutEvent_Sequence(void* ptr)
{
return new QKeySequence(static_cast<QShortcutEvent*>(ptr)->sequence);
}
void QShortcutEvent_SetSequence(void* ptr, void* vqk)
{
static_cast<QShortcutEvent*>(ptr)->sequence = *static_cast<QKeySequence*>(vqk);
}
int QShortcutEvent_Sid(void* ptr)
{
return static_cast<QShortcutEvent*>(ptr)->sid;
}
void QShortcutEvent_SetSid(void* ptr, int vin)
{
static_cast<QShortcutEvent*>(ptr)->sid = vin;
}
class MyQShowEvent: public QShowEvent
{
public:
MyQShowEvent() : QShowEvent() {};
};
void* QShowEvent_NewQShowEvent()
{
return new MyQShowEvent();
}
class MyQStandardItem: public QStandardItem
{
public:
MyQStandardItem() : QStandardItem() {};
MyQStandardItem(const QIcon &icon, const QString &text) : QStandardItem(icon, text) {};
MyQStandardItem(const QStandardItem &other) : QStandardItem(other) {};
MyQStandardItem(const QString &text) : QStandardItem(text) {};
MyQStandardItem(int rows, int columns = 1) : QStandardItem(rows, columns) {};
void read(QDataStream & in) { callbackQStandardItem_Read(this, static_cast<QDataStream*>(&in)); };
void setData(const QVariant & value, int role) { callbackQStandardItem_SetData(this, const_cast<QVariant*>(&value), role); };
~MyQStandardItem() { callbackQStandardItem_DestroyQStandardItem(this); };
QStandardItem * clone() const { return static_cast<QStandardItem*>(callbackQStandardItem_Clone(const_cast<void*>(static_cast<const void*>(this)))); };
QVariant data(int role) const { return *static_cast<QVariant*>(callbackQStandardItem_Data(const_cast<void*>(static_cast<const void*>(this)), role)); };
int type() const { return callbackQStandardItem_Type(const_cast<void*>(static_cast<const void*>(this))); };
void write(QDataStream & out) const { callbackQStandardItem_Write(const_cast<void*>(static_cast<const void*>(this)), static_cast<QDataStream*>(&out)); };
};
struct QtGui_PackedList QStandardItem_TakeColumn(void* ptr, int column)
{
return ({ QList<QStandardItem *>* tmpValue = new QList<QStandardItem *>(static_cast<QStandardItem*>(ptr)->takeColumn(column)); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedList QStandardItem_TakeRow(void* ptr, int row)
{
return ({ QList<QStandardItem *>* tmpValue = new QList<QStandardItem *>(static_cast<QStandardItem*>(ptr)->takeRow(row)); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QStandardItem_TakeChild(void* ptr, int row, int column)
{
return static_cast<QStandardItem*>(ptr)->takeChild(row, column);
}
void* QStandardItem_NewQStandardItem()
{
return new MyQStandardItem();
}
void* QStandardItem_NewQStandardItem3(void* icon, struct QtGui_PackedString text)
{
return new MyQStandardItem(*static_cast<QIcon*>(icon), QString::fromUtf8(text.data, text.len));
}
void* QStandardItem_NewQStandardItem5(void* other)
{
return new MyQStandardItem(*static_cast<QStandardItem*>(other));
}
void* QStandardItem_NewQStandardItem2(struct QtGui_PackedString text)
{
return new MyQStandardItem(QString::fromUtf8(text.data, text.len));
}
void* QStandardItem_NewQStandardItem4(int rows, int columns)
{
return new MyQStandardItem(rows, columns);
}
void QStandardItem_AppendColumn(void* ptr, void* items)
{
static_cast<QStandardItem*>(ptr)->appendColumn(*static_cast<QList<QStandardItem *>*>(items));
}
void QStandardItem_AppendRow2(void* ptr, void* item)
{
static_cast<QStandardItem*>(ptr)->appendRow(static_cast<QStandardItem*>(item));
}
void QStandardItem_AppendRow(void* ptr, void* items)
{
static_cast<QStandardItem*>(ptr)->appendRow(*static_cast<QList<QStandardItem *>*>(items));
}
void QStandardItem_AppendRows(void* ptr, void* items)
{
static_cast<QStandardItem*>(ptr)->appendRows(*static_cast<QList<QStandardItem *>*>(items));
}
void QStandardItem_EmitDataChanged(void* ptr)
{
static_cast<QStandardItem*>(ptr)->emitDataChanged();
}
void QStandardItem_InsertColumn(void* ptr, int column, void* items)
{
static_cast<QStandardItem*>(ptr)->insertColumn(column, *static_cast<QList<QStandardItem *>*>(items));
}
void QStandardItem_InsertColumns(void* ptr, int column, int count)
{
static_cast<QStandardItem*>(ptr)->insertColumns(column, count);
}
void QStandardItem_InsertRow2(void* ptr, int row, void* item)
{
static_cast<QStandardItem*>(ptr)->insertRow(row, static_cast<QStandardItem*>(item));
}
void QStandardItem_InsertRow(void* ptr, int row, void* items)
{
static_cast<QStandardItem*>(ptr)->insertRow(row, *static_cast<QList<QStandardItem *>*>(items));
}
void QStandardItem_InsertRows(void* ptr, int row, void* items)
{
static_cast<QStandardItem*>(ptr)->insertRows(row, *static_cast<QList<QStandardItem *>*>(items));
}
void QStandardItem_InsertRows2(void* ptr, int row, int count)
{
static_cast<QStandardItem*>(ptr)->insertRows(row, count);
}
void QStandardItem_Read(void* ptr, void* in)
{
static_cast<QStandardItem*>(ptr)->read(*static_cast<QDataStream*>(in));
}
void QStandardItem_ReadDefault(void* ptr, void* in)
{
static_cast<QStandardItem*>(ptr)->QStandardItem::read(*static_cast<QDataStream*>(in));
}
void QStandardItem_RemoveColumn(void* ptr, int column)
{
static_cast<QStandardItem*>(ptr)->removeColumn(column);
}
void QStandardItem_RemoveColumns(void* ptr, int column, int count)
{
static_cast<QStandardItem*>(ptr)->removeColumns(column, count);
}
void QStandardItem_RemoveRow(void* ptr, int row)
{
static_cast<QStandardItem*>(ptr)->removeRow(row);
}
void QStandardItem_RemoveRows(void* ptr, int row, int count)
{
static_cast<QStandardItem*>(ptr)->removeRows(row, count);
}
void QStandardItem_SetAccessibleDescription(void* ptr, struct QtGui_PackedString accessibleDescription)
{
static_cast<QStandardItem*>(ptr)->setAccessibleDescription(QString::fromUtf8(accessibleDescription.data, accessibleDescription.len));
}
void QStandardItem_SetAccessibleText(void* ptr, struct QtGui_PackedString accessibleText)
{
static_cast<QStandardItem*>(ptr)->setAccessibleText(QString::fromUtf8(accessibleText.data, accessibleText.len));
}
void QStandardItem_SetAutoTristate(void* ptr, char tristate)
{
static_cast<QStandardItem*>(ptr)->setAutoTristate(tristate != 0);
}
void QStandardItem_SetBackground(void* ptr, void* brush)
{
static_cast<QStandardItem*>(ptr)->setBackground(*static_cast<QBrush*>(brush));
}
void QStandardItem_SetCheckState(void* ptr, long long state)
{
static_cast<QStandardItem*>(ptr)->setCheckState(static_cast<Qt::CheckState>(state));
}
void QStandardItem_SetCheckable(void* ptr, char checkable)
{
static_cast<QStandardItem*>(ptr)->setCheckable(checkable != 0);
}
void QStandardItem_SetChild2(void* ptr, int row, void* item)
{
static_cast<QStandardItem*>(ptr)->setChild(row, static_cast<QStandardItem*>(item));
}
void QStandardItem_SetChild(void* ptr, int row, int column, void* item)
{
static_cast<QStandardItem*>(ptr)->setChild(row, column, static_cast<QStandardItem*>(item));
}
void QStandardItem_SetColumnCount(void* ptr, int columns)
{
static_cast<QStandardItem*>(ptr)->setColumnCount(columns);
}
void QStandardItem_SetData(void* ptr, void* value, int role)
{
static_cast<QStandardItem*>(ptr)->setData(*static_cast<QVariant*>(value), role);
}
void QStandardItem_SetDataDefault(void* ptr, void* value, int role)
{
static_cast<QStandardItem*>(ptr)->QStandardItem::setData(*static_cast<QVariant*>(value), role);
}
void QStandardItem_SetDragEnabled(void* ptr, char dragEnabled)
{
static_cast<QStandardItem*>(ptr)->setDragEnabled(dragEnabled != 0);
}
void QStandardItem_SetDropEnabled(void* ptr, char dropEnabled)
{
static_cast<QStandardItem*>(ptr)->setDropEnabled(dropEnabled != 0);
}
void QStandardItem_SetEditable(void* ptr, char editable)
{
static_cast<QStandardItem*>(ptr)->setEditable(editable != 0);
}
void QStandardItem_SetEnabled(void* ptr, char enabled)
{
static_cast<QStandardItem*>(ptr)->setEnabled(enabled != 0);
}
void QStandardItem_SetFlags(void* ptr, long long flags)
{
static_cast<QStandardItem*>(ptr)->setFlags(static_cast<Qt::ItemFlag>(flags));
}
void QStandardItem_SetFont(void* ptr, void* font)
{
static_cast<QStandardItem*>(ptr)->setFont(*static_cast<QFont*>(font));
}
void QStandardItem_SetForeground(void* ptr, void* brush)
{
static_cast<QStandardItem*>(ptr)->setForeground(*static_cast<QBrush*>(brush));
}
void QStandardItem_SetIcon(void* ptr, void* icon)
{
static_cast<QStandardItem*>(ptr)->setIcon(*static_cast<QIcon*>(icon));
}
void QStandardItem_SetRowCount(void* ptr, int rows)
{
static_cast<QStandardItem*>(ptr)->setRowCount(rows);
}
void QStandardItem_SetSelectable(void* ptr, char selectable)
{
static_cast<QStandardItem*>(ptr)->setSelectable(selectable != 0);
}
void QStandardItem_SetSizeHint(void* ptr, void* size)
{
static_cast<QStandardItem*>(ptr)->setSizeHint(*static_cast<QSize*>(size));
}
void QStandardItem_SetStatusTip(void* ptr, struct QtGui_PackedString statusTip)
{
static_cast<QStandardItem*>(ptr)->setStatusTip(QString::fromUtf8(statusTip.data, statusTip.len));
}
void QStandardItem_SetText(void* ptr, struct QtGui_PackedString text)
{
static_cast<QStandardItem*>(ptr)->setText(QString::fromUtf8(text.data, text.len));
}
void QStandardItem_SetTextAlignment(void* ptr, long long alignment)
{
static_cast<QStandardItem*>(ptr)->setTextAlignment(static_cast<Qt::AlignmentFlag>(alignment));
}
void QStandardItem_SetToolTip(void* ptr, struct QtGui_PackedString toolTip)
{
static_cast<QStandardItem*>(ptr)->setToolTip(QString::fromUtf8(toolTip.data, toolTip.len));
}
void QStandardItem_SetUserTristate(void* ptr, char tristate)
{
static_cast<QStandardItem*>(ptr)->setUserTristate(tristate != 0);
}
void QStandardItem_SetWhatsThis(void* ptr, struct QtGui_PackedString whatsThis)
{
static_cast<QStandardItem*>(ptr)->setWhatsThis(QString::fromUtf8(whatsThis.data, whatsThis.len));
}
void QStandardItem_SortChildren(void* ptr, int column, long long order)
{
static_cast<QStandardItem*>(ptr)->sortChildren(column, static_cast<Qt::SortOrder>(order));
}
void QStandardItem_DestroyQStandardItem(void* ptr)
{
static_cast<QStandardItem*>(ptr)->~QStandardItem();
}
void QStandardItem_DestroyQStandardItemDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QStandardItem_Background(void* ptr)
{
return new QBrush(static_cast<QStandardItem*>(ptr)->background());
}
void* QStandardItem_Foreground(void* ptr)
{
return new QBrush(static_cast<QStandardItem*>(ptr)->foreground());
}
void* QStandardItem_Font(void* ptr)
{
return new QFont(static_cast<QStandardItem*>(ptr)->font());
}
void* QStandardItem_Icon(void* ptr)
{
return new QIcon(static_cast<QStandardItem*>(ptr)->icon());
}
void* QStandardItem_Index(void* ptr)
{
return new QModelIndex(static_cast<QStandardItem*>(ptr)->index());
}
void* QStandardItem_SizeHint(void* ptr)
{
return ({ QSize tmpValue = static_cast<QStandardItem*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}
void* QStandardItem_Child(void* ptr, int row, int column)
{
return static_cast<QStandardItem*>(ptr)->child(row, column);
}
void* QStandardItem_Clone(void* ptr)
{
return static_cast<QStandardItem*>(ptr)->clone();
}
void* QStandardItem_CloneDefault(void* ptr)
{
return static_cast<QStandardItem*>(ptr)->QStandardItem::clone();
}
void* QStandardItem_Parent(void* ptr)
{
return static_cast<QStandardItem*>(ptr)->parent();
}
void* QStandardItem_Model(void* ptr)
{
return static_cast<QStandardItem*>(ptr)->model();
}
struct QtGui_PackedString QStandardItem_AccessibleDescription(void* ptr)
{
return ({ QByteArray t03d242 = static_cast<QStandardItem*>(ptr)->accessibleDescription().toUtf8(); QtGui_PackedString { const_cast<char*>(t03d242.prepend("WHITESPACE").constData()+10), t03d242.size()-10 }; });
}
struct QtGui_PackedString QStandardItem_AccessibleText(void* ptr)
{
return ({ QByteArray t3ec2e5 = static_cast<QStandardItem*>(ptr)->accessibleText().toUtf8(); QtGui_PackedString { const_cast<char*>(t3ec2e5.prepend("WHITESPACE").constData()+10), t3ec2e5.size()-10 }; });
}
struct QtGui_PackedString QStandardItem_StatusTip(void* ptr)
{
return ({ QByteArray t534fca = static_cast<QStandardItem*>(ptr)->statusTip().toUtf8(); QtGui_PackedString { const_cast<char*>(t534fca.prepend("WHITESPACE").constData()+10), t534fca.size()-10 }; });
}
struct QtGui_PackedString QStandardItem_Text(void* ptr)
{
return ({ QByteArray t847a7a = static_cast<QStandardItem*>(ptr)->text().toUtf8(); QtGui_PackedString { const_cast<char*>(t847a7a.prepend("WHITESPACE").constData()+10), t847a7a.size()-10 }; });
}
struct QtGui_PackedString QStandardItem_ToolTip(void* ptr)
{
return ({ QByteArray t938860 = static_cast<QStandardItem*>(ptr)->toolTip().toUtf8(); QtGui_PackedString { const_cast<char*>(t938860.prepend("WHITESPACE").constData()+10), t938860.size()-10 }; });
}
struct QtGui_PackedString QStandardItem_WhatsThis(void* ptr)
{
return ({ QByteArray taa28dd = static_cast<QStandardItem*>(ptr)->whatsThis().toUtf8(); QtGui_PackedString { const_cast<char*>(taa28dd.prepend("WHITESPACE").constData()+10), taa28dd.size()-10 }; });
}
void* QStandardItem_Data(void* ptr, int role)
{
return new QVariant(static_cast<QStandardItem*>(ptr)->data(role));
}
void* QStandardItem_DataDefault(void* ptr, int role)
{
return new QVariant(static_cast<QStandardItem*>(ptr)->QStandardItem::data(role));
}
long long QStandardItem_TextAlignment(void* ptr)
{
return static_cast<QStandardItem*>(ptr)->textAlignment();
}
long long QStandardItem_CheckState(void* ptr)
{
return static_cast<QStandardItem*>(ptr)->checkState();
}
long long QStandardItem_Flags(void* ptr)
{
return static_cast<QStandardItem*>(ptr)->flags();
}
char QStandardItem_HasChildren(void* ptr)
{
return static_cast<QStandardItem*>(ptr)->hasChildren();
}
char QStandardItem_IsAutoTristate(void* ptr)
{
return static_cast<QStandardItem*>(ptr)->isAutoTristate();
}
char QStandardItem_IsCheckable(void* ptr)
{
return static_cast<QStandardItem*>(ptr)->isCheckable();
}
char QStandardItem_IsDragEnabled(void* ptr)
{
return static_cast<QStandardItem*>(ptr)->isDragEnabled();
}
char QStandardItem_IsDropEnabled(void* ptr)
{
return static_cast<QStandardItem*>(ptr)->isDropEnabled();
}
char QStandardItem_IsEditable(void* ptr)
{
return static_cast<QStandardItem*>(ptr)->isEditable();
}
char QStandardItem_IsEnabled(void* ptr)
{
return static_cast<QStandardItem*>(ptr)->isEnabled();
}
char QStandardItem_IsSelectable(void* ptr)
{
return static_cast<QStandardItem*>(ptr)->isSelectable();
}
char QStandardItem_IsUserTristate(void* ptr)
{
return static_cast<QStandardItem*>(ptr)->isUserTristate();
}
int QStandardItem_Column(void* ptr)
{
return static_cast<QStandardItem*>(ptr)->column();
}
int QStandardItem_ColumnCount(void* ptr)
{
return static_cast<QStandardItem*>(ptr)->columnCount();
}
int QStandardItem_Row(void* ptr)
{
return static_cast<QStandardItem*>(ptr)->row();
}
int QStandardItem_RowCount(void* ptr)
{
return static_cast<QStandardItem*>(ptr)->rowCount();
}
int QStandardItem_Type(void* ptr)
{
return static_cast<QStandardItem*>(ptr)->type();
}
int QStandardItem_TypeDefault(void* ptr)
{
return static_cast<QStandardItem*>(ptr)->QStandardItem::type();
}
void QStandardItem_Write(void* ptr, void* out)
{
static_cast<QStandardItem*>(ptr)->write(*static_cast<QDataStream*>(out));
}
void QStandardItem_WriteDefault(void* ptr, void* out)
{
static_cast<QStandardItem*>(ptr)->QStandardItem::write(*static_cast<QDataStream*>(out));
}
void* QStandardItem___takeColumn_atList(void* ptr, int i)
{
return ({QStandardItem * tmp = static_cast<QList<QStandardItem *>*>(ptr)->at(i); if (i == static_cast<QList<QStandardItem *>*>(ptr)->size()-1) { static_cast<QList<QStandardItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItem___takeColumn_setList(void* ptr, void* i)
{
static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}
void* QStandardItem___takeColumn_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QStandardItem *>();
}
void* QStandardItem___takeRow_atList(void* ptr, int i)
{
return ({QStandardItem * tmp = static_cast<QList<QStandardItem *>*>(ptr)->at(i); if (i == static_cast<QList<QStandardItem *>*>(ptr)->size()-1) { static_cast<QList<QStandardItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItem___takeRow_setList(void* ptr, void* i)
{
static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}
void* QStandardItem___takeRow_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QStandardItem *>();
}
void* QStandardItem___appendColumn_items_atList(void* ptr, int i)
{
return ({QStandardItem * tmp = static_cast<QList<QStandardItem *>*>(ptr)->at(i); if (i == static_cast<QList<QStandardItem *>*>(ptr)->size()-1) { static_cast<QList<QStandardItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItem___appendColumn_items_setList(void* ptr, void* i)
{
static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}
void* QStandardItem___appendColumn_items_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QStandardItem *>();
}
void* QStandardItem___appendRow_items_atList(void* ptr, int i)
{
return ({QStandardItem * tmp = static_cast<QList<QStandardItem *>*>(ptr)->at(i); if (i == static_cast<QList<QStandardItem *>*>(ptr)->size()-1) { static_cast<QList<QStandardItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItem___appendRow_items_setList(void* ptr, void* i)
{
static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}
void* QStandardItem___appendRow_items_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QStandardItem *>();
}
void* QStandardItem___appendRows_items_atList(void* ptr, int i)
{
return ({QStandardItem * tmp = static_cast<QList<QStandardItem *>*>(ptr)->at(i); if (i == static_cast<QList<QStandardItem *>*>(ptr)->size()-1) { static_cast<QList<QStandardItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItem___appendRows_items_setList(void* ptr, void* i)
{
static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}
void* QStandardItem___appendRows_items_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QStandardItem *>();
}
void* QStandardItem___insertColumn_items_atList(void* ptr, int i)
{
return ({QStandardItem * tmp = static_cast<QList<QStandardItem *>*>(ptr)->at(i); if (i == static_cast<QList<QStandardItem *>*>(ptr)->size()-1) { static_cast<QList<QStandardItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItem___insertColumn_items_setList(void* ptr, void* i)
{
static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}
void* QStandardItem___insertColumn_items_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QStandardItem *>();
}
void* QStandardItem___insertRow_items_atList(void* ptr, int i)
{
return ({QStandardItem * tmp = static_cast<QList<QStandardItem *>*>(ptr)->at(i); if (i == static_cast<QList<QStandardItem *>*>(ptr)->size()-1) { static_cast<QList<QStandardItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItem___insertRow_items_setList(void* ptr, void* i)
{
static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}
void* QStandardItem___insertRow_items_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QStandardItem *>();
}
void* QStandardItem___insertRows_items_atList(void* ptr, int i)
{
return ({QStandardItem * tmp = static_cast<QList<QStandardItem *>*>(ptr)->at(i); if (i == static_cast<QList<QStandardItem *>*>(ptr)->size()-1) { static_cast<QList<QStandardItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItem___insertRows_items_setList(void* ptr, void* i)
{
static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}
void* QStandardItem___insertRows_items_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QStandardItem *>();
}
class MyQStandardItemModel: public QStandardItemModel
{
public:
MyQStandardItemModel(QObject *parent = Q_NULLPTR) : QStandardItemModel(parent) {QStandardItemModel_QStandardItemModel_QRegisterMetaType();};
MyQStandardItemModel(int rows, int columns, QObject *parent = Q_NULLPTR) : QStandardItemModel(rows, columns, parent) {QStandardItemModel_QStandardItemModel_QRegisterMetaType();};
bool dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) { return callbackQStandardItemModel_DropMimeData(this, const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
bool insertColumns(int column, int count, const QModelIndex & parent) { return callbackQStandardItemModel_InsertColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
bool insertRows(int row, int count, const QModelIndex & parent) { return callbackQStandardItemModel_InsertRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
bool removeColumns(int column, int count, const QModelIndex & parent) { return callbackQStandardItemModel_RemoveColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
bool removeRows(int row, int count, const QModelIndex & parent) { return callbackQStandardItemModel_RemoveRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
bool setData(const QModelIndex & index, const QVariant & value, int role) { return callbackQStandardItemModel_SetData(this, const_cast<QModelIndex*>(&index), const_cast<QVariant*>(&value), role) != 0; };
bool setHeaderData(int section, Qt::Orientation orientation, const QVariant & value, int role) { return callbackQStandardItemModel_SetHeaderData(this, section, orientation, const_cast<QVariant*>(&value), role) != 0; };
bool setItemData(const QModelIndex & index, const QMap<int, QVariant> & roles) { return callbackQStandardItemModel_SetItemData(this, const_cast<QModelIndex*>(&index), ({ QMap<int, QVariant>* tmpValue = const_cast<QMap<int, QVariant>*>(&roles); QtGui_PackedList { tmpValue, tmpValue->size() }; })) != 0; };
void Signal_ItemChanged(QStandardItem * item) { callbackQStandardItemModel_ItemChanged(this, item); };
void sort(int column, Qt::SortOrder order) { callbackQStandardItemModel_Sort(this, column, order); };
~MyQStandardItemModel() { callbackQStandardItemModel_DestroyQStandardItemModel(this); };
QMap<int, QVariant> itemData(const QModelIndex & index) const { return ({ QMap<int, QVariant>* tmpP = static_cast<QMap<int, QVariant>*>(callbackQStandardItemModel_ItemData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); QMap<int, QVariant> tmpV = *tmpP; tmpP->~QMap(); free(tmpP); tmpV; }); };
QMimeData * mimeData(const QModelIndexList & indexes) const { return static_cast<QMimeData*>(callbackQStandardItemModel_MimeData(const_cast<void*>(static_cast<const void*>(this)), ({ QList<QModelIndex>* tmpValue = new QList<QModelIndex>(indexes); QtGui_PackedList { tmpValue, tmpValue->size() }; }))); };
QModelIndex index(int row, int column, const QModelIndex & parent) const { return *static_cast<QModelIndex*>(callbackQStandardItemModel_Index(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&parent))); };
QModelIndex parent(const QModelIndex & child) const { return *static_cast<QModelIndex*>(callbackQStandardItemModel_Parent(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&child))); };
QModelIndex sibling(int row, int column, const QModelIndex & idx) const { return *static_cast<QModelIndex*>(callbackQStandardItemModel_Sibling(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&idx))); };
QStringList mimeTypes() const { return ({ QtGui_PackedString tempVal = callbackQStandardItemModel_MimeTypes(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("|", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
QVariant data(const QModelIndex & index, int role) const { return *static_cast<QVariant*>(callbackQStandardItemModel_Data(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index), role)); };
QVariant headerData(int section, Qt::Orientation orientation, int role) const { return *static_cast<QVariant*>(callbackQStandardItemModel_HeaderData(const_cast<void*>(static_cast<const void*>(this)), section, orientation, role)); };
Qt::DropActions supportedDropActions() const { return static_cast<Qt::DropAction>(callbackQStandardItemModel_SupportedDropActions(const_cast<void*>(static_cast<const void*>(this)))); };
Qt::ItemFlags flags(const QModelIndex & index) const { return static_cast<Qt::ItemFlag>(callbackQStandardItemModel_Flags(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool hasChildren(const QModelIndex & parent) const { return callbackQStandardItemModel_HasChildren(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQStandardItemModel_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
int columnCount(const QModelIndex & parent) const { return callbackQStandardItemModel_ColumnCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
int rowCount(const QModelIndex & parent) const { return callbackQStandardItemModel_RowCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
bool moveColumns(const QModelIndex & sourceParent, int sourceColumn, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQStandardItemModel_MoveColumns(this, const_cast<QModelIndex*>(&sourceParent), sourceColumn, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
bool moveRows(const QModelIndex & sourceParent, int sourceRow, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQStandardItemModel_MoveRows(this, const_cast<QModelIndex*>(&sourceParent), sourceRow, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
bool submit() { return callbackQStandardItemModel_Submit(this) != 0; };
void Signal_ColumnsAboutToBeInserted(const QModelIndex & parent, int first, int last) { callbackQStandardItemModel_ColumnsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationColumn) { callbackQStandardItemModel_ColumnsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationColumn); };
void Signal_ColumnsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQStandardItemModel_ColumnsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsInserted(const QModelIndex & parent, int first, int last) { callbackQStandardItemModel_ColumnsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int column) { callbackQStandardItemModel_ColumnsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), column); };
void Signal_ColumnsRemoved(const QModelIndex & parent, int first, int last) { callbackQStandardItemModel_ColumnsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_DataChanged(const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles) { callbackQStandardItemModel_DataChanged(this, const_cast<QModelIndex*>(&topLeft), const_cast<QModelIndex*>(&bottomRight), ({ QVector<int>* tmpValue = const_cast<QVector<int>*>(&roles); QtGui_PackedList { tmpValue, tmpValue->size() }; })); };
void fetchMore(const QModelIndex & parent) { callbackQStandardItemModel_FetchMore(this, const_cast<QModelIndex*>(&parent)); };
void Signal_HeaderDataChanged(Qt::Orientation orientation, int first, int last) { callbackQStandardItemModel_HeaderDataChanged(this, orientation, first, last); };
void Signal_LayoutAboutToBeChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQStandardItemModel_LayoutAboutToBeChanged(this, ({ QList<QPersistentModelIndex>* tmpValue = const_cast<QList<QPersistentModelIndex>*>(&parents); QtGui_PackedList { tmpValue, tmpValue->size() }; }), hint); };
void Signal_LayoutChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQStandardItemModel_LayoutChanged(this, ({ QList<QPersistentModelIndex>* tmpValue = const_cast<QList<QPersistentModelIndex>*>(&parents); QtGui_PackedList { tmpValue, tmpValue->size() }; }), hint); };
void Signal_ModelAboutToBeReset() { callbackQStandardItemModel_ModelAboutToBeReset(this); };
void Signal_ModelReset() { callbackQStandardItemModel_ModelReset(this); };
void resetInternalData() { callbackQStandardItemModel_ResetInternalData(this); };
void revert() { callbackQStandardItemModel_Revert(this); };
void Signal_RowsAboutToBeInserted(const QModelIndex & parent, int start, int end) { callbackQStandardItemModel_RowsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
void Signal_RowsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationRow) { callbackQStandardItemModel_RowsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationRow); };
void Signal_RowsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQStandardItemModel_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_RowsInserted(const QModelIndex & parent, int first, int last) { callbackQStandardItemModel_RowsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_RowsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int row) { callbackQStandardItemModel_RowsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), row); };
void Signal_RowsRemoved(const QModelIndex & parent, int first, int last) { callbackQStandardItemModel_RowsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
QHash<int, QByteArray> roleNames() const { return ({ QHash<int, QByteArray>* tmpP = static_cast<QHash<int, QByteArray>*>(callbackQStandardItemModel_RoleNames(const_cast<void*>(static_cast<const void*>(this)))); QHash<int, QByteArray> tmpV = *tmpP; tmpP->~QHash(); free(tmpP); tmpV; }); };
QModelIndex buddy(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQStandardItemModel_Buddy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
QList<QModelIndex> match(const QModelIndex & start, int role, const QVariant & value, int hits, Qt::MatchFlags flags) const { return ({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(callbackQStandardItemModel_Match(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&start), role, const_cast<QVariant*>(&value), hits, flags)); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
QSize span(const QModelIndex & index) const { return *static_cast<QSize*>(callbackQStandardItemModel_Span(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
Qt::DropActions supportedDragActions() const { return static_cast<Qt::DropAction>(callbackQStandardItemModel_SupportedDragActions(const_cast<void*>(static_cast<const void*>(this)))); };
bool canDropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) const { return callbackQStandardItemModel_CanDropMimeData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
bool canFetchMore(const QModelIndex & parent) const { return callbackQStandardItemModel_CanFetchMore(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
bool event(QEvent * e) { return callbackQStandardItemModel_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQStandardItemModel_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQStandardItemModel_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQStandardItemModel_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQStandardItemModel_CustomEvent(this, event); };
void deleteLater() { callbackQStandardItemModel_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQStandardItemModel_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQStandardItemModel_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQStandardItemModel_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQStandardItemModel_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQStandardItemModel*)
int QStandardItemModel_QStandardItemModel_QRegisterMetaType(){qRegisterMetaType<QStandardItemModel*>(); return qRegisterMetaType<MyQStandardItemModel*>();}
struct QtGui_PackedList QStandardItemModel_TakeColumn(void* ptr, int column)
{
return ({ QList<QStandardItem *>* tmpValue = new QList<QStandardItem *>(static_cast<QStandardItemModel*>(ptr)->takeColumn(column)); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedList QStandardItemModel_TakeRow(void* ptr, int row)
{
return ({ QList<QStandardItem *>* tmpValue = new QList<QStandardItem *>(static_cast<QStandardItemModel*>(ptr)->takeRow(row)); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QStandardItemModel_TakeHorizontalHeaderItem(void* ptr, int column)
{
return static_cast<QStandardItemModel*>(ptr)->takeHorizontalHeaderItem(column);
}
void* QStandardItemModel_TakeItem(void* ptr, int row, int column)
{
return static_cast<QStandardItemModel*>(ptr)->takeItem(row, column);
}
void* QStandardItemModel_TakeVerticalHeaderItem(void* ptr, int row)
{
return static_cast<QStandardItemModel*>(ptr)->takeVerticalHeaderItem(row);
}
void* QStandardItemModel_NewQStandardItemModel(void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(static_cast<QWindow*>(parent));
} else {
return new MyQStandardItemModel(static_cast<QObject*>(parent));
}
}
void* QStandardItemModel_NewQStandardItemModel2(int rows, int columns, void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(rows, columns, static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(rows, columns, static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(rows, columns, static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(rows, columns, static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(rows, columns, static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(rows, columns, static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(rows, columns, static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(rows, columns, static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(rows, columns, static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(rows, columns, static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(rows, columns, static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(rows, columns, static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(rows, columns, static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(rows, columns, static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(rows, columns, static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQStandardItemModel(rows, columns, static_cast<QWindow*>(parent));
} else {
return new MyQStandardItemModel(rows, columns, static_cast<QObject*>(parent));
}
}
struct QtGui_PackedString QStandardItemModel_QStandardItemModel_Tr(char* s, char* c, int n)
{
return ({ QByteArray td4ff8c = QStandardItemModel::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(td4ff8c.prepend("WHITESPACE").constData()+10), td4ff8c.size()-10 }; });
}
struct QtGui_PackedString QStandardItemModel_QStandardItemModel_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray ta85b5b = QStandardItemModel::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(ta85b5b.prepend("WHITESPACE").constData()+10), ta85b5b.size()-10 }; });
}
char QStandardItemModel_DropMimeDataDefault(void* ptr, void* data, long long action, int row, int column, void* parent)
{
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::dropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
}
char QStandardItemModel_InsertColumnsDefault(void* ptr, int column, int count, void* parent)
{
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::insertColumns(column, count, *static_cast<QModelIndex*>(parent));
}
char QStandardItemModel_InsertRowsDefault(void* ptr, int row, int count, void* parent)
{
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::insertRows(row, count, *static_cast<QModelIndex*>(parent));
}
char QStandardItemModel_RemoveColumnsDefault(void* ptr, int column, int count, void* parent)
{
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::removeColumns(column, count, *static_cast<QModelIndex*>(parent));
}
char QStandardItemModel_RemoveRowsDefault(void* ptr, int row, int count, void* parent)
{
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::removeRows(row, count, *static_cast<QModelIndex*>(parent));
}
char QStandardItemModel_SetDataDefault(void* ptr, void* index, void* value, int role)
{
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::setData(*static_cast<QModelIndex*>(index), *static_cast<QVariant*>(value), role);
}
char QStandardItemModel_SetHeaderDataDefault(void* ptr, int section, long long orientation, void* value, int role)
{
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::setHeaderData(section, static_cast<Qt::Orientation>(orientation), *static_cast<QVariant*>(value), role);
}
char QStandardItemModel_SetItemDataDefault(void* ptr, void* index, void* roles)
{
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::setItemData(*static_cast<QModelIndex*>(index), *static_cast<QMap<int, QVariant>*>(roles));
}
void QStandardItemModel_AppendColumn(void* ptr, void* items)
{
static_cast<QStandardItemModel*>(ptr)->appendColumn(*static_cast<QList<QStandardItem *>*>(items));
}
void QStandardItemModel_AppendRow2(void* ptr, void* item)
{
static_cast<QStandardItemModel*>(ptr)->appendRow(static_cast<QStandardItem*>(item));
}
void QStandardItemModel_AppendRow(void* ptr, void* items)
{
static_cast<QStandardItemModel*>(ptr)->appendRow(*static_cast<QList<QStandardItem *>*>(items));
}
void QStandardItemModel_Clear(void* ptr)
{
static_cast<QStandardItemModel*>(ptr)->clear();
}
void QStandardItemModel_InsertColumn(void* ptr, int column, void* items)
{
static_cast<QStandardItemModel*>(ptr)->insertColumn(column, *static_cast<QList<QStandardItem *>*>(items));
}
void QStandardItemModel_InsertRow2(void* ptr, int row, void* item)
{
static_cast<QStandardItemModel*>(ptr)->insertRow(row, static_cast<QStandardItem*>(item));
}
void QStandardItemModel_InsertRow(void* ptr, int row, void* items)
{
static_cast<QStandardItemModel*>(ptr)->insertRow(row, *static_cast<QList<QStandardItem *>*>(items));
}
void QStandardItemModel_ConnectItemChanged(void* ptr)
{
QObject::connect(static_cast<QStandardItemModel*>(ptr), static_cast<void (QStandardItemModel::*)(QStandardItem *)>(&QStandardItemModel::itemChanged), static_cast<MyQStandardItemModel*>(ptr), static_cast<void (MyQStandardItemModel::*)(QStandardItem *)>(&MyQStandardItemModel::Signal_ItemChanged));
}
void QStandardItemModel_DisconnectItemChanged(void* ptr)
{
QObject::disconnect(static_cast<QStandardItemModel*>(ptr), static_cast<void (QStandardItemModel::*)(QStandardItem *)>(&QStandardItemModel::itemChanged), static_cast<MyQStandardItemModel*>(ptr), static_cast<void (MyQStandardItemModel::*)(QStandardItem *)>(&MyQStandardItemModel::Signal_ItemChanged));
}
void QStandardItemModel_ItemChanged(void* ptr, void* item)
{
static_cast<QStandardItemModel*>(ptr)->itemChanged(static_cast<QStandardItem*>(item));
}
void QStandardItemModel_SetColumnCount(void* ptr, int columns)
{
static_cast<QStandardItemModel*>(ptr)->setColumnCount(columns);
}
void QStandardItemModel_SetHorizontalHeaderItem(void* ptr, int column, void* item)
{
static_cast<QStandardItemModel*>(ptr)->setHorizontalHeaderItem(column, static_cast<QStandardItem*>(item));
}
void QStandardItemModel_SetHorizontalHeaderLabels(void* ptr, struct QtGui_PackedString labels)
{
static_cast<QStandardItemModel*>(ptr)->setHorizontalHeaderLabels(QString::fromUtf8(labels.data, labels.len).split("|", QString::SkipEmptyParts));
}
void QStandardItemModel_SetItem2(void* ptr, int row, void* item)
{
static_cast<QStandardItemModel*>(ptr)->setItem(row, static_cast<QStandardItem*>(item));
}
void QStandardItemModel_SetItem(void* ptr, int row, int column, void* item)
{
static_cast<QStandardItemModel*>(ptr)->setItem(row, column, static_cast<QStandardItem*>(item));
}
void QStandardItemModel_SetItemPrototype(void* ptr, void* item)
{
static_cast<QStandardItemModel*>(ptr)->setItemPrototype(static_cast<QStandardItem*>(item));
}
void QStandardItemModel_SetItemRoleNames(void* ptr, void* roleNames)
{
static_cast<QStandardItemModel*>(ptr)->setItemRoleNames(*static_cast<QHash<int, QByteArray>*>(roleNames));
}
void QStandardItemModel_SetRowCount(void* ptr, int rows)
{
static_cast<QStandardItemModel*>(ptr)->setRowCount(rows);
}
void QStandardItemModel_SetSortRole(void* ptr, int role)
{
static_cast<QStandardItemModel*>(ptr)->setSortRole(role);
}
void QStandardItemModel_SetVerticalHeaderItem(void* ptr, int row, void* item)
{
static_cast<QStandardItemModel*>(ptr)->setVerticalHeaderItem(row, static_cast<QStandardItem*>(item));
}
void QStandardItemModel_SetVerticalHeaderLabels(void* ptr, struct QtGui_PackedString labels)
{
static_cast<QStandardItemModel*>(ptr)->setVerticalHeaderLabels(QString::fromUtf8(labels.data, labels.len).split("|", QString::SkipEmptyParts));
}
void QStandardItemModel_SortDefault(void* ptr, int column, long long order)
{
static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::sort(column, static_cast<Qt::SortOrder>(order));
}
void QStandardItemModel_DestroyQStandardItemModel(void* ptr)
{
static_cast<QStandardItemModel*>(ptr)->~QStandardItemModel();
}
void QStandardItemModel_DestroyQStandardItemModelDefault(void* ptr)
{
Q_UNUSED(ptr);
}
struct QtGui_PackedList QStandardItemModel_FindItems(void* ptr, struct QtGui_PackedString text, long long flags, int column)
{
return ({ QList<QStandardItem *>* tmpValue = new QList<QStandardItem *>(static_cast<QStandardItemModel*>(ptr)->findItems(QString::fromUtf8(text.data, text.len), static_cast<Qt::MatchFlag>(flags), column)); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedList QStandardItemModel_ItemDataDefault(void* ptr, void* index)
{
return ({ QMap<int, QVariant>* tmpValue = new QMap<int, QVariant>(static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::itemData(*static_cast<QModelIndex*>(index))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QStandardItemModel_MimeDataDefault(void* ptr, void* indexes)
{
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::mimeData(({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(indexes); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }));
}
void* QStandardItemModel_Index(void* ptr, int row, int column, void* parent)
{
return new QModelIndex(static_cast<QStandardItemModel*>(ptr)->index(row, column, *static_cast<QModelIndex*>(parent)));
}
void* QStandardItemModel_IndexDefault(void* ptr, int row, int column, void* parent)
{
return new QModelIndex(static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::index(row, column, *static_cast<QModelIndex*>(parent)));
}
void* QStandardItemModel_IndexFromItem(void* ptr, void* item)
{
return new QModelIndex(static_cast<QStandardItemModel*>(ptr)->indexFromItem(static_cast<QStandardItem*>(item)));
}
void* QStandardItemModel_Parent(void* ptr, void* child)
{
return new QModelIndex(static_cast<QStandardItemModel*>(ptr)->parent(*static_cast<QModelIndex*>(child)));
}
void* QStandardItemModel_ParentDefault(void* ptr, void* child)
{
return new QModelIndex(static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::parent(*static_cast<QModelIndex*>(child)));
}
void* QStandardItemModel_SiblingDefault(void* ptr, int row, int column, void* idx)
{
return new QModelIndex(static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::sibling(row, column, *static_cast<QModelIndex*>(idx)));
}
void* QStandardItemModel_HorizontalHeaderItem(void* ptr, int column)
{
return static_cast<QStandardItemModel*>(ptr)->horizontalHeaderItem(column);
}
void* QStandardItemModel_InvisibleRootItem(void* ptr)
{
return static_cast<QStandardItemModel*>(ptr)->invisibleRootItem();
}
void* QStandardItemModel_Item(void* ptr, int row, int column)
{
return static_cast<QStandardItemModel*>(ptr)->item(row, column);
}
void* QStandardItemModel_ItemFromIndex(void* ptr, void* index)
{
return static_cast<QStandardItemModel*>(ptr)->itemFromIndex(*static_cast<QModelIndex*>(index));
}
void* QStandardItemModel_VerticalHeaderItem(void* ptr, int row)
{
return static_cast<QStandardItemModel*>(ptr)->verticalHeaderItem(row);
}
struct QtGui_PackedString QStandardItemModel_MimeTypesDefault(void* ptr)
{
return ({ QByteArray t83a37d = static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::mimeTypes().join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t83a37d.prepend("WHITESPACE").constData()+10), t83a37d.size()-10 }; });
}
void* QStandardItemModel_Data(void* ptr, void* index, int role)
{
return new QVariant(static_cast<QStandardItemModel*>(ptr)->data(*static_cast<QModelIndex*>(index), role));
}
void* QStandardItemModel_DataDefault(void* ptr, void* index, int role)
{
return new QVariant(static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::data(*static_cast<QModelIndex*>(index), role));
}
void* QStandardItemModel_HeaderDataDefault(void* ptr, int section, long long orientation, int role)
{
return new QVariant(static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::headerData(section, static_cast<Qt::Orientation>(orientation), role));
}
long long QStandardItemModel_SupportedDropActionsDefault(void* ptr)
{
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::supportedDropActions();
}
long long QStandardItemModel_FlagsDefault(void* ptr, void* index)
{
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::flags(*static_cast<QModelIndex*>(index));
}
char QStandardItemModel_HasChildrenDefault(void* ptr, void* parent)
{
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::hasChildren(*static_cast<QModelIndex*>(parent));
}
void* QStandardItemModel_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::metaObject());
}
void* QStandardItemModel_ItemPrototype(void* ptr)
{
return const_cast<QStandardItem*>(static_cast<QStandardItemModel*>(ptr)->itemPrototype());
}
int QStandardItemModel_ColumnCount(void* ptr, void* parent)
{
return static_cast<QStandardItemModel*>(ptr)->columnCount(*static_cast<QModelIndex*>(parent));
}
int QStandardItemModel_ColumnCountDefault(void* ptr, void* parent)
{
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::columnCount(*static_cast<QModelIndex*>(parent));
}
int QStandardItemModel_RowCount(void* ptr, void* parent)
{
return static_cast<QStandardItemModel*>(ptr)->rowCount(*static_cast<QModelIndex*>(parent));
}
int QStandardItemModel_RowCountDefault(void* ptr, void* parent)
{
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::rowCount(*static_cast<QModelIndex*>(parent));
}
int QStandardItemModel_SortRole(void* ptr)
{
return static_cast<QStandardItemModel*>(ptr)->sortRole();
}
void* QStandardItemModel___takeColumn_atList(void* ptr, int i)
{
return ({QStandardItem * tmp = static_cast<QList<QStandardItem *>*>(ptr)->at(i); if (i == static_cast<QList<QStandardItem *>*>(ptr)->size()-1) { static_cast<QList<QStandardItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItemModel___takeColumn_setList(void* ptr, void* i)
{
static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}
void* QStandardItemModel___takeColumn_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QStandardItem *>();
}
void* QStandardItemModel___takeRow_atList(void* ptr, int i)
{
return ({QStandardItem * tmp = static_cast<QList<QStandardItem *>*>(ptr)->at(i); if (i == static_cast<QList<QStandardItem *>*>(ptr)->size()-1) { static_cast<QList<QStandardItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItemModel___takeRow_setList(void* ptr, void* i)
{
static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}
void* QStandardItemModel___takeRow_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QStandardItem *>();
}
void* QStandardItemModel___setItemData_roles_atList(void* ptr, int v, int i)
{
return new QVariant(({ QVariant tmp = static_cast<QMap<int, QVariant>*>(ptr)->value(v); if (i == static_cast<QMap<int, QVariant>*>(ptr)->size()-1) { static_cast<QMap<int, QVariant>*>(ptr)->~QMap(); free(ptr); }; tmp; }));
}
void QStandardItemModel___setItemData_roles_setList(void* ptr, int key, void* i)
{
static_cast<QMap<int, QVariant>*>(ptr)->insert(key, *static_cast<QVariant*>(i));
}
void* QStandardItemModel___setItemData_roles_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QMap<int, QVariant>();
}
struct QtGui_PackedList QStandardItemModel___setItemData_keyList(void* ptr)
{
return ({ QList<int>* tmpValue = new QList<int>(static_cast<QMap<int, QVariant>*>(ptr)->keys()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QStandardItemModel___appendColumn_items_atList(void* ptr, int i)
{
return ({QStandardItem * tmp = static_cast<QList<QStandardItem *>*>(ptr)->at(i); if (i == static_cast<QList<QStandardItem *>*>(ptr)->size()-1) { static_cast<QList<QStandardItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItemModel___appendColumn_items_setList(void* ptr, void* i)
{
static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}
void* QStandardItemModel___appendColumn_items_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QStandardItem *>();
}
void* QStandardItemModel___appendRow_items_atList(void* ptr, int i)
{
return ({QStandardItem * tmp = static_cast<QList<QStandardItem *>*>(ptr)->at(i); if (i == static_cast<QList<QStandardItem *>*>(ptr)->size()-1) { static_cast<QList<QStandardItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItemModel___appendRow_items_setList(void* ptr, void* i)
{
static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}
void* QStandardItemModel___appendRow_items_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QStandardItem *>();
}
void* QStandardItemModel___insertColumn_items_atList(void* ptr, int i)
{
return ({QStandardItem * tmp = static_cast<QList<QStandardItem *>*>(ptr)->at(i); if (i == static_cast<QList<QStandardItem *>*>(ptr)->size()-1) { static_cast<QList<QStandardItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItemModel___insertColumn_items_setList(void* ptr, void* i)
{
static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}
void* QStandardItemModel___insertColumn_items_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QStandardItem *>();
}
void* QStandardItemModel___insertRow_items_atList(void* ptr, int i)
{
return ({QStandardItem * tmp = static_cast<QList<QStandardItem *>*>(ptr)->at(i); if (i == static_cast<QList<QStandardItem *>*>(ptr)->size()-1) { static_cast<QList<QStandardItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItemModel___insertRow_items_setList(void* ptr, void* i)
{
static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}
void* QStandardItemModel___insertRow_items_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QStandardItem *>();
}
void* QStandardItemModel___setItemRoleNames_roleNames_atList(void* ptr, int v, int i)
{
return new QByteArray(({ QByteArray tmp = static_cast<QHash<int, QByteArray>*>(ptr)->value(v); if (i == static_cast<QHash<int, QByteArray>*>(ptr)->size()-1) { static_cast<QHash<int, QByteArray>*>(ptr)->~QHash(); free(ptr); }; tmp; }));
}
void QStandardItemModel___setItemRoleNames_roleNames_setList(void* ptr, int key, void* i)
{
static_cast<QHash<int, QByteArray>*>(ptr)->insert(key, *static_cast<QByteArray*>(i));
}
void* QStandardItemModel___setItemRoleNames_roleNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QHash<int, QByteArray>();
}
struct QtGui_PackedList QStandardItemModel___setItemRoleNames_keyList(void* ptr)
{
return ({ QList<int>* tmpValue = new QList<int>(static_cast<QHash<int, QByteArray>*>(ptr)->keys()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QStandardItemModel___findItems_atList(void* ptr, int i)
{
return ({QStandardItem * tmp = static_cast<QList<QStandardItem *>*>(ptr)->at(i); if (i == static_cast<QList<QStandardItem *>*>(ptr)->size()-1) { static_cast<QList<QStandardItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItemModel___findItems_setList(void* ptr, void* i)
{
static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}
void* QStandardItemModel___findItems_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QStandardItem *>();
}
void* QStandardItemModel___itemData_atList(void* ptr, int v, int i)
{
return new QVariant(({ QVariant tmp = static_cast<QMap<int, QVariant>*>(ptr)->value(v); if (i == static_cast<QMap<int, QVariant>*>(ptr)->size()-1) { static_cast<QMap<int, QVariant>*>(ptr)->~QMap(); free(ptr); }; tmp; }));
}
void QStandardItemModel___itemData_setList(void* ptr, int key, void* i)
{
static_cast<QMap<int, QVariant>*>(ptr)->insert(key, *static_cast<QVariant*>(i));
}
void* QStandardItemModel___itemData_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QMap<int, QVariant>();
}
struct QtGui_PackedList QStandardItemModel___itemData_keyList(void* ptr)
{
return ({ QList<int>* tmpValue = new QList<int>(static_cast<QMap<int, QVariant>*>(ptr)->keys()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QStandardItemModel___mimeData_indexes_atList(void* ptr, int i)
{
return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QStandardItemModel___mimeData_indexes_setList(void* ptr, void* i)
{
static_cast<QList<QModelIndex>*>(ptr)->append(*static_cast<QModelIndex*>(i));
}
void* QStandardItemModel___mimeData_indexes_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QModelIndex>();
}
int QStandardItemModel_____setItemData_keyList_atList(void* ptr, int i)
{
return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItemModel_____setItemData_keyList_setList(void* ptr, int i)
{
static_cast<QList<int>*>(ptr)->append(i);
}
void* QStandardItemModel_____setItemData_keyList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<int>();
}
int QStandardItemModel_____setItemRoleNames_keyList_atList(void* ptr, int i)
{
return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItemModel_____setItemRoleNames_keyList_setList(void* ptr, int i)
{
static_cast<QList<int>*>(ptr)->append(i);
}
void* QStandardItemModel_____setItemRoleNames_keyList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<int>();
}
int QStandardItemModel_____itemData_keyList_atList(void* ptr, int i)
{
return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItemModel_____itemData_keyList_setList(void* ptr, int i)
{
static_cast<QList<int>*>(ptr)->append(i);
}
void* QStandardItemModel_____itemData_keyList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<int>();
}
void* QStandardItemModel___changePersistentIndexList_from_atList(void* ptr, int i)
{
return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QStandardItemModel___changePersistentIndexList_from_setList(void* ptr, void* i)
{
static_cast<QList<QModelIndex>*>(ptr)->append(*static_cast<QModelIndex*>(i));
}
void* QStandardItemModel___changePersistentIndexList_from_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QModelIndex>();
}
void* QStandardItemModel___changePersistentIndexList_to_atList(void* ptr, int i)
{
return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QStandardItemModel___changePersistentIndexList_to_setList(void* ptr, void* i)
{
static_cast<QList<QModelIndex>*>(ptr)->append(*static_cast<QModelIndex*>(i));
}
void* QStandardItemModel___changePersistentIndexList_to_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QModelIndex>();
}
int QStandardItemModel___dataChanged_roles_atList(void* ptr, int i)
{
return ({int tmp = static_cast<QVector<int>*>(ptr)->at(i); if (i == static_cast<QVector<int>*>(ptr)->size()-1) { static_cast<QVector<int>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QStandardItemModel___dataChanged_roles_setList(void* ptr, int i)
{
static_cast<QVector<int>*>(ptr)->append(i);
}
void* QStandardItemModel___dataChanged_roles_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<int>();
}
void* QStandardItemModel___layoutAboutToBeChanged_parents_atList(void* ptr, int i)
{
return new QPersistentModelIndex(({QPersistentModelIndex tmp = static_cast<QList<QPersistentModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QPersistentModelIndex>*>(ptr)->size()-1) { static_cast<QList<QPersistentModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QStandardItemModel___layoutAboutToBeChanged_parents_setList(void* ptr, void* i)
{
static_cast<QList<QPersistentModelIndex>*>(ptr)->append(*static_cast<QPersistentModelIndex*>(i));
}
void* QStandardItemModel___layoutAboutToBeChanged_parents_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QPersistentModelIndex>();
}
void* QStandardItemModel___layoutChanged_parents_atList(void* ptr, int i)
{
return new QPersistentModelIndex(({QPersistentModelIndex tmp = static_cast<QList<QPersistentModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QPersistentModelIndex>*>(ptr)->size()-1) { static_cast<QList<QPersistentModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QStandardItemModel___layoutChanged_parents_setList(void* ptr, void* i)
{
static_cast<QList<QPersistentModelIndex>*>(ptr)->append(*static_cast<QPersistentModelIndex*>(i));
}
void* QStandardItemModel___layoutChanged_parents_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QPersistentModelIndex>();
}
void* QStandardItemModel___roleNames_atList(void* ptr, int v, int i)
{
return new QByteArray(({ QByteArray tmp = static_cast<QHash<int, QByteArray>*>(ptr)->value(v); if (i == static_cast<QHash<int, QByteArray>*>(ptr)->size()-1) { static_cast<QHash<int, QByteArray>*>(ptr)->~QHash(); free(ptr); }; tmp; }));
}
void QStandardItemModel___roleNames_setList(void* ptr, int key, void* i)
{
static_cast<QHash<int, QByteArray>*>(ptr)->insert(key, *static_cast<QByteArray*>(i));
}
void* QStandardItemModel___roleNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QHash<int, QByteArray>();
}
struct QtGui_PackedList QStandardItemModel___roleNames_keyList(void* ptr)
{
return ({ QList<int>* tmpValue = new QList<int>(static_cast<QHash<int, QByteArray>*>(ptr)->keys()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QStandardItemModel___match_atList(void* ptr, int i)
{
return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QStandardItemModel___match_setList(void* ptr, void* i)
{
static_cast<QList<QModelIndex>*>(ptr)->append(*static_cast<QModelIndex*>(i));
}
void* QStandardItemModel___match_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QModelIndex>();
}
void* QStandardItemModel___persistentIndexList_atList(void* ptr, int i)
{
return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QStandardItemModel___persistentIndexList_setList(void* ptr, void* i)
{
static_cast<QList<QModelIndex>*>(ptr)->append(*static_cast<QModelIndex*>(i));
}
void* QStandardItemModel___persistentIndexList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QModelIndex>();
}
int QStandardItemModel_____doSetRoleNames_keyList_atList(void* ptr, int i)
{
return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItemModel_____doSetRoleNames_keyList_setList(void* ptr, int i)
{
static_cast<QList<int>*>(ptr)->append(i);
}
void* QStandardItemModel_____doSetRoleNames_keyList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<int>();
}
int QStandardItemModel_____setRoleNames_keyList_atList(void* ptr, int i)
{
return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItemModel_____setRoleNames_keyList_setList(void* ptr, int i)
{
static_cast<QList<int>*>(ptr)->append(i);
}
void* QStandardItemModel_____setRoleNames_keyList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<int>();
}
int QStandardItemModel_____roleNames_keyList_atList(void* ptr, int i)
{
return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItemModel_____roleNames_keyList_setList(void* ptr, int i)
{
static_cast<QList<int>*>(ptr)->append(i);
}
void* QStandardItemModel_____roleNames_keyList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<int>();
}
void* QStandardItemModel___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QStandardItemModel___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QStandardItemModel___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QStandardItemModel___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItemModel___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QStandardItemModel___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QStandardItemModel___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItemModel___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QStandardItemModel___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QStandardItemModel___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItemModel___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QStandardItemModel___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QStandardItemModel___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStandardItemModel___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QStandardItemModel___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QStandardItemModel_MoveColumnsDefault(void* ptr, void* sourceParent, int sourceColumn, int count, void* destinationParent, int destinationChild)
{
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::moveColumns(*static_cast<QModelIndex*>(sourceParent), sourceColumn, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
}
char QStandardItemModel_MoveRowsDefault(void* ptr, void* sourceParent, int sourceRow, int count, void* destinationParent, int destinationChild)
{
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::moveRows(*static_cast<QModelIndex*>(sourceParent), sourceRow, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
}
char QStandardItemModel_SubmitDefault(void* ptr)
{
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::submit();
}
void QStandardItemModel_FetchMoreDefault(void* ptr, void* parent)
{
static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::fetchMore(*static_cast<QModelIndex*>(parent));
}
void QStandardItemModel_ResetInternalDataDefault(void* ptr)
{
static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::resetInternalData();
}
void QStandardItemModel_RevertDefault(void* ptr)
{
static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::revert();
}
struct QtGui_PackedList QStandardItemModel_RoleNamesDefault(void* ptr)
{
return ({ QHash<int, QByteArray>* tmpValue = new QHash<int, QByteArray>(static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::roleNames()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QStandardItemModel_BuddyDefault(void* ptr, void* index)
{
return new QModelIndex(static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::buddy(*static_cast<QModelIndex*>(index)));
}
struct QtGui_PackedList QStandardItemModel_MatchDefault(void* ptr, void* start, int role, void* value, int hits, long long flags)
{
return ({ QList<QModelIndex>* tmpValue = new QList<QModelIndex>(static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::match(*static_cast<QModelIndex*>(start), role, *static_cast<QVariant*>(value), hits, static_cast<Qt::MatchFlag>(flags))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QStandardItemModel_SpanDefault(void* ptr, void* index)
{
return ({ QSize tmpValue = static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::span(*static_cast<QModelIndex*>(index)); new QSize(tmpValue.width(), tmpValue.height()); });
}
long long QStandardItemModel_SupportedDragActionsDefault(void* ptr)
{
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::supportedDragActions();
}
char QStandardItemModel_CanDropMimeDataDefault(void* ptr, void* data, long long action, int row, int column, void* parent)
{
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::canDropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
}
char QStandardItemModel_CanFetchMoreDefault(void* ptr, void* parent)
{
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::canFetchMore(*static_cast<QModelIndex*>(parent));
}
char QStandardItemModel_EventDefault(void* ptr, void* e)
{
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::event(static_cast<QEvent*>(e));
}
char QStandardItemModel_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QStandardItemModel_ChildEventDefault(void* ptr, void* event)
{
static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::childEvent(static_cast<QChildEvent*>(event));
}
void QStandardItemModel_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QStandardItemModel_CustomEventDefault(void* ptr, void* event)
{
static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::customEvent(static_cast<QEvent*>(event));
}
void QStandardItemModel_DeleteLaterDefault(void* ptr)
{
static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::deleteLater();
}
void QStandardItemModel_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QStandardItemModel_TimerEventDefault(void* ptr, void* event)
{
static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::timerEvent(static_cast<QTimerEvent*>(event));
}
void* QStaticText_NewQStaticText()
{
return new QStaticText();
}
void* QStaticText_NewQStaticText3(void* other)
{
return new QStaticText(*static_cast<QStaticText*>(other));
}
void* QStaticText_NewQStaticText2(struct QtGui_PackedString text)
{
return new QStaticText(QString::fromUtf8(text.data, text.len));
}
void QStaticText_Prepare(void* ptr, void* matrix, void* font)
{
static_cast<QStaticText*>(ptr)->prepare(*static_cast<QTransform*>(matrix), *static_cast<QFont*>(font));
}
void QStaticText_SetPerformanceHint(void* ptr, long long performanceHint)
{
static_cast<QStaticText*>(ptr)->setPerformanceHint(static_cast<QStaticText::PerformanceHint>(performanceHint));
}
void QStaticText_SetText(void* ptr, struct QtGui_PackedString text)
{
static_cast<QStaticText*>(ptr)->setText(QString::fromUtf8(text.data, text.len));
}
void QStaticText_SetTextFormat(void* ptr, long long textFormat)
{
static_cast<QStaticText*>(ptr)->setTextFormat(static_cast<Qt::TextFormat>(textFormat));
}
void QStaticText_SetTextOption(void* ptr, void* textOption)
{
static_cast<QStaticText*>(ptr)->setTextOption(*static_cast<QTextOption*>(textOption));
}
void QStaticText_SetTextWidth(void* ptr, double textWidth)
{
static_cast<QStaticText*>(ptr)->setTextWidth(textWidth);
}
void QStaticText_Swap(void* ptr, void* other)
{
static_cast<QStaticText*>(ptr)->swap(*static_cast<QStaticText*>(other));
}
void QStaticText_DestroyQStaticText(void* ptr)
{
static_cast<QStaticText*>(ptr)->~QStaticText();
}
void* QStaticText_Size(void* ptr)
{
return ({ QSizeF tmpValue = static_cast<QStaticText*>(ptr)->size(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}
long long QStaticText_PerformanceHint(void* ptr)
{
return static_cast<QStaticText*>(ptr)->performanceHint();
}
struct QtGui_PackedString QStaticText_Text(void* ptr)
{
return ({ QByteArray t6fe556 = static_cast<QStaticText*>(ptr)->text().toUtf8(); QtGui_PackedString { const_cast<char*>(t6fe556.prepend("WHITESPACE").constData()+10), t6fe556.size()-10 }; });
}
void* QStaticText_TextOption(void* ptr)
{
return new QTextOption(static_cast<QStaticText*>(ptr)->textOption());
}
long long QStaticText_TextFormat(void* ptr)
{
return static_cast<QStaticText*>(ptr)->textFormat();
}
double QStaticText_TextWidth(void* ptr)
{
return static_cast<QStaticText*>(ptr)->textWidth();
}
class MyQStatusTipEvent: public QStatusTipEvent
{
public:
MyQStatusTipEvent(const QString &tip) : QStatusTipEvent(tip) {};
};
void* QStatusTipEvent_NewQStatusTipEvent(struct QtGui_PackedString tip)
{
return new MyQStatusTipEvent(QString::fromUtf8(tip.data, tip.len));
}
struct QtGui_PackedString QStatusTipEvent_Tip(void* ptr)
{
return ({ QByteArray t663d3b = static_cast<QStatusTipEvent*>(ptr)->tip().toUtf8(); QtGui_PackedString { const_cast<char*>(t663d3b.prepend("WHITESPACE").constData()+10), t663d3b.size()-10 }; });
}
class MyQStyleHints: public QStyleHints
{
public:
void Signal_CursorFlashTimeChanged(int cursorFlashTime) { callbackQStyleHints_CursorFlashTimeChanged(this, cursorFlashTime); };
void Signal_KeyboardInputIntervalChanged(int keyboardInputInterval) { callbackQStyleHints_KeyboardInputIntervalChanged(this, keyboardInputInterval); };
void Signal_MouseDoubleClickIntervalChanged(int mouseDoubleClickInterval) { callbackQStyleHints_MouseDoubleClickIntervalChanged(this, mouseDoubleClickInterval); };
void Signal_MousePressAndHoldIntervalChanged(int mousePressAndHoldInterval) { callbackQStyleHints_MousePressAndHoldIntervalChanged(this, mousePressAndHoldInterval); };
void Signal_MouseQuickSelectionThresholdChanged(int threshold) { callbackQStyleHints_MouseQuickSelectionThresholdChanged(this, threshold); };
void Signal_StartDragDistanceChanged(int startDragDistance) { callbackQStyleHints_StartDragDistanceChanged(this, startDragDistance); };
void Signal_StartDragTimeChanged(int startDragTime) { callbackQStyleHints_StartDragTimeChanged(this, startDragTime); };
void Signal_TabFocusBehaviorChanged(Qt::TabFocusBehavior tabFocusBehavior) { callbackQStyleHints_TabFocusBehaviorChanged(this, tabFocusBehavior); };
void Signal_UseHoverEffectsChanged(bool useHoverEffects) { callbackQStyleHints_UseHoverEffectsChanged(this, useHoverEffects); };
void Signal_WheelScrollLinesChanged(int scrollLines) { callbackQStyleHints_WheelScrollLinesChanged(this, scrollLines); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQStyleHints_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQStyleHints_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQStyleHints_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQStyleHints_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQStyleHints_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQStyleHints_CustomEvent(this, event); };
void deleteLater() { callbackQStyleHints_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQStyleHints_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQStyleHints_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQStyleHints_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQStyleHints_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQStyleHints*)
int QStyleHints_QStyleHints_QRegisterMetaType(){qRegisterMetaType<QStyleHints*>(); return qRegisterMetaType<MyQStyleHints*>();}
struct QtGui_PackedString QStyleHints_QStyleHints_Tr(char* s, char* c, int n)
{
return ({ QByteArray t98e56f = QStyleHints::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t98e56f.prepend("WHITESPACE").constData()+10), t98e56f.size()-10 }; });
}
struct QtGui_PackedString QStyleHints_QStyleHints_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray t706781 = QStyleHints::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t706781.prepend("WHITESPACE").constData()+10), t706781.size()-10 }; });
}
void QStyleHints_ConnectCursorFlashTimeChanged(void* ptr)
{
QObject::connect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::cursorFlashTimeChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_CursorFlashTimeChanged));
}
void QStyleHints_DisconnectCursorFlashTimeChanged(void* ptr)
{
QObject::disconnect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::cursorFlashTimeChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_CursorFlashTimeChanged));
}
void QStyleHints_CursorFlashTimeChanged(void* ptr, int cursorFlashTime)
{
static_cast<QStyleHints*>(ptr)->cursorFlashTimeChanged(cursorFlashTime);
}
void QStyleHints_ConnectKeyboardInputIntervalChanged(void* ptr)
{
QObject::connect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::keyboardInputIntervalChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_KeyboardInputIntervalChanged));
}
void QStyleHints_DisconnectKeyboardInputIntervalChanged(void* ptr)
{
QObject::disconnect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::keyboardInputIntervalChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_KeyboardInputIntervalChanged));
}
void QStyleHints_KeyboardInputIntervalChanged(void* ptr, int keyboardInputInterval)
{
static_cast<QStyleHints*>(ptr)->keyboardInputIntervalChanged(keyboardInputInterval);
}
void QStyleHints_ConnectMouseDoubleClickIntervalChanged(void* ptr)
{
QObject::connect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::mouseDoubleClickIntervalChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_MouseDoubleClickIntervalChanged));
}
void QStyleHints_DisconnectMouseDoubleClickIntervalChanged(void* ptr)
{
QObject::disconnect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::mouseDoubleClickIntervalChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_MouseDoubleClickIntervalChanged));
}
void QStyleHints_MouseDoubleClickIntervalChanged(void* ptr, int mouseDoubleClickInterval)
{
static_cast<QStyleHints*>(ptr)->mouseDoubleClickIntervalChanged(mouseDoubleClickInterval);
}
void QStyleHints_ConnectMousePressAndHoldIntervalChanged(void* ptr)
{
QObject::connect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::mousePressAndHoldIntervalChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_MousePressAndHoldIntervalChanged));
}
void QStyleHints_DisconnectMousePressAndHoldIntervalChanged(void* ptr)
{
QObject::disconnect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::mousePressAndHoldIntervalChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_MousePressAndHoldIntervalChanged));
}
void QStyleHints_MousePressAndHoldIntervalChanged(void* ptr, int mousePressAndHoldInterval)
{
static_cast<QStyleHints*>(ptr)->mousePressAndHoldIntervalChanged(mousePressAndHoldInterval);
}
void QStyleHints_ConnectMouseQuickSelectionThresholdChanged(void* ptr)
{
QObject::connect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::mouseQuickSelectionThresholdChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_MouseQuickSelectionThresholdChanged));
}
void QStyleHints_DisconnectMouseQuickSelectionThresholdChanged(void* ptr)
{
QObject::disconnect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::mouseQuickSelectionThresholdChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_MouseQuickSelectionThresholdChanged));
}
void QStyleHints_MouseQuickSelectionThresholdChanged(void* ptr, int threshold)
{
static_cast<QStyleHints*>(ptr)->mouseQuickSelectionThresholdChanged(threshold);
}
void QStyleHints_SetUseHoverEffects(void* ptr, char useHoverEffects)
{
static_cast<QStyleHints*>(ptr)->setUseHoverEffects(useHoverEffects != 0);
}
void QStyleHints_ConnectStartDragDistanceChanged(void* ptr)
{
QObject::connect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::startDragDistanceChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_StartDragDistanceChanged));
}
void QStyleHints_DisconnectStartDragDistanceChanged(void* ptr)
{
QObject::disconnect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::startDragDistanceChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_StartDragDistanceChanged));
}
void QStyleHints_StartDragDistanceChanged(void* ptr, int startDragDistance)
{
static_cast<QStyleHints*>(ptr)->startDragDistanceChanged(startDragDistance);
}
void QStyleHints_ConnectStartDragTimeChanged(void* ptr)
{
QObject::connect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::startDragTimeChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_StartDragTimeChanged));
}
void QStyleHints_DisconnectStartDragTimeChanged(void* ptr)
{
QObject::disconnect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::startDragTimeChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_StartDragTimeChanged));
}
void QStyleHints_StartDragTimeChanged(void* ptr, int startDragTime)
{
static_cast<QStyleHints*>(ptr)->startDragTimeChanged(startDragTime);
}
void QStyleHints_ConnectTabFocusBehaviorChanged(void* ptr)
{
qRegisterMetaType<Qt::TabFocusBehavior>();
QObject::connect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(Qt::TabFocusBehavior)>(&QStyleHints::tabFocusBehaviorChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(Qt::TabFocusBehavior)>(&MyQStyleHints::Signal_TabFocusBehaviorChanged));
}
void QStyleHints_DisconnectTabFocusBehaviorChanged(void* ptr)
{
QObject::disconnect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(Qt::TabFocusBehavior)>(&QStyleHints::tabFocusBehaviorChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(Qt::TabFocusBehavior)>(&MyQStyleHints::Signal_TabFocusBehaviorChanged));
}
void QStyleHints_TabFocusBehaviorChanged(void* ptr, long long tabFocusBehavior)
{
static_cast<QStyleHints*>(ptr)->tabFocusBehaviorChanged(static_cast<Qt::TabFocusBehavior>(tabFocusBehavior));
}
void QStyleHints_ConnectUseHoverEffectsChanged(void* ptr)
{
QObject::connect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(bool)>(&QStyleHints::useHoverEffectsChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(bool)>(&MyQStyleHints::Signal_UseHoverEffectsChanged));
}
void QStyleHints_DisconnectUseHoverEffectsChanged(void* ptr)
{
QObject::disconnect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(bool)>(&QStyleHints::useHoverEffectsChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(bool)>(&MyQStyleHints::Signal_UseHoverEffectsChanged));
}
void QStyleHints_UseHoverEffectsChanged(void* ptr, char useHoverEffects)
{
static_cast<QStyleHints*>(ptr)->useHoverEffectsChanged(useHoverEffects != 0);
}
void QStyleHints_ConnectWheelScrollLinesChanged(void* ptr)
{
QObject::connect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::wheelScrollLinesChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_WheelScrollLinesChanged));
}
void QStyleHints_DisconnectWheelScrollLinesChanged(void* ptr)
{
QObject::disconnect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::wheelScrollLinesChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_WheelScrollLinesChanged));
}
void QStyleHints_WheelScrollLinesChanged(void* ptr, int scrollLines)
{
static_cast<QStyleHints*>(ptr)->wheelScrollLinesChanged(scrollLines);
}
void* QStyleHints_PasswordMaskCharacter(void* ptr)
{
return new QChar(static_cast<QStyleHints*>(ptr)->passwordMaskCharacter());
}
long long QStyleHints_TabFocusBehavior(void* ptr)
{
return static_cast<QStyleHints*>(ptr)->tabFocusBehavior();
}
char QStyleHints_SetFocusOnTouchRelease(void* ptr)
{
return static_cast<QStyleHints*>(ptr)->setFocusOnTouchRelease();
}
char QStyleHints_ShowIsFullScreen(void* ptr)
{
return static_cast<QStyleHints*>(ptr)->showIsFullScreen();
}
char QStyleHints_ShowIsMaximized(void* ptr)
{
return static_cast<QStyleHints*>(ptr)->showIsMaximized();
}
char QStyleHints_ShowShortcutsInContextMenus(void* ptr)
{
return static_cast<QStyleHints*>(ptr)->showShortcutsInContextMenus();
}
char QStyleHints_SingleClickActivation(void* ptr)
{
return static_cast<QStyleHints*>(ptr)->singleClickActivation();
}
char QStyleHints_UseHoverEffects(void* ptr)
{
return static_cast<QStyleHints*>(ptr)->useHoverEffects();
}
char QStyleHints_UseRtlExtensions(void* ptr)
{
return static_cast<QStyleHints*>(ptr)->useRtlExtensions();
}
void* QStyleHints_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QStyleHints*>(ptr)->QStyleHints::metaObject());
}
int QStyleHints_CursorFlashTime(void* ptr)
{
return static_cast<QStyleHints*>(ptr)->cursorFlashTime();
}
int QStyleHints_KeyboardAutoRepeatRate(void* ptr)
{
return static_cast<QStyleHints*>(ptr)->keyboardAutoRepeatRate();
}
int QStyleHints_KeyboardInputInterval(void* ptr)
{
return static_cast<QStyleHints*>(ptr)->keyboardInputInterval();
}
int QStyleHints_MouseDoubleClickInterval(void* ptr)
{
return static_cast<QStyleHints*>(ptr)->mouseDoubleClickInterval();
}
int QStyleHints_MousePressAndHoldInterval(void* ptr)
{
return static_cast<QStyleHints*>(ptr)->mousePressAndHoldInterval();
}
int QStyleHints_MouseQuickSelectionThreshold(void* ptr)
{
return static_cast<QStyleHints*>(ptr)->mouseQuickSelectionThreshold();
}
int QStyleHints_PasswordMaskDelay(void* ptr)
{
return static_cast<QStyleHints*>(ptr)->passwordMaskDelay();
}
int QStyleHints_StartDragDistance(void* ptr)
{
return static_cast<QStyleHints*>(ptr)->startDragDistance();
}
int QStyleHints_StartDragTime(void* ptr)
{
return static_cast<QStyleHints*>(ptr)->startDragTime();
}
int QStyleHints_StartDragVelocity(void* ptr)
{
return static_cast<QStyleHints*>(ptr)->startDragVelocity();
}
int QStyleHints_WheelScrollLines(void* ptr)
{
return static_cast<QStyleHints*>(ptr)->wheelScrollLines();
}
double QStyleHints_FontSmoothingGamma(void* ptr)
{
return static_cast<QStyleHints*>(ptr)->fontSmoothingGamma();
}
void* QStyleHints___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QStyleHints___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QStyleHints___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QStyleHints___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStyleHints___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QStyleHints___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QStyleHints___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStyleHints___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QStyleHints___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QStyleHints___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStyleHints___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QStyleHints___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QStyleHints___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStyleHints___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QStyleHints___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QStyleHints_EventDefault(void* ptr, void* e)
{
return static_cast<QStyleHints*>(ptr)->QStyleHints::event(static_cast<QEvent*>(e));
}
char QStyleHints_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QStyleHints*>(ptr)->QStyleHints::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QStyleHints*>(ptr)->QStyleHints::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QStyleHints*>(ptr)->QStyleHints::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QStyleHints*>(ptr)->QStyleHints::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QStyleHints*>(ptr)->QStyleHints::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QStyleHints_ChildEventDefault(void* ptr, void* event)
{
static_cast<QStyleHints*>(ptr)->QStyleHints::childEvent(static_cast<QChildEvent*>(event));
}
void QStyleHints_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QStyleHints*>(ptr)->QStyleHints::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QStyleHints_CustomEventDefault(void* ptr, void* event)
{
static_cast<QStyleHints*>(ptr)->QStyleHints::customEvent(static_cast<QEvent*>(event));
}
void QStyleHints_DeleteLaterDefault(void* ptr)
{
static_cast<QStyleHints*>(ptr)->QStyleHints::deleteLater();
}
void QStyleHints_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QStyleHints*>(ptr)->QStyleHints::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QStyleHints_TimerEventDefault(void* ptr, void* event)
{
static_cast<QStyleHints*>(ptr)->QStyleHints::timerEvent(static_cast<QTimerEvent*>(event));
}
class MyQSurface: public QSurface
{
public:
~MyQSurface() { callbackQSurface_DestroyQSurface(this); };
QSize size() const { return *static_cast<QSize*>(callbackQSurface_Size(const_cast<void*>(static_cast<const void*>(this)))); };
QSurface::SurfaceType surfaceType() const { return static_cast<QSurface::SurfaceType>(callbackQSurface_SurfaceType(const_cast<void*>(static_cast<const void*>(this)))); };
QSurfaceFormat format() const { return *static_cast<QSurfaceFormat*>(callbackQSurface_Format(const_cast<void*>(static_cast<const void*>(this)))); };
};
void QSurface_DestroyQSurface(void* ptr)
{
static_cast<QSurface*>(ptr)->~QSurface();
}
void QSurface_DestroyQSurfaceDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QSurface_Size(void* ptr)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(ptr))) {
return ({ QSize tmpValue = static_cast<QOffscreenSurface*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return ({ QSize tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(ptr))) {
return ({ QSize tmpValue = static_cast<QWindow*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
} else {
return ({ QSize tmpValue = static_cast<QSurface*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
}
}
long long QSurface_SurfaceClass(void* ptr)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(ptr))) {
return static_cast<QOffscreenSurface*>(ptr)->surfaceClass();
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->surfaceClass();
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QWindow*>(ptr)->surfaceClass();
} else {
return static_cast<QSurface*>(ptr)->surfaceClass();
}
}
long long QSurface_SurfaceType(void* ptr)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(ptr))) {
return static_cast<QOffscreenSurface*>(ptr)->surfaceType();
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->surfaceType();
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QWindow*>(ptr)->surfaceType();
} else {
return static_cast<QSurface*>(ptr)->surfaceType();
}
}
void* QSurface_Format(void* ptr)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(ptr))) {
return new QSurfaceFormat(static_cast<QOffscreenSurface*>(ptr)->format());
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return new QSurfaceFormat(static_cast<QPaintDeviceWindow*>(ptr)->format());
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(ptr))) {
return new QSurfaceFormat(static_cast<QWindow*>(ptr)->format());
} else {
return new QSurfaceFormat(static_cast<QSurface*>(ptr)->format());
}
}
char QSurface_SupportsOpenGL(void* ptr)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(ptr))) {
return static_cast<QOffscreenSurface*>(ptr)->supportsOpenGL();
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->supportsOpenGL();
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QWindow*>(ptr)->supportsOpenGL();
} else {
return static_cast<QSurface*>(ptr)->supportsOpenGL();
}
}
long long QSurface_M_type(void* ptr)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(ptr))) {
return static_cast<QOffscreenSurface*>(ptr)->m_type;
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->m_type;
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QWindow*>(ptr)->m_type;
} else {
return static_cast<QSurface*>(ptr)->m_type;
}
}
void QSurface_SetM_type(void* ptr, long long vqs)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(ptr))) {
static_cast<QOffscreenSurface*>(ptr)->m_type = static_cast<QSurface::SurfaceClass>(vqs);
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->m_type = static_cast<QSurface::SurfaceClass>(vqs);
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QWindow*>(ptr)->m_type = static_cast<QSurface::SurfaceClass>(vqs);
} else {
static_cast<QSurface*>(ptr)->m_type = static_cast<QSurface::SurfaceClass>(vqs);
}
}
void* QSurfaceFormat_QSurfaceFormat_DefaultFormat()
{
return new QSurfaceFormat(QSurfaceFormat::defaultFormat());
}
void* QSurfaceFormat_NewQSurfaceFormat()
{
return new QSurfaceFormat();
}
void* QSurfaceFormat_NewQSurfaceFormat2(long long options)
{
return new QSurfaceFormat(static_cast<QSurfaceFormat::FormatOption>(options));
}
void* QSurfaceFormat_NewQSurfaceFormat3(void* other)
{
return new QSurfaceFormat(*static_cast<QSurfaceFormat*>(other));
}
void QSurfaceFormat_SetAlphaBufferSize(void* ptr, int size)
{
static_cast<QSurfaceFormat*>(ptr)->setAlphaBufferSize(size);
}
void QSurfaceFormat_SetBlueBufferSize(void* ptr, int size)
{
static_cast<QSurfaceFormat*>(ptr)->setBlueBufferSize(size);
}
void QSurfaceFormat_SetColorSpace(void* ptr, long long colorSpace)
{
static_cast<QSurfaceFormat*>(ptr)->setColorSpace(static_cast<QSurfaceFormat::ColorSpace>(colorSpace));
}
void QSurfaceFormat_QSurfaceFormat_SetDefaultFormat(void* format)
{
QSurfaceFormat::setDefaultFormat(*static_cast<QSurfaceFormat*>(format));
}
void QSurfaceFormat_SetDepthBufferSize(void* ptr, int size)
{
static_cast<QSurfaceFormat*>(ptr)->setDepthBufferSize(size);
}
void QSurfaceFormat_SetGreenBufferSize(void* ptr, int size)
{
static_cast<QSurfaceFormat*>(ptr)->setGreenBufferSize(size);
}
void QSurfaceFormat_SetMajorVersion(void* ptr, int major)
{
static_cast<QSurfaceFormat*>(ptr)->setMajorVersion(major);
}
void QSurfaceFormat_SetMinorVersion(void* ptr, int minor)
{
static_cast<QSurfaceFormat*>(ptr)->setMinorVersion(minor);
}
void QSurfaceFormat_SetOption(void* ptr, long long option, char on)
{
static_cast<QSurfaceFormat*>(ptr)->setOption(static_cast<QSurfaceFormat::FormatOption>(option), on != 0);
}
void QSurfaceFormat_SetOptions(void* ptr, long long options)
{
static_cast<QSurfaceFormat*>(ptr)->setOptions(static_cast<QSurfaceFormat::FormatOption>(options));
}
void QSurfaceFormat_SetProfile(void* ptr, long long profile)
{
static_cast<QSurfaceFormat*>(ptr)->setProfile(static_cast<QSurfaceFormat::OpenGLContextProfile>(profile));
}
void QSurfaceFormat_SetRedBufferSize(void* ptr, int size)
{
static_cast<QSurfaceFormat*>(ptr)->setRedBufferSize(size);
}
void QSurfaceFormat_SetRenderableType(void* ptr, long long ty)
{
static_cast<QSurfaceFormat*>(ptr)->setRenderableType(static_cast<QSurfaceFormat::RenderableType>(ty));
}
void QSurfaceFormat_SetSamples(void* ptr, int numSamples)
{
static_cast<QSurfaceFormat*>(ptr)->setSamples(numSamples);
}
void QSurfaceFormat_SetStencilBufferSize(void* ptr, int size)
{
static_cast<QSurfaceFormat*>(ptr)->setStencilBufferSize(size);
}
void QSurfaceFormat_SetStereo(void* ptr, char enable)
{
static_cast<QSurfaceFormat*>(ptr)->setStereo(enable != 0);
}
void QSurfaceFormat_SetSwapBehavior(void* ptr, long long behavior)
{
static_cast<QSurfaceFormat*>(ptr)->setSwapBehavior(static_cast<QSurfaceFormat::SwapBehavior>(behavior));
}
void QSurfaceFormat_SetSwapInterval(void* ptr, int interval)
{
static_cast<QSurfaceFormat*>(ptr)->setSwapInterval(interval);
}
void QSurfaceFormat_SetVersion(void* ptr, int major, int minor)
{
static_cast<QSurfaceFormat*>(ptr)->setVersion(major, minor);
}
void QSurfaceFormat_DestroyQSurfaceFormat(void* ptr)
{
static_cast<QSurfaceFormat*>(ptr)->~QSurfaceFormat();
}
long long QSurfaceFormat_ColorSpace(void* ptr)
{
return static_cast<QSurfaceFormat*>(ptr)->colorSpace();
}
long long QSurfaceFormat_Options(void* ptr)
{
return static_cast<QSurfaceFormat*>(ptr)->options();
}
long long QSurfaceFormat_Profile(void* ptr)
{
return static_cast<QSurfaceFormat*>(ptr)->profile();
}
long long QSurfaceFormat_RenderableType(void* ptr)
{
return static_cast<QSurfaceFormat*>(ptr)->renderableType();
}
long long QSurfaceFormat_SwapBehavior(void* ptr)
{
return static_cast<QSurfaceFormat*>(ptr)->swapBehavior();
}
char QSurfaceFormat_HasAlpha(void* ptr)
{
return static_cast<QSurfaceFormat*>(ptr)->hasAlpha();
}
char QSurfaceFormat_Stereo(void* ptr)
{
return static_cast<QSurfaceFormat*>(ptr)->stereo();
}
char QSurfaceFormat_TestOption(void* ptr, long long option)
{
return static_cast<QSurfaceFormat*>(ptr)->testOption(static_cast<QSurfaceFormat::FormatOption>(option));
}
int QSurfaceFormat_AlphaBufferSize(void* ptr)
{
return static_cast<QSurfaceFormat*>(ptr)->alphaBufferSize();
}
int QSurfaceFormat_BlueBufferSize(void* ptr)
{
return static_cast<QSurfaceFormat*>(ptr)->blueBufferSize();
}
int QSurfaceFormat_DepthBufferSize(void* ptr)
{
return static_cast<QSurfaceFormat*>(ptr)->depthBufferSize();
}
int QSurfaceFormat_GreenBufferSize(void* ptr)
{
return static_cast<QSurfaceFormat*>(ptr)->greenBufferSize();
}
int QSurfaceFormat_MajorVersion(void* ptr)
{
return static_cast<QSurfaceFormat*>(ptr)->majorVersion();
}
int QSurfaceFormat_MinorVersion(void* ptr)
{
return static_cast<QSurfaceFormat*>(ptr)->minorVersion();
}
int QSurfaceFormat_RedBufferSize(void* ptr)
{
return static_cast<QSurfaceFormat*>(ptr)->redBufferSize();
}
int QSurfaceFormat_Samples(void* ptr)
{
return static_cast<QSurfaceFormat*>(ptr)->samples();
}
int QSurfaceFormat_StencilBufferSize(void* ptr)
{
return static_cast<QSurfaceFormat*>(ptr)->stencilBufferSize();
}
int QSurfaceFormat_SwapInterval(void* ptr)
{
return static_cast<QSurfaceFormat*>(ptr)->swapInterval();
}
class MyQSyntaxHighlighter: public QSyntaxHighlighter
{
public:
MyQSyntaxHighlighter(QObject *parent) : QSyntaxHighlighter(parent) {QSyntaxHighlighter_QSyntaxHighlighter_QRegisterMetaType();};
MyQSyntaxHighlighter(QTextDocument *parent) : QSyntaxHighlighter(parent) {QSyntaxHighlighter_QSyntaxHighlighter_QRegisterMetaType();};
void highlightBlock(const QString & text) { QByteArray t372ea0 = text.toUtf8(); QtGui_PackedString textPacked = { const_cast<char*>(t372ea0.prepend("WHITESPACE").constData()+10), t372ea0.size()-10 };callbackQSyntaxHighlighter_HighlightBlock(this, textPacked); };
void rehighlight() { callbackQSyntaxHighlighter_Rehighlight(this); };
void rehighlightBlock(const QTextBlock & block) { callbackQSyntaxHighlighter_RehighlightBlock(this, const_cast<QTextBlock*>(&block)); };
~MyQSyntaxHighlighter() { callbackQSyntaxHighlighter_DestroyQSyntaxHighlighter(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQSyntaxHighlighter_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQSyntaxHighlighter_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQSyntaxHighlighter_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQSyntaxHighlighter_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQSyntaxHighlighter_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQSyntaxHighlighter_CustomEvent(this, event); };
void deleteLater() { callbackQSyntaxHighlighter_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQSyntaxHighlighter_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQSyntaxHighlighter_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQSyntaxHighlighter_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQSyntaxHighlighter_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQSyntaxHighlighter*)
int QSyntaxHighlighter_QSyntaxHighlighter_QRegisterMetaType(){qRegisterMetaType<QSyntaxHighlighter*>(); return qRegisterMetaType<MyQSyntaxHighlighter*>();}
struct QtGui_PackedString QSyntaxHighlighter_QSyntaxHighlighter_Tr(char* s, char* c, int n)
{
return ({ QByteArray t5766ed = QSyntaxHighlighter::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t5766ed.prepend("WHITESPACE").constData()+10), t5766ed.size()-10 }; });
}
struct QtGui_PackedString QSyntaxHighlighter_QSyntaxHighlighter_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray t4a56b9 = QSyntaxHighlighter::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t4a56b9.prepend("WHITESPACE").constData()+10), t4a56b9.size()-10 }; });
}
void* QSyntaxHighlighter_NewQSyntaxHighlighter(void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQSyntaxHighlighter(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSyntaxHighlighter(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQSyntaxHighlighter(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQSyntaxHighlighter(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQSyntaxHighlighter(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQSyntaxHighlighter(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQSyntaxHighlighter(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQSyntaxHighlighter(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQSyntaxHighlighter(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQSyntaxHighlighter(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQSyntaxHighlighter(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQSyntaxHighlighter(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQSyntaxHighlighter(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQSyntaxHighlighter(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQSyntaxHighlighter(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQSyntaxHighlighter(static_cast<QWindow*>(parent));
} else {
return new MyQSyntaxHighlighter(static_cast<QObject*>(parent));
}
}
void* QSyntaxHighlighter_NewQSyntaxHighlighter2(void* parent)
{
return new MyQSyntaxHighlighter(static_cast<QTextDocument*>(parent));
}
void QSyntaxHighlighter_HighlightBlock(void* ptr, struct QtGui_PackedString text)
{
static_cast<QSyntaxHighlighter*>(ptr)->highlightBlock(QString::fromUtf8(text.data, text.len));
}
void QSyntaxHighlighter_Rehighlight(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QSyntaxHighlighter*>(ptr), "rehighlight");
}
void QSyntaxHighlighter_RehighlightDefault(void* ptr)
{
static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::rehighlight();
}
void QSyntaxHighlighter_RehighlightBlock(void* ptr, void* block)
{
QMetaObject::invokeMethod(static_cast<QSyntaxHighlighter*>(ptr), "rehighlightBlock", Q_ARG(const QTextBlock, *static_cast<QTextBlock*>(block)));
}
void QSyntaxHighlighter_RehighlightBlockDefault(void* ptr, void* block)
{
static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::rehighlightBlock(*static_cast<QTextBlock*>(block));
}
void QSyntaxHighlighter_SetCurrentBlockState(void* ptr, int newState)
{
static_cast<QSyntaxHighlighter*>(ptr)->setCurrentBlockState(newState);
}
void QSyntaxHighlighter_SetCurrentBlockUserData(void* ptr, void* data)
{
static_cast<QSyntaxHighlighter*>(ptr)->setCurrentBlockUserData(static_cast<QTextBlockUserData*>(data));
}
void QSyntaxHighlighter_SetDocument(void* ptr, void* doc)
{
static_cast<QSyntaxHighlighter*>(ptr)->setDocument(static_cast<QTextDocument*>(doc));
}
void QSyntaxHighlighter_SetFormat2(void* ptr, int start, int count, void* color)
{
static_cast<QSyntaxHighlighter*>(ptr)->setFormat(start, count, *static_cast<QColor*>(color));
}
void QSyntaxHighlighter_SetFormat3(void* ptr, int start, int count, void* font)
{
static_cast<QSyntaxHighlighter*>(ptr)->setFormat(start, count, *static_cast<QFont*>(font));
}
void QSyntaxHighlighter_SetFormat(void* ptr, int start, int count, void* format)
{
static_cast<QSyntaxHighlighter*>(ptr)->setFormat(start, count, *static_cast<QTextCharFormat*>(format));
}
void QSyntaxHighlighter_DestroyQSyntaxHighlighter(void* ptr)
{
static_cast<QSyntaxHighlighter*>(ptr)->~QSyntaxHighlighter();
}
void QSyntaxHighlighter_DestroyQSyntaxHighlighterDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QSyntaxHighlighter_CurrentBlock(void* ptr)
{
return new QTextBlock(static_cast<QSyntaxHighlighter*>(ptr)->currentBlock());
}
void* QSyntaxHighlighter_CurrentBlockUserData(void* ptr)
{
return static_cast<QSyntaxHighlighter*>(ptr)->currentBlockUserData();
}
void* QSyntaxHighlighter_Format(void* ptr, int position)
{
return new QTextCharFormat(static_cast<QSyntaxHighlighter*>(ptr)->format(position));
}
void* QSyntaxHighlighter_Document(void* ptr)
{
return static_cast<QSyntaxHighlighter*>(ptr)->document();
}
void* QSyntaxHighlighter_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::metaObject());
}
int QSyntaxHighlighter_CurrentBlockState(void* ptr)
{
return static_cast<QSyntaxHighlighter*>(ptr)->currentBlockState();
}
int QSyntaxHighlighter_PreviousBlockState(void* ptr)
{
return static_cast<QSyntaxHighlighter*>(ptr)->previousBlockState();
}
void* QSyntaxHighlighter___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QSyntaxHighlighter___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QSyntaxHighlighter___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QSyntaxHighlighter___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QSyntaxHighlighter___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QSyntaxHighlighter___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QSyntaxHighlighter___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QSyntaxHighlighter___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QSyntaxHighlighter___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QSyntaxHighlighter___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QSyntaxHighlighter___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QSyntaxHighlighter___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QSyntaxHighlighter___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QSyntaxHighlighter___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QSyntaxHighlighter___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QSyntaxHighlighter_EventDefault(void* ptr, void* e)
{
return static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::event(static_cast<QEvent*>(e));
}
char QSyntaxHighlighter_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QSyntaxHighlighter_ChildEventDefault(void* ptr, void* event)
{
static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::childEvent(static_cast<QChildEvent*>(event));
}
void QSyntaxHighlighter_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QSyntaxHighlighter_CustomEventDefault(void* ptr, void* event)
{
static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::customEvent(static_cast<QEvent*>(event));
}
void QSyntaxHighlighter_DeleteLaterDefault(void* ptr)
{
static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::deleteLater();
}
void QSyntaxHighlighter_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QSyntaxHighlighter_TimerEventDefault(void* ptr, void* event)
{
static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::timerEvent(static_cast<QTimerEvent*>(event));
}
class MyQTabletEvent: public QTabletEvent
{
public:
MyQTabletEvent(QEvent::Type ty, const QPointF &pos, const QPointF &globalPos, int device, int pointerType, qreal pressure, int xTilt, int yTilt, qreal tangentialPressure, qreal rotation, int z, Qt::KeyboardModifiers keyState, qint64 uniqueID, Qt::MouseButton button, Qt::MouseButtons buttons) : QTabletEvent(ty, pos, globalPos, device, pointerType, pressure, xTilt, yTilt, tangentialPressure, rotation, z, keyState, uniqueID, button, buttons) {};
};
void* QTabletEvent_NewQTabletEvent(long long ty, void* pos, void* globalPos, int device, int pointerType, double pressure, int xTilt, int yTilt, double tangentialPressure, double rotation, int z, long long keyState, long long uniqueID, long long button, long long buttons)
{
return new MyQTabletEvent(static_cast<QEvent::Type>(ty), *static_cast<QPointF*>(pos), *static_cast<QPointF*>(globalPos), device, pointerType, pressure, xTilt, yTilt, tangentialPressure, rotation, z, static_cast<Qt::KeyboardModifier>(keyState), uniqueID, static_cast<Qt::MouseButton>(button), static_cast<Qt::MouseButton>(buttons));
}
void* QTabletEvent_GlobalPos(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QTabletEvent*>(ptr)->globalPos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QTabletEvent_Pos(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QTabletEvent*>(ptr)->pos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
long long QTabletEvent_PointerType(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->pointerType();
}
long long QTabletEvent_Device(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->device();
}
long long QTabletEvent_Button(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->button();
}
long long QTabletEvent_Buttons(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->buttons();
}
void* QTabletEvent_GlobalPosF(void* ptr)
{
return const_cast<QPointF*>(&static_cast<QTabletEvent*>(ptr)->globalPosF());
}
void* QTabletEvent_PosF(void* ptr)
{
return const_cast<QPointF*>(&static_cast<QTabletEvent*>(ptr)->posF());
}
int QTabletEvent_GlobalX(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->globalX();
}
int QTabletEvent_GlobalY(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->globalY();
}
int QTabletEvent_X(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->x();
}
int QTabletEvent_XTilt(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->xTilt();
}
int QTabletEvent_Y(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->y();
}
int QTabletEvent_YTilt(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->yTilt();
}
int QTabletEvent_Z(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->z();
}
long long QTabletEvent_UniqueId(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->uniqueId();
}
double QTabletEvent_HiResGlobalX(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->hiResGlobalX();
}
double QTabletEvent_HiResGlobalY(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->hiResGlobalY();
}
double QTabletEvent_Pressure(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->pressure();
}
double QTabletEvent_Rotation(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->rotation();
}
double QTabletEvent_TangentialPressure(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->tangentialPressure();
}
int QTabletEvent_MDev(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->mDev;
}
void QTabletEvent_SetMDev(void* ptr, int vin)
{
static_cast<QTabletEvent*>(ptr)->mDev = vin;
}
void* QTabletEvent_MExtra(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->mExtra;
}
void QTabletEvent_SetMExtra(void* ptr, void* vvo)
{
static_cast<QTabletEvent*>(ptr)->mExtra = vvo;
}
void* QTabletEvent_MGPos(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QTabletEvent*>(ptr)->mGPos; new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QTabletEvent_SetMGPos(void* ptr, void* vqp)
{
static_cast<QTabletEvent*>(ptr)->mGPos = *static_cast<QPointF*>(vqp);
}
int QTabletEvent_MPointerType(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->mPointerType;
}
void QTabletEvent_SetMPointerType(void* ptr, int vin)
{
static_cast<QTabletEvent*>(ptr)->mPointerType = vin;
}
void* QTabletEvent_MPos(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QTabletEvent*>(ptr)->mPos; new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QTabletEvent_SetMPos(void* ptr, void* vqp)
{
static_cast<QTabletEvent*>(ptr)->mPos = *static_cast<QPointF*>(vqp);
}
double QTabletEvent_MPress(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->mPress;
}
void QTabletEvent_SetMPress(void* ptr, double vqr)
{
static_cast<QTabletEvent*>(ptr)->mPress = vqr;
}
double QTabletEvent_MRot(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->mRot;
}
void QTabletEvent_SetMRot(void* ptr, double vqr)
{
static_cast<QTabletEvent*>(ptr)->mRot = vqr;
}
double QTabletEvent_MTangential(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->mTangential;
}
void QTabletEvent_SetMTangential(void* ptr, double vqr)
{
static_cast<QTabletEvent*>(ptr)->mTangential = vqr;
}
long long QTabletEvent_MUnique(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->mUnique;
}
void QTabletEvent_SetMUnique(void* ptr, long long vqi)
{
static_cast<QTabletEvent*>(ptr)->mUnique = vqi;
}
int QTabletEvent_MXT(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->mXT;
}
void QTabletEvent_SetMXT(void* ptr, int vin)
{
static_cast<QTabletEvent*>(ptr)->mXT = vin;
}
int QTabletEvent_MYT(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->mYT;
}
void QTabletEvent_SetMYT(void* ptr, int vin)
{
static_cast<QTabletEvent*>(ptr)->mYT = vin;
}
int QTabletEvent_MZ(void* ptr)
{
return static_cast<QTabletEvent*>(ptr)->mZ;
}
void QTabletEvent_SetMZ(void* ptr, int vin)
{
static_cast<QTabletEvent*>(ptr)->mZ = vin;
}
void* QTextBlock_NewQTextBlock(void* other)
{
return new QTextBlock(*static_cast<QTextBlock*>(other));
}
void QTextBlock_ClearLayout(void* ptr)
{
static_cast<QTextBlock*>(ptr)->clearLayout();
}
void QTextBlock_SetLineCount(void* ptr, int count)
{
static_cast<QTextBlock*>(ptr)->setLineCount(count);
}
void QTextBlock_SetRevision(void* ptr, int rev)
{
static_cast<QTextBlock*>(ptr)->setRevision(rev);
}
void QTextBlock_SetUserData(void* ptr, void* data)
{
static_cast<QTextBlock*>(ptr)->setUserData(static_cast<QTextBlockUserData*>(data));
}
void QTextBlock_SetUserState(void* ptr, int state)
{
static_cast<QTextBlock*>(ptr)->setUserState(state);
}
void QTextBlock_SetVisible(void* ptr, char visible)
{
static_cast<QTextBlock*>(ptr)->setVisible(visible != 0);
}
struct QtGui_PackedString QTextBlock_Text(void* ptr)
{
return ({ QByteArray t4bcf6c = static_cast<QTextBlock*>(ptr)->text().toUtf8(); QtGui_PackedString { const_cast<char*>(t4bcf6c.prepend("WHITESPACE").constData()+10), t4bcf6c.size()-10 }; });
}
void* QTextBlock_Next(void* ptr)
{
return new QTextBlock(static_cast<QTextBlock*>(ptr)->next());
}
void* QTextBlock_Previous(void* ptr)
{
return new QTextBlock(static_cast<QTextBlock*>(ptr)->previous());
}
void* QTextBlock_BlockFormat(void* ptr)
{
return new QTextBlockFormat(static_cast<QTextBlock*>(ptr)->blockFormat());
}
void* QTextBlock_UserData(void* ptr)
{
return static_cast<QTextBlock*>(ptr)->userData();
}
void* QTextBlock_CharFormat(void* ptr)
{
return new QTextCharFormat(static_cast<QTextBlock*>(ptr)->charFormat());
}
void* QTextBlock_Layout(void* ptr)
{
return static_cast<QTextBlock*>(ptr)->layout();
}
long long QTextBlock_TextDirection(void* ptr)
{
return static_cast<QTextBlock*>(ptr)->textDirection();
}
char QTextBlock_Contains(void* ptr, int position)
{
return static_cast<QTextBlock*>(ptr)->contains(position);
}
char QTextBlock_IsValid(void* ptr)
{
return static_cast<QTextBlock*>(ptr)->isValid();
}
char QTextBlock_IsVisible(void* ptr)
{
return static_cast<QTextBlock*>(ptr)->isVisible();
}
void* QTextBlock_Document(void* ptr)
{
return const_cast<QTextDocument*>(static_cast<QTextBlock*>(ptr)->document());
}
int QTextBlock_BlockFormatIndex(void* ptr)
{
return static_cast<QTextBlock*>(ptr)->blockFormatIndex();
}
int QTextBlock_BlockNumber(void* ptr)
{
return static_cast<QTextBlock*>(ptr)->blockNumber();
}
int QTextBlock_CharFormatIndex(void* ptr)
{
return static_cast<QTextBlock*>(ptr)->charFormatIndex();
}
int QTextBlock_FirstLineNumber(void* ptr)
{
return static_cast<QTextBlock*>(ptr)->firstLineNumber();
}
int QTextBlock_Length(void* ptr)
{
return static_cast<QTextBlock*>(ptr)->length();
}
int QTextBlock_LineCount(void* ptr)
{
return static_cast<QTextBlock*>(ptr)->lineCount();
}
int QTextBlock_Position(void* ptr)
{
return static_cast<QTextBlock*>(ptr)->position();
}
int QTextBlock_Revision(void* ptr)
{
return static_cast<QTextBlock*>(ptr)->revision();
}
int QTextBlock_UserState(void* ptr)
{
return static_cast<QTextBlock*>(ptr)->userState();
}
void* QTextBlock___textFormats_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QTextLayout::FormatRange>();
}
void* QTextBlockFormat_NewQTextBlockFormat()
{
return new QTextBlockFormat();
}
void QTextBlockFormat_SetAlignment(void* ptr, long long alignment)
{
static_cast<QTextBlockFormat*>(ptr)->setAlignment(static_cast<Qt::AlignmentFlag>(alignment));
}
void QTextBlockFormat_SetBottomMargin(void* ptr, double margin)
{
static_cast<QTextBlockFormat*>(ptr)->setBottomMargin(margin);
}
void QTextBlockFormat_SetIndent(void* ptr, int indentation)
{
static_cast<QTextBlockFormat*>(ptr)->setIndent(indentation);
}
void QTextBlockFormat_SetLeftMargin(void* ptr, double margin)
{
static_cast<QTextBlockFormat*>(ptr)->setLeftMargin(margin);
}
void QTextBlockFormat_SetLineHeight(void* ptr, double height, int heightType)
{
static_cast<QTextBlockFormat*>(ptr)->setLineHeight(height, heightType);
}
void QTextBlockFormat_SetNonBreakableLines(void* ptr, char b)
{
static_cast<QTextBlockFormat*>(ptr)->setNonBreakableLines(b != 0);
}
void QTextBlockFormat_SetPageBreakPolicy(void* ptr, long long policy)
{
static_cast<QTextBlockFormat*>(ptr)->setPageBreakPolicy(static_cast<QTextFormat::PageBreakFlag>(policy));
}
void QTextBlockFormat_SetRightMargin(void* ptr, double margin)
{
static_cast<QTextBlockFormat*>(ptr)->setRightMargin(margin);
}
void QTextBlockFormat_SetTextIndent(void* ptr, double indent)
{
static_cast<QTextBlockFormat*>(ptr)->setTextIndent(indent);
}
void QTextBlockFormat_SetTopMargin(void* ptr, double margin)
{
static_cast<QTextBlockFormat*>(ptr)->setTopMargin(margin);
}
long long QTextBlockFormat_PageBreakPolicy(void* ptr)
{
return static_cast<QTextBlockFormat*>(ptr)->pageBreakPolicy();
}
long long QTextBlockFormat_Alignment(void* ptr)
{
return static_cast<QTextBlockFormat*>(ptr)->alignment();
}
char QTextBlockFormat_NonBreakableLines(void* ptr)
{
return static_cast<QTextBlockFormat*>(ptr)->nonBreakableLines();
}
int QTextBlockFormat_Indent(void* ptr)
{
return static_cast<QTextBlockFormat*>(ptr)->indent();
}
int QTextBlockFormat_LineHeightType(void* ptr)
{
return static_cast<QTextBlockFormat*>(ptr)->lineHeightType();
}
double QTextBlockFormat_BottomMargin(void* ptr)
{
return static_cast<QTextBlockFormat*>(ptr)->bottomMargin();
}
double QTextBlockFormat_LeftMargin(void* ptr)
{
return static_cast<QTextBlockFormat*>(ptr)->leftMargin();
}
double QTextBlockFormat_LineHeight2(void* ptr)
{
return static_cast<QTextBlockFormat*>(ptr)->lineHeight();
}
double QTextBlockFormat_LineHeight(void* ptr, double scriptLineHeight, double scaling)
{
return static_cast<QTextBlockFormat*>(ptr)->lineHeight(scriptLineHeight, scaling);
}
double QTextBlockFormat_RightMargin(void* ptr)
{
return static_cast<QTextBlockFormat*>(ptr)->rightMargin();
}
double QTextBlockFormat_TextIndent(void* ptr)
{
return static_cast<QTextBlockFormat*>(ptr)->textIndent();
}
double QTextBlockFormat_TopMargin(void* ptr)
{
return static_cast<QTextBlockFormat*>(ptr)->topMargin();
}
void* QTextBlockFormat___setTabPositions_tabs_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QTextOption::Tab>();
}
void* QTextBlockFormat___tabPositions_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QTextOption::Tab>();
}
class MyQTextBlockGroup: public QTextBlockGroup
{
public:
MyQTextBlockGroup(QTextDocument *document) : QTextBlockGroup(document) {QTextBlockGroup_QTextBlockGroup_QRegisterMetaType();};
void blockFormatChanged(const QTextBlock & block) { callbackQTextBlockGroup_BlockFormatChanged(this, const_cast<QTextBlock*>(&block)); };
void blockInserted(const QTextBlock & block) { callbackQTextBlockGroup_BlockInserted(this, const_cast<QTextBlock*>(&block)); };
void blockRemoved(const QTextBlock & block) { callbackQTextBlockGroup_BlockRemoved(this, const_cast<QTextBlock*>(&block)); };
~MyQTextBlockGroup() { callbackQTextBlockGroup_DestroyQTextBlockGroup(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTextObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQTextObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQTextObject_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQTextObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQTextObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQTextObject_CustomEvent(this, event); };
void deleteLater() { callbackQTextObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQTextObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQTextObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQTextObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQTextObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQTextBlockGroup*)
int QTextBlockGroup_QTextBlockGroup_QRegisterMetaType(){qRegisterMetaType<QTextBlockGroup*>(); return qRegisterMetaType<MyQTextBlockGroup*>();}
void* QTextBlockGroup_NewQTextBlockGroup(void* document)
{
return new MyQTextBlockGroup(static_cast<QTextDocument*>(document));
}
void QTextBlockGroup_BlockFormatChanged(void* ptr, void* block)
{
static_cast<QTextBlockGroup*>(ptr)->blockFormatChanged(*static_cast<QTextBlock*>(block));
}
void QTextBlockGroup_BlockFormatChangedDefault(void* ptr, void* block)
{
if (dynamic_cast<QTextList*>(static_cast<QObject*>(ptr))) {
static_cast<QTextList*>(ptr)->QTextList::blockFormatChanged(*static_cast<QTextBlock*>(block));
} else {
static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::blockFormatChanged(*static_cast<QTextBlock*>(block));
}
}
void QTextBlockGroup_BlockInserted(void* ptr, void* block)
{
static_cast<QTextBlockGroup*>(ptr)->blockInserted(*static_cast<QTextBlock*>(block));
}
void QTextBlockGroup_BlockInsertedDefault(void* ptr, void* block)
{
if (dynamic_cast<QTextList*>(static_cast<QObject*>(ptr))) {
static_cast<QTextList*>(ptr)->QTextList::blockInserted(*static_cast<QTextBlock*>(block));
} else {
static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::blockInserted(*static_cast<QTextBlock*>(block));
}
}
void QTextBlockGroup_BlockRemoved(void* ptr, void* block)
{
static_cast<QTextBlockGroup*>(ptr)->blockRemoved(*static_cast<QTextBlock*>(block));
}
void QTextBlockGroup_BlockRemovedDefault(void* ptr, void* block)
{
if (dynamic_cast<QTextList*>(static_cast<QObject*>(ptr))) {
static_cast<QTextList*>(ptr)->QTextList::blockRemoved(*static_cast<QTextBlock*>(block));
} else {
static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::blockRemoved(*static_cast<QTextBlock*>(block));
}
}
void QTextBlockGroup_DestroyQTextBlockGroup(void* ptr)
{
static_cast<QTextBlockGroup*>(ptr)->~QTextBlockGroup();
}
void QTextBlockGroup_DestroyQTextBlockGroupDefault(void* ptr)
{
Q_UNUSED(ptr);
}
struct QtGui_PackedList QTextBlockGroup_BlockList(void* ptr)
{
return ({ QList<QTextBlock>* tmpValue = new QList<QTextBlock>(static_cast<QTextBlockGroup*>(ptr)->blockList()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QTextBlockGroup___blockList_atList(void* ptr, int i)
{
return new QTextBlock(({QTextBlock tmp = static_cast<QList<QTextBlock>*>(ptr)->at(i); if (i == static_cast<QList<QTextBlock>*>(ptr)->size()-1) { static_cast<QList<QTextBlock>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QTextBlockGroup___blockList_setList(void* ptr, void* i)
{
static_cast<QList<QTextBlock>*>(ptr)->append(*static_cast<QTextBlock*>(i));
}
void* QTextBlockGroup___blockList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QTextBlock>();
}
class MyQTextBlockUserData: public QTextBlockUserData
{
public:
~MyQTextBlockUserData() { callbackQTextBlockUserData_DestroyQTextBlockUserData(this); };
};
void QTextBlockUserData_DestroyQTextBlockUserData(void* ptr)
{
static_cast<QTextBlockUserData*>(ptr)->~QTextBlockUserData();
}
void QTextBlockUserData_DestroyQTextBlockUserDataDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QTextCharFormat_NewQTextCharFormat()
{
return new QTextCharFormat();
}
void QTextCharFormat_SetAnchor(void* ptr, char anchor)
{
static_cast<QTextCharFormat*>(ptr)->setAnchor(anchor != 0);
}
void QTextCharFormat_SetAnchorHref(void* ptr, struct QtGui_PackedString value)
{
static_cast<QTextCharFormat*>(ptr)->setAnchorHref(QString::fromUtf8(value.data, value.len));
}
void QTextCharFormat_SetAnchorNames(void* ptr, struct QtGui_PackedString names)
{
static_cast<QTextCharFormat*>(ptr)->setAnchorNames(QString::fromUtf8(names.data, names.len).split("|", QString::SkipEmptyParts));
}
void QTextCharFormat_SetFont2(void* ptr, void* font)
{
static_cast<QTextCharFormat*>(ptr)->setFont(*static_cast<QFont*>(font));
}
void QTextCharFormat_SetFont(void* ptr, void* font, long long behavior)
{
static_cast<QTextCharFormat*>(ptr)->setFont(*static_cast<QFont*>(font), static_cast<QTextCharFormat::FontPropertiesInheritanceBehavior>(behavior));
}
void QTextCharFormat_SetFontCapitalization(void* ptr, long long capitalization)
{
static_cast<QTextCharFormat*>(ptr)->setFontCapitalization(static_cast<QFont::Capitalization>(capitalization));
}
void QTextCharFormat_SetFontFamily(void* ptr, struct QtGui_PackedString family)
{
static_cast<QTextCharFormat*>(ptr)->setFontFamily(QString::fromUtf8(family.data, family.len));
}
void QTextCharFormat_SetFontFixedPitch(void* ptr, char fixedPitch)
{
static_cast<QTextCharFormat*>(ptr)->setFontFixedPitch(fixedPitch != 0);
}
void QTextCharFormat_SetFontHintingPreference(void* ptr, long long hintingPreference)
{
static_cast<QTextCharFormat*>(ptr)->setFontHintingPreference(static_cast<QFont::HintingPreference>(hintingPreference));
}
void QTextCharFormat_SetFontItalic(void* ptr, char italic)
{
static_cast<QTextCharFormat*>(ptr)->setFontItalic(italic != 0);
}
void QTextCharFormat_SetFontKerning(void* ptr, char enable)
{
static_cast<QTextCharFormat*>(ptr)->setFontKerning(enable != 0);
}
void QTextCharFormat_SetFontLetterSpacing(void* ptr, double spacing)
{
static_cast<QTextCharFormat*>(ptr)->setFontLetterSpacing(spacing);
}
void QTextCharFormat_SetFontLetterSpacingType(void* ptr, long long letterSpacingType)
{
static_cast<QTextCharFormat*>(ptr)->setFontLetterSpacingType(static_cast<QFont::SpacingType>(letterSpacingType));
}
void QTextCharFormat_SetFontOverline(void* ptr, char overline)
{
static_cast<QTextCharFormat*>(ptr)->setFontOverline(overline != 0);
}
void QTextCharFormat_SetFontPointSize(void* ptr, double size)
{
static_cast<QTextCharFormat*>(ptr)->setFontPointSize(size);
}
void QTextCharFormat_SetFontStretch(void* ptr, int factor)
{
static_cast<QTextCharFormat*>(ptr)->setFontStretch(factor);
}
void QTextCharFormat_SetFontStrikeOut(void* ptr, char strikeOut)
{
static_cast<QTextCharFormat*>(ptr)->setFontStrikeOut(strikeOut != 0);
}
void QTextCharFormat_SetFontStyleHint(void* ptr, long long hint, long long strategy)
{
static_cast<QTextCharFormat*>(ptr)->setFontStyleHint(static_cast<QFont::StyleHint>(hint), static_cast<QFont::StyleStrategy>(strategy));
}
void QTextCharFormat_SetFontStyleStrategy(void* ptr, long long strategy)
{
static_cast<QTextCharFormat*>(ptr)->setFontStyleStrategy(static_cast<QFont::StyleStrategy>(strategy));
}
void QTextCharFormat_SetFontUnderline(void* ptr, char underline)
{
static_cast<QTextCharFormat*>(ptr)->setFontUnderline(underline != 0);
}
void QTextCharFormat_SetFontWeight(void* ptr, int weight)
{
static_cast<QTextCharFormat*>(ptr)->setFontWeight(weight);
}
void QTextCharFormat_SetFontWordSpacing(void* ptr, double spacing)
{
static_cast<QTextCharFormat*>(ptr)->setFontWordSpacing(spacing);
}
void QTextCharFormat_SetTextOutline(void* ptr, void* pen)
{
static_cast<QTextCharFormat*>(ptr)->setTextOutline(*static_cast<QPen*>(pen));
}
void QTextCharFormat_SetToolTip(void* ptr, struct QtGui_PackedString text)
{
static_cast<QTextCharFormat*>(ptr)->setToolTip(QString::fromUtf8(text.data, text.len));
}
void QTextCharFormat_SetUnderlineColor(void* ptr, void* color)
{
static_cast<QTextCharFormat*>(ptr)->setUnderlineColor(*static_cast<QColor*>(color));
}
void QTextCharFormat_SetUnderlineStyle(void* ptr, long long style)
{
static_cast<QTextCharFormat*>(ptr)->setUnderlineStyle(static_cast<QTextCharFormat::UnderlineStyle>(style));
}
void QTextCharFormat_SetVerticalAlignment(void* ptr, long long alignment)
{
static_cast<QTextCharFormat*>(ptr)->setVerticalAlignment(static_cast<QTextCharFormat::VerticalAlignment>(alignment));
}
void* QTextCharFormat_UnderlineColor(void* ptr)
{
return new QColor(static_cast<QTextCharFormat*>(ptr)->underlineColor());
}
void* QTextCharFormat_Font(void* ptr)
{
return new QFont(static_cast<QTextCharFormat*>(ptr)->font());
}
long long QTextCharFormat_FontCapitalization(void* ptr)
{
return static_cast<QTextCharFormat*>(ptr)->fontCapitalization();
}
long long QTextCharFormat_FontHintingPreference(void* ptr)
{
return static_cast<QTextCharFormat*>(ptr)->fontHintingPreference();
}
long long QTextCharFormat_FontLetterSpacingType(void* ptr)
{
return static_cast<QTextCharFormat*>(ptr)->fontLetterSpacingType();
}
long long QTextCharFormat_FontStyleHint(void* ptr)
{
return static_cast<QTextCharFormat*>(ptr)->fontStyleHint();
}
long long QTextCharFormat_FontStyleStrategy(void* ptr)
{
return static_cast<QTextCharFormat*>(ptr)->fontStyleStrategy();
}
void* QTextCharFormat_TextOutline(void* ptr)
{
return new QPen(static_cast<QTextCharFormat*>(ptr)->textOutline());
}
struct QtGui_PackedString QTextCharFormat_AnchorHref(void* ptr)
{
return ({ QByteArray t7b8d88 = static_cast<QTextCharFormat*>(ptr)->anchorHref().toUtf8(); QtGui_PackedString { const_cast<char*>(t7b8d88.prepend("WHITESPACE").constData()+10), t7b8d88.size()-10 }; });
}
struct QtGui_PackedString QTextCharFormat_FontFamily(void* ptr)
{
return ({ QByteArray t087f3f = static_cast<QTextCharFormat*>(ptr)->fontFamily().toUtf8(); QtGui_PackedString { const_cast<char*>(t087f3f.prepend("WHITESPACE").constData()+10), t087f3f.size()-10 }; });
}
struct QtGui_PackedString QTextCharFormat_ToolTip(void* ptr)
{
return ({ QByteArray t7e7f7f = static_cast<QTextCharFormat*>(ptr)->toolTip().toUtf8(); QtGui_PackedString { const_cast<char*>(t7e7f7f.prepend("WHITESPACE").constData()+10), t7e7f7f.size()-10 }; });
}
struct QtGui_PackedString QTextCharFormat_AnchorNames(void* ptr)
{
return ({ QByteArray t55bd77 = static_cast<QTextCharFormat*>(ptr)->anchorNames().join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t55bd77.prepend("WHITESPACE").constData()+10), t55bd77.size()-10 }; });
}
long long QTextCharFormat_UnderlineStyle(void* ptr)
{
return static_cast<QTextCharFormat*>(ptr)->underlineStyle();
}
long long QTextCharFormat_VerticalAlignment(void* ptr)
{
return static_cast<QTextCharFormat*>(ptr)->verticalAlignment();
}
char QTextCharFormat_FontFixedPitch(void* ptr)
{
return static_cast<QTextCharFormat*>(ptr)->fontFixedPitch();
}
char QTextCharFormat_FontItalic(void* ptr)
{
return static_cast<QTextCharFormat*>(ptr)->fontItalic();
}
char QTextCharFormat_FontKerning(void* ptr)
{
return static_cast<QTextCharFormat*>(ptr)->fontKerning();
}
char QTextCharFormat_FontOverline(void* ptr)
{
return static_cast<QTextCharFormat*>(ptr)->fontOverline();
}
char QTextCharFormat_FontStrikeOut(void* ptr)
{
return static_cast<QTextCharFormat*>(ptr)->fontStrikeOut();
}
char QTextCharFormat_FontUnderline(void* ptr)
{
return static_cast<QTextCharFormat*>(ptr)->fontUnderline();
}
char QTextCharFormat_IsAnchor(void* ptr)
{
return static_cast<QTextCharFormat*>(ptr)->isAnchor();
}
int QTextCharFormat_FontStretch(void* ptr)
{
return static_cast<QTextCharFormat*>(ptr)->fontStretch();
}
int QTextCharFormat_FontWeight(void* ptr)
{
return static_cast<QTextCharFormat*>(ptr)->fontWeight();
}
double QTextCharFormat_FontLetterSpacing(void* ptr)
{
return static_cast<QTextCharFormat*>(ptr)->fontLetterSpacing();
}
double QTextCharFormat_FontPointSize(void* ptr)
{
return static_cast<QTextCharFormat*>(ptr)->fontPointSize();
}
double QTextCharFormat_FontWordSpacing(void* ptr)
{
return static_cast<QTextCharFormat*>(ptr)->fontWordSpacing();
}
void* QTextCursor_NewQTextCursor()
{
return new QTextCursor();
}
void* QTextCursor_NewQTextCursor2(void* document)
{
return new QTextCursor(static_cast<QTextDocument*>(document));
}
void* QTextCursor_NewQTextCursor5(void* frame)
{
return new QTextCursor(static_cast<QTextFrame*>(frame));
}
void* QTextCursor_NewQTextCursor6(void* block)
{
return new QTextCursor(*static_cast<QTextBlock*>(block));
}
void* QTextCursor_NewQTextCursor7(void* cursor)
{
return new QTextCursor(*static_cast<QTextCursor*>(cursor));
}
void* QTextCursor_InsertFrame(void* ptr, void* format)
{
return static_cast<QTextCursor*>(ptr)->insertFrame(*static_cast<QTextFrameFormat*>(format));
}
void* QTextCursor_CreateList2(void* ptr, long long style)
{
return static_cast<QTextCursor*>(ptr)->createList(static_cast<QTextListFormat::Style>(style));
}
void* QTextCursor_CreateList(void* ptr, void* format)
{
return static_cast<QTextCursor*>(ptr)->createList(*static_cast<QTextListFormat*>(format));
}
void* QTextCursor_InsertList2(void* ptr, long long style)
{
return static_cast<QTextCursor*>(ptr)->insertList(static_cast<QTextListFormat::Style>(style));
}
void* QTextCursor_InsertList(void* ptr, void* format)
{
return static_cast<QTextCursor*>(ptr)->insertList(*static_cast<QTextListFormat*>(format));
}
void* QTextCursor_InsertTable2(void* ptr, int rows, int columns)
{
return static_cast<QTextCursor*>(ptr)->insertTable(rows, columns);
}
void* QTextCursor_InsertTable(void* ptr, int rows, int columns, void* format)
{
return static_cast<QTextCursor*>(ptr)->insertTable(rows, columns, *static_cast<QTextTableFormat*>(format));
}
char QTextCursor_MovePosition(void* ptr, long long operation, long long mode, int n)
{
return static_cast<QTextCursor*>(ptr)->movePosition(static_cast<QTextCursor::MoveOperation>(operation), static_cast<QTextCursor::MoveMode>(mode), n);
}
void QTextCursor_BeginEditBlock(void* ptr)
{
static_cast<QTextCursor*>(ptr)->beginEditBlock();
}
void QTextCursor_ClearSelection(void* ptr)
{
static_cast<QTextCursor*>(ptr)->clearSelection();
}
void QTextCursor_DeleteChar(void* ptr)
{
static_cast<QTextCursor*>(ptr)->deleteChar();
}
void QTextCursor_DeletePreviousChar(void* ptr)
{
static_cast<QTextCursor*>(ptr)->deletePreviousChar();
}
void QTextCursor_EndEditBlock(void* ptr)
{
static_cast<QTextCursor*>(ptr)->endEditBlock();
}
void QTextCursor_InsertBlock(void* ptr)
{
static_cast<QTextCursor*>(ptr)->insertBlock();
}
void QTextCursor_InsertBlock2(void* ptr, void* format)
{
static_cast<QTextCursor*>(ptr)->insertBlock(*static_cast<QTextBlockFormat*>(format));
}
void QTextCursor_InsertBlock3(void* ptr, void* format, void* charFormat)
{
static_cast<QTextCursor*>(ptr)->insertBlock(*static_cast<QTextBlockFormat*>(format), *static_cast<QTextCharFormat*>(charFormat));
}
void QTextCursor_InsertFragment(void* ptr, void* fragment)
{
static_cast<QTextCursor*>(ptr)->insertFragment(*static_cast<QTextDocumentFragment*>(fragment));
}
void QTextCursor_InsertHtml(void* ptr, struct QtGui_PackedString html)
{
static_cast<QTextCursor*>(ptr)->insertHtml(QString::fromUtf8(html.data, html.len));
}
void QTextCursor_InsertImage4(void* ptr, void* image, struct QtGui_PackedString name)
{
static_cast<QTextCursor*>(ptr)->insertImage(*static_cast<QImage*>(image), QString::fromUtf8(name.data, name.len));
}
void QTextCursor_InsertImage3(void* ptr, struct QtGui_PackedString name)
{
static_cast<QTextCursor*>(ptr)->insertImage(QString::fromUtf8(name.data, name.len));
}
void QTextCursor_InsertImage(void* ptr, void* format)
{
static_cast<QTextCursor*>(ptr)->insertImage(*static_cast<QTextImageFormat*>(format));
}
void QTextCursor_InsertImage2(void* ptr, void* format, long long alignment)
{
static_cast<QTextCursor*>(ptr)->insertImage(*static_cast<QTextImageFormat*>(format), static_cast<QTextFrameFormat::Position>(alignment));
}
void QTextCursor_InsertText(void* ptr, struct QtGui_PackedString text)
{
static_cast<QTextCursor*>(ptr)->insertText(QString::fromUtf8(text.data, text.len));
}
void QTextCursor_InsertText2(void* ptr, struct QtGui_PackedString text, void* format)
{
static_cast<QTextCursor*>(ptr)->insertText(QString::fromUtf8(text.data, text.len), *static_cast<QTextCharFormat*>(format));
}
void QTextCursor_JoinPreviousEditBlock(void* ptr)
{
static_cast<QTextCursor*>(ptr)->joinPreviousEditBlock();
}
void QTextCursor_MergeBlockCharFormat(void* ptr, void* modifier)
{
static_cast<QTextCursor*>(ptr)->mergeBlockCharFormat(*static_cast<QTextCharFormat*>(modifier));
}
void QTextCursor_MergeBlockFormat(void* ptr, void* modifier)
{
static_cast<QTextCursor*>(ptr)->mergeBlockFormat(*static_cast<QTextBlockFormat*>(modifier));
}
void QTextCursor_MergeCharFormat(void* ptr, void* modifier)
{
static_cast<QTextCursor*>(ptr)->mergeCharFormat(*static_cast<QTextCharFormat*>(modifier));
}
void QTextCursor_RemoveSelectedText(void* ptr)
{
static_cast<QTextCursor*>(ptr)->removeSelectedText();
}
void QTextCursor_Select(void* ptr, long long selection)
{
static_cast<QTextCursor*>(ptr)->select(static_cast<QTextCursor::SelectionType>(selection));
}
void QTextCursor_SetBlockCharFormat(void* ptr, void* format)
{
static_cast<QTextCursor*>(ptr)->setBlockCharFormat(*static_cast<QTextCharFormat*>(format));
}
void QTextCursor_SetBlockFormat(void* ptr, void* format)
{
static_cast<QTextCursor*>(ptr)->setBlockFormat(*static_cast<QTextBlockFormat*>(format));
}
void QTextCursor_SetCharFormat(void* ptr, void* format)
{
static_cast<QTextCursor*>(ptr)->setCharFormat(*static_cast<QTextCharFormat*>(format));
}
void QTextCursor_SetKeepPositionOnInsert(void* ptr, char b)
{
static_cast<QTextCursor*>(ptr)->setKeepPositionOnInsert(b != 0);
}
void QTextCursor_SetPosition(void* ptr, int pos, long long m)
{
static_cast<QTextCursor*>(ptr)->setPosition(pos, static_cast<QTextCursor::MoveMode>(m));
}
void QTextCursor_SetVerticalMovementX(void* ptr, int x)
{
static_cast<QTextCursor*>(ptr)->setVerticalMovementX(x);
}
void QTextCursor_SetVisualNavigation(void* ptr, char b)
{
static_cast<QTextCursor*>(ptr)->setVisualNavigation(b != 0);
}
void QTextCursor_Swap(void* ptr, void* other)
{
static_cast<QTextCursor*>(ptr)->swap(*static_cast<QTextCursor*>(other));
}
void QTextCursor_DestroyQTextCursor(void* ptr)
{
static_cast<QTextCursor*>(ptr)->~QTextCursor();
}
struct QtGui_PackedString QTextCursor_SelectedText(void* ptr)
{
return ({ QByteArray t495ef8 = static_cast<QTextCursor*>(ptr)->selectedText().toUtf8(); QtGui_PackedString { const_cast<char*>(t495ef8.prepend("WHITESPACE").constData()+10), t495ef8.size()-10 }; });
}
void* QTextCursor_Block(void* ptr)
{
return new QTextBlock(static_cast<QTextCursor*>(ptr)->block());
}
void* QTextCursor_BlockFormat(void* ptr)
{
return new QTextBlockFormat(static_cast<QTextCursor*>(ptr)->blockFormat());
}
void* QTextCursor_BlockCharFormat(void* ptr)
{
return new QTextCharFormat(static_cast<QTextCursor*>(ptr)->blockCharFormat());
}
void* QTextCursor_CharFormat(void* ptr)
{
return new QTextCharFormat(static_cast<QTextCursor*>(ptr)->charFormat());
}
void* QTextCursor_Document(void* ptr)
{
return static_cast<QTextCursor*>(ptr)->document();
}
void* QTextCursor_Selection(void* ptr)
{
return new QTextDocumentFragment(static_cast<QTextCursor*>(ptr)->selection());
}
void* QTextCursor_CurrentFrame(void* ptr)
{
return static_cast<QTextCursor*>(ptr)->currentFrame();
}
void* QTextCursor_CurrentList(void* ptr)
{
return static_cast<QTextCursor*>(ptr)->currentList();
}
void* QTextCursor_CurrentTable(void* ptr)
{
return static_cast<QTextCursor*>(ptr)->currentTable();
}
char QTextCursor_AtBlockEnd(void* ptr)
{
return static_cast<QTextCursor*>(ptr)->atBlockEnd();
}
char QTextCursor_AtBlockStart(void* ptr)
{
return static_cast<QTextCursor*>(ptr)->atBlockStart();
}
char QTextCursor_AtEnd(void* ptr)
{
return static_cast<QTextCursor*>(ptr)->atEnd();
}
char QTextCursor_AtStart(void* ptr)
{
return static_cast<QTextCursor*>(ptr)->atStart();
}
char QTextCursor_HasComplexSelection(void* ptr)
{
return static_cast<QTextCursor*>(ptr)->hasComplexSelection();
}
char QTextCursor_HasSelection(void* ptr)
{
return static_cast<QTextCursor*>(ptr)->hasSelection();
}
char QTextCursor_IsCopyOf(void* ptr, void* other)
{
return static_cast<QTextCursor*>(ptr)->isCopyOf(*static_cast<QTextCursor*>(other));
}
char QTextCursor_IsNull(void* ptr)
{
return static_cast<QTextCursor*>(ptr)->isNull();
}
char QTextCursor_KeepPositionOnInsert(void* ptr)
{
return static_cast<QTextCursor*>(ptr)->keepPositionOnInsert();
}
char QTextCursor_VisualNavigation(void* ptr)
{
return static_cast<QTextCursor*>(ptr)->visualNavigation();
}
int QTextCursor_Anchor(void* ptr)
{
return static_cast<QTextCursor*>(ptr)->anchor();
}
int QTextCursor_BlockNumber(void* ptr)
{
return static_cast<QTextCursor*>(ptr)->blockNumber();
}
int QTextCursor_ColumnNumber(void* ptr)
{
return static_cast<QTextCursor*>(ptr)->columnNumber();
}
int QTextCursor_Position(void* ptr)
{
return static_cast<QTextCursor*>(ptr)->position();
}
int QTextCursor_PositionInBlock(void* ptr)
{
return static_cast<QTextCursor*>(ptr)->positionInBlock();
}
int QTextCursor_SelectionEnd(void* ptr)
{
return static_cast<QTextCursor*>(ptr)->selectionEnd();
}
int QTextCursor_SelectionStart(void* ptr)
{
return static_cast<QTextCursor*>(ptr)->selectionStart();
}
int QTextCursor_VerticalMovementX(void* ptr)
{
return static_cast<QTextCursor*>(ptr)->verticalMovementX();
}
void QTextCursor_SelectedTableCells(void* ptr, int firstRow, int numRows, int firstColumn, int numColumns)
{
static_cast<QTextCursor*>(ptr)->selectedTableCells(&firstRow, &numRows, &firstColumn, &numColumns);
}
class MyQTextDocument: public QTextDocument
{
public:
MyQTextDocument(QObject *parent = Q_NULLPTR) : QTextDocument(parent) {QTextDocument_QTextDocument_QRegisterMetaType();};
MyQTextDocument(const QString &text, QObject *parent = Q_NULLPTR) : QTextDocument(text, parent) {QTextDocument_QTextDocument_QRegisterMetaType();};
QTextObject * createObject(const QTextFormat & format) { return static_cast<QTextObject*>(callbackQTextDocument_CreateObject(this, const_cast<QTextFormat*>(&format))); };
QVariant loadResource(int ty, const QUrl & name) { return *static_cast<QVariant*>(callbackQTextDocument_LoadResource(this, ty, const_cast<QUrl*>(&name))); };
void Signal_BaseUrlChanged(const QUrl & url) { callbackQTextDocument_BaseUrlChanged(this, const_cast<QUrl*>(&url)); };
void Signal_BlockCountChanged(int newBlockCount) { callbackQTextDocument_BlockCountChanged(this, newBlockCount); };
void clear() { callbackQTextDocument_Clear(this); };
void Signal_ContentsChange(int position, int charsRemoved, int charsAdded) { callbackQTextDocument_ContentsChange(this, position, charsRemoved, charsAdded); };
void Signal_ContentsChanged() { callbackQTextDocument_ContentsChanged(this); };
void Signal_CursorPositionChanged(const QTextCursor & cursor) { callbackQTextDocument_CursorPositionChanged(this, const_cast<QTextCursor*>(&cursor)); };
void Signal_DocumentLayoutChanged() { callbackQTextDocument_DocumentLayoutChanged(this); };
void Signal_ModificationChanged(bool changed) { callbackQTextDocument_ModificationChanged(this, changed); };
void redo() { callbackQTextDocument_Redo2(this); };
void Signal_RedoAvailable(bool available) { callbackQTextDocument_RedoAvailable(this, available); };
void setModified(bool m) { callbackQTextDocument_SetModified(this, m); };
void undo() { callbackQTextDocument_Undo2(this); };
void Signal_UndoAvailable(bool available) { callbackQTextDocument_UndoAvailable(this, available); };
void Signal_UndoCommandAdded() { callbackQTextDocument_UndoCommandAdded(this); };
~MyQTextDocument() { callbackQTextDocument_DestroyQTextDocument(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTextDocument_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQTextDocument_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQTextDocument_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQTextDocument_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQTextDocument_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQTextDocument_CustomEvent(this, event); };
void deleteLater() { callbackQTextDocument_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQTextDocument_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQTextDocument_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQTextDocument_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQTextDocument_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQTextDocument*)
int QTextDocument_QTextDocument_QRegisterMetaType(){qRegisterMetaType<QTextDocument*>(); return qRegisterMetaType<MyQTextDocument*>();}
struct QtGui_PackedString QTextDocument_QTextDocument_Tr(char* s, char* c, int n)
{
return ({ QByteArray t4e8cfa = QTextDocument::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t4e8cfa.prepend("WHITESPACE").constData()+10), t4e8cfa.size()-10 }; });
}
struct QtGui_PackedString QTextDocument_QTextDocument_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray t2af0b3 = QTextDocument::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t2af0b3.prepend("WHITESPACE").constData()+10), t2af0b3.size()-10 }; });
}
void* QTextDocument_NewQTextDocument(void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(static_cast<QWindow*>(parent));
} else {
return new MyQTextDocument(static_cast<QObject*>(parent));
}
}
void* QTextDocument_NewQTextDocument2(struct QtGui_PackedString text, void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(QString::fromUtf8(text.data, text.len), static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(QString::fromUtf8(text.data, text.len), static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(QString::fromUtf8(text.data, text.len), static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(QString::fromUtf8(text.data, text.len), static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(QString::fromUtf8(text.data, text.len), static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(QString::fromUtf8(text.data, text.len), static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(QString::fromUtf8(text.data, text.len), static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(QString::fromUtf8(text.data, text.len), static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(QString::fromUtf8(text.data, text.len), static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(QString::fromUtf8(text.data, text.len), static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(QString::fromUtf8(text.data, text.len), static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(QString::fromUtf8(text.data, text.len), static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(QString::fromUtf8(text.data, text.len), static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(QString::fromUtf8(text.data, text.len), static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(QString::fromUtf8(text.data, text.len), static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQTextDocument(QString::fromUtf8(text.data, text.len), static_cast<QWindow*>(parent));
} else {
return new MyQTextDocument(QString::fromUtf8(text.data, text.len), static_cast<QObject*>(parent));
}
}
void* QTextDocument_CreateObject(void* ptr, void* format)
{
return static_cast<QTextDocument*>(ptr)->createObject(*static_cast<QTextFormat*>(format));
}
void* QTextDocument_CreateObjectDefault(void* ptr, void* format)
{
return static_cast<QTextDocument*>(ptr)->QTextDocument::createObject(*static_cast<QTextFormat*>(format));
}
void* QTextDocument_LoadResource(void* ptr, int ty, void* name)
{
return new QVariant(static_cast<QTextDocument*>(ptr)->loadResource(ty, *static_cast<QUrl*>(name)));
}
void* QTextDocument_LoadResourceDefault(void* ptr, int ty, void* name)
{
return new QVariant(static_cast<QTextDocument*>(ptr)->QTextDocument::loadResource(ty, *static_cast<QUrl*>(name)));
}
void QTextDocument_AddResource(void* ptr, int ty, void* name, void* resource)
{
static_cast<QTextDocument*>(ptr)->addResource(ty, *static_cast<QUrl*>(name), *static_cast<QVariant*>(resource));
}
void QTextDocument_AdjustSize(void* ptr)
{
static_cast<QTextDocument*>(ptr)->adjustSize();
}
void QTextDocument_ConnectBaseUrlChanged(void* ptr)
{
QObject::connect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(const QUrl &)>(&QTextDocument::baseUrlChanged), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(const QUrl &)>(&MyQTextDocument::Signal_BaseUrlChanged));
}
void QTextDocument_DisconnectBaseUrlChanged(void* ptr)
{
QObject::disconnect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(const QUrl &)>(&QTextDocument::baseUrlChanged), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(const QUrl &)>(&MyQTextDocument::Signal_BaseUrlChanged));
}
void QTextDocument_BaseUrlChanged(void* ptr, void* url)
{
static_cast<QTextDocument*>(ptr)->baseUrlChanged(*static_cast<QUrl*>(url));
}
void QTextDocument_ConnectBlockCountChanged(void* ptr)
{
QObject::connect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(int)>(&QTextDocument::blockCountChanged), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(int)>(&MyQTextDocument::Signal_BlockCountChanged));
}
void QTextDocument_DisconnectBlockCountChanged(void* ptr)
{
QObject::disconnect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(int)>(&QTextDocument::blockCountChanged), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(int)>(&MyQTextDocument::Signal_BlockCountChanged));
}
void QTextDocument_BlockCountChanged(void* ptr, int newBlockCount)
{
static_cast<QTextDocument*>(ptr)->blockCountChanged(newBlockCount);
}
void QTextDocument_Clear(void* ptr)
{
static_cast<QTextDocument*>(ptr)->clear();
}
void QTextDocument_ClearDefault(void* ptr)
{
static_cast<QTextDocument*>(ptr)->QTextDocument::clear();
}
void QTextDocument_ClearUndoRedoStacks(void* ptr, long long stacksToClear)
{
static_cast<QTextDocument*>(ptr)->clearUndoRedoStacks(static_cast<QTextDocument::Stacks>(stacksToClear));
}
void QTextDocument_ConnectContentsChange(void* ptr)
{
QObject::connect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(int, int, int)>(&QTextDocument::contentsChange), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(int, int, int)>(&MyQTextDocument::Signal_ContentsChange));
}
void QTextDocument_DisconnectContentsChange(void* ptr)
{
QObject::disconnect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(int, int, int)>(&QTextDocument::contentsChange), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(int, int, int)>(&MyQTextDocument::Signal_ContentsChange));
}
void QTextDocument_ContentsChange(void* ptr, int position, int charsRemoved, int charsAdded)
{
static_cast<QTextDocument*>(ptr)->contentsChange(position, charsRemoved, charsAdded);
}
void QTextDocument_ConnectContentsChanged(void* ptr)
{
QObject::connect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)()>(&QTextDocument::contentsChanged), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)()>(&MyQTextDocument::Signal_ContentsChanged));
}
void QTextDocument_DisconnectContentsChanged(void* ptr)
{
QObject::disconnect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)()>(&QTextDocument::contentsChanged), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)()>(&MyQTextDocument::Signal_ContentsChanged));
}
void QTextDocument_ContentsChanged(void* ptr)
{
static_cast<QTextDocument*>(ptr)->contentsChanged();
}
void QTextDocument_ConnectCursorPositionChanged(void* ptr)
{
QObject::connect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(const QTextCursor &)>(&QTextDocument::cursorPositionChanged), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(const QTextCursor &)>(&MyQTextDocument::Signal_CursorPositionChanged));
}
void QTextDocument_DisconnectCursorPositionChanged(void* ptr)
{
QObject::disconnect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(const QTextCursor &)>(&QTextDocument::cursorPositionChanged), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(const QTextCursor &)>(&MyQTextDocument::Signal_CursorPositionChanged));
}
void QTextDocument_CursorPositionChanged(void* ptr, void* cursor)
{
static_cast<QTextDocument*>(ptr)->cursorPositionChanged(*static_cast<QTextCursor*>(cursor));
}
void QTextDocument_ConnectDocumentLayoutChanged(void* ptr)
{
QObject::connect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)()>(&QTextDocument::documentLayoutChanged), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)()>(&MyQTextDocument::Signal_DocumentLayoutChanged));
}
void QTextDocument_DisconnectDocumentLayoutChanged(void* ptr)
{
QObject::disconnect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)()>(&QTextDocument::documentLayoutChanged), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)()>(&MyQTextDocument::Signal_DocumentLayoutChanged));
}
void QTextDocument_DocumentLayoutChanged(void* ptr)
{
static_cast<QTextDocument*>(ptr)->documentLayoutChanged();
}
void QTextDocument_DrawContents(void* ptr, void* p, void* rect)
{
static_cast<QTextDocument*>(ptr)->drawContents(static_cast<QPainter*>(p), *static_cast<QRectF*>(rect));
}
void QTextDocument_MarkContentsDirty(void* ptr, int position, int length)
{
static_cast<QTextDocument*>(ptr)->markContentsDirty(position, length);
}
void QTextDocument_ConnectModificationChanged(void* ptr)
{
QObject::connect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(bool)>(&QTextDocument::modificationChanged), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(bool)>(&MyQTextDocument::Signal_ModificationChanged));
}
void QTextDocument_DisconnectModificationChanged(void* ptr)
{
QObject::disconnect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(bool)>(&QTextDocument::modificationChanged), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(bool)>(&MyQTextDocument::Signal_ModificationChanged));
}
void QTextDocument_ModificationChanged(void* ptr, char changed)
{
static_cast<QTextDocument*>(ptr)->modificationChanged(changed != 0);
}
void QTextDocument_Redo2(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QTextDocument*>(ptr), "redo");
}
void QTextDocument_Redo2Default(void* ptr)
{
static_cast<QTextDocument*>(ptr)->QTextDocument::redo();
}
void QTextDocument_Redo(void* ptr, void* cursor)
{
static_cast<QTextDocument*>(ptr)->redo(static_cast<QTextCursor*>(cursor));
}
void QTextDocument_ConnectRedoAvailable(void* ptr)
{
QObject::connect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(bool)>(&QTextDocument::redoAvailable), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(bool)>(&MyQTextDocument::Signal_RedoAvailable));
}
void QTextDocument_DisconnectRedoAvailable(void* ptr)
{
QObject::disconnect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(bool)>(&QTextDocument::redoAvailable), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(bool)>(&MyQTextDocument::Signal_RedoAvailable));
}
void QTextDocument_RedoAvailable(void* ptr, char available)
{
static_cast<QTextDocument*>(ptr)->redoAvailable(available != 0);
}
void QTextDocument_SetBaseUrl(void* ptr, void* url)
{
static_cast<QTextDocument*>(ptr)->setBaseUrl(*static_cast<QUrl*>(url));
}
void QTextDocument_SetDefaultCursorMoveStyle(void* ptr, long long style)
{
static_cast<QTextDocument*>(ptr)->setDefaultCursorMoveStyle(static_cast<Qt::CursorMoveStyle>(style));
}
void QTextDocument_SetDefaultFont(void* ptr, void* font)
{
static_cast<QTextDocument*>(ptr)->setDefaultFont(*static_cast<QFont*>(font));
}
void QTextDocument_SetDefaultStyleSheet(void* ptr, struct QtGui_PackedString sheet)
{
static_cast<QTextDocument*>(ptr)->setDefaultStyleSheet(QString::fromUtf8(sheet.data, sheet.len));
}
void QTextDocument_SetDefaultTextOption(void* ptr, void* option)
{
static_cast<QTextDocument*>(ptr)->setDefaultTextOption(*static_cast<QTextOption*>(option));
}
void QTextDocument_SetDocumentLayout(void* ptr, void* layout)
{
static_cast<QTextDocument*>(ptr)->setDocumentLayout(static_cast<QAbstractTextDocumentLayout*>(layout));
}
void QTextDocument_SetDocumentMargin(void* ptr, double margin)
{
static_cast<QTextDocument*>(ptr)->setDocumentMargin(margin);
}
void QTextDocument_SetHtml(void* ptr, struct QtGui_PackedString html)
{
static_cast<QTextDocument*>(ptr)->setHtml(QString::fromUtf8(html.data, html.len));
}
void QTextDocument_SetIndentWidth(void* ptr, double width)
{
static_cast<QTextDocument*>(ptr)->setIndentWidth(width);
}
void QTextDocument_SetMaximumBlockCount(void* ptr, int maximum)
{
static_cast<QTextDocument*>(ptr)->setMaximumBlockCount(maximum);
}
void QTextDocument_SetMetaInformation(void* ptr, long long info, struct QtGui_PackedString stri)
{
static_cast<QTextDocument*>(ptr)->setMetaInformation(static_cast<QTextDocument::MetaInformation>(info), QString::fromUtf8(stri.data, stri.len));
}
void QTextDocument_SetModified(void* ptr, char m)
{
QMetaObject::invokeMethod(static_cast<QTextDocument*>(ptr), "setModified", Q_ARG(bool, m != 0));
}
void QTextDocument_SetModifiedDefault(void* ptr, char m)
{
static_cast<QTextDocument*>(ptr)->QTextDocument::setModified(m != 0);
}
void QTextDocument_SetPageSize(void* ptr, void* size)
{
static_cast<QTextDocument*>(ptr)->setPageSize(*static_cast<QSizeF*>(size));
}
void QTextDocument_SetPlainText(void* ptr, struct QtGui_PackedString text)
{
static_cast<QTextDocument*>(ptr)->setPlainText(QString::fromUtf8(text.data, text.len));
}
void QTextDocument_SetTextWidth(void* ptr, double width)
{
static_cast<QTextDocument*>(ptr)->setTextWidth(width);
}
void QTextDocument_SetUndoRedoEnabled(void* ptr, char enable)
{
static_cast<QTextDocument*>(ptr)->setUndoRedoEnabled(enable != 0);
}
void QTextDocument_SetUseDesignMetrics(void* ptr, char b)
{
static_cast<QTextDocument*>(ptr)->setUseDesignMetrics(b != 0);
}
void QTextDocument_Undo2(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QTextDocument*>(ptr), "undo");
}
void QTextDocument_Undo2Default(void* ptr)
{
static_cast<QTextDocument*>(ptr)->QTextDocument::undo();
}
void QTextDocument_Undo(void* ptr, void* cursor)
{
static_cast<QTextDocument*>(ptr)->undo(static_cast<QTextCursor*>(cursor));
}
void QTextDocument_ConnectUndoAvailable(void* ptr)
{
QObject::connect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(bool)>(&QTextDocument::undoAvailable), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(bool)>(&MyQTextDocument::Signal_UndoAvailable));
}
void QTextDocument_DisconnectUndoAvailable(void* ptr)
{
QObject::disconnect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(bool)>(&QTextDocument::undoAvailable), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(bool)>(&MyQTextDocument::Signal_UndoAvailable));
}
void QTextDocument_UndoAvailable(void* ptr, char available)
{
static_cast<QTextDocument*>(ptr)->undoAvailable(available != 0);
}
void QTextDocument_ConnectUndoCommandAdded(void* ptr)
{
QObject::connect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)()>(&QTextDocument::undoCommandAdded), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)()>(&MyQTextDocument::Signal_UndoCommandAdded));
}
void QTextDocument_DisconnectUndoCommandAdded(void* ptr)
{
QObject::disconnect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)()>(&QTextDocument::undoCommandAdded), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)()>(&MyQTextDocument::Signal_UndoCommandAdded));
}
void QTextDocument_UndoCommandAdded(void* ptr)
{
static_cast<QTextDocument*>(ptr)->undoCommandAdded();
}
void QTextDocument_DestroyQTextDocument(void* ptr)
{
static_cast<QTextDocument*>(ptr)->~QTextDocument();
}
void QTextDocument_DestroyQTextDocumentDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QTextDocument_DocumentLayout(void* ptr)
{
return static_cast<QTextDocument*>(ptr)->documentLayout();
}
void* QTextDocument_CharacterAt(void* ptr, int pos)
{
return new QChar(static_cast<QTextDocument*>(ptr)->characterAt(pos));
}
void* QTextDocument_DefaultFont(void* ptr)
{
return new QFont(static_cast<QTextDocument*>(ptr)->defaultFont());
}
void* QTextDocument_PageSize(void* ptr)
{
return ({ QSizeF tmpValue = static_cast<QTextDocument*>(ptr)->pageSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}
void* QTextDocument_Size(void* ptr)
{
return ({ QSizeF tmpValue = static_cast<QTextDocument*>(ptr)->size(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}
struct QtGui_PackedString QTextDocument_DefaultStyleSheet(void* ptr)
{
return ({ QByteArray t95f0f4 = static_cast<QTextDocument*>(ptr)->defaultStyleSheet().toUtf8(); QtGui_PackedString { const_cast<char*>(t95f0f4.prepend("WHITESPACE").constData()+10), t95f0f4.size()-10 }; });
}
struct QtGui_PackedString QTextDocument_MetaInformation(void* ptr, long long info)
{
return ({ QByteArray ta91ae2 = static_cast<QTextDocument*>(ptr)->metaInformation(static_cast<QTextDocument::MetaInformation>(info)).toUtf8(); QtGui_PackedString { const_cast<char*>(ta91ae2.prepend("WHITESPACE").constData()+10), ta91ae2.size()-10 }; });
}
struct QtGui_PackedString QTextDocument_ToHtml(void* ptr, void* encoding)
{
return ({ QByteArray t48be10 = static_cast<QTextDocument*>(ptr)->toHtml(*static_cast<QByteArray*>(encoding)).toUtf8(); QtGui_PackedString { const_cast<char*>(t48be10.prepend("WHITESPACE").constData()+10), t48be10.size()-10 }; });
}
struct QtGui_PackedString QTextDocument_ToPlainText(void* ptr)
{
return ({ QByteArray t7d8da3 = static_cast<QTextDocument*>(ptr)->toPlainText().toUtf8(); QtGui_PackedString { const_cast<char*>(t7d8da3.prepend("WHITESPACE").constData()+10), t7d8da3.size()-10 }; });
}
struct QtGui_PackedString QTextDocument_ToRawText(void* ptr)
{
return ({ QByteArray td710b1 = static_cast<QTextDocument*>(ptr)->toRawText().toUtf8(); QtGui_PackedString { const_cast<char*>(td710b1.prepend("WHITESPACE").constData()+10), td710b1.size()-10 }; });
}
void* QTextDocument_Begin(void* ptr)
{
return new QTextBlock(static_cast<QTextDocument*>(ptr)->begin());
}
void* QTextDocument_End(void* ptr)
{
return new QTextBlock(static_cast<QTextDocument*>(ptr)->end());
}
void* QTextDocument_FindBlock(void* ptr, int pos)
{
return new QTextBlock(static_cast<QTextDocument*>(ptr)->findBlock(pos));
}
void* QTextDocument_FindBlockByLineNumber(void* ptr, int lineNumber)
{
return new QTextBlock(static_cast<QTextDocument*>(ptr)->findBlockByLineNumber(lineNumber));
}
void* QTextDocument_FindBlockByNumber(void* ptr, int blockNumber)
{
return new QTextBlock(static_cast<QTextDocument*>(ptr)->findBlockByNumber(blockNumber));
}
void* QTextDocument_FirstBlock(void* ptr)
{
return new QTextBlock(static_cast<QTextDocument*>(ptr)->firstBlock());
}
void* QTextDocument_LastBlock(void* ptr)
{
return new QTextBlock(static_cast<QTextDocument*>(ptr)->lastBlock());
}
void* QTextDocument_Find4(void* ptr, void* expr, void* cursor, long long options)
{
return new QTextCursor(static_cast<QTextDocument*>(ptr)->find(*static_cast<QRegExp*>(expr), *static_cast<QTextCursor*>(cursor), static_cast<QTextDocument::FindFlag>(options)));
}
void* QTextDocument_Find3(void* ptr, void* expr, int from, long long options)
{
return new QTextCursor(static_cast<QTextDocument*>(ptr)->find(*static_cast<QRegExp*>(expr), from, static_cast<QTextDocument::FindFlag>(options)));
}
void* QTextDocument_Find6(void* ptr, void* expr, void* cursor, long long options)
{
return new QTextCursor(static_cast<QTextDocument*>(ptr)->find(*static_cast<QRegularExpression*>(expr), *static_cast<QTextCursor*>(cursor), static_cast<QTextDocument::FindFlag>(options)));
}
void* QTextDocument_Find5(void* ptr, void* expr, int from, long long options)
{
return new QTextCursor(static_cast<QTextDocument*>(ptr)->find(*static_cast<QRegularExpression*>(expr), from, static_cast<QTextDocument::FindFlag>(options)));
}
void* QTextDocument_Find(void* ptr, struct QtGui_PackedString subString, void* cursor, long long options)
{
return new QTextCursor(static_cast<QTextDocument*>(ptr)->find(QString::fromUtf8(subString.data, subString.len), *static_cast<QTextCursor*>(cursor), static_cast<QTextDocument::FindFlag>(options)));
}
void* QTextDocument_Find2(void* ptr, struct QtGui_PackedString subString, int position, long long options)
{
return new QTextCursor(static_cast<QTextDocument*>(ptr)->find(QString::fromUtf8(subString.data, subString.len), position, static_cast<QTextDocument::FindFlag>(options)));
}
void* QTextDocument_Clone(void* ptr, void* parent)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return static_cast<QTextDocument*>(ptr)->clone(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return static_cast<QTextDocument*>(ptr)->clone(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return static_cast<QTextDocument*>(ptr)->clone(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return static_cast<QTextDocument*>(ptr)->clone(static_cast<QWindow*>(parent));
} else {
return static_cast<QTextDocument*>(ptr)->clone(static_cast<QObject*>(parent));
}
}
void* QTextDocument_RootFrame(void* ptr)
{
return static_cast<QTextDocument*>(ptr)->rootFrame();
}
void* QTextDocument_Object(void* ptr, int objectIndex)
{
return static_cast<QTextDocument*>(ptr)->object(objectIndex);
}
void* QTextDocument_ObjectForFormat(void* ptr, void* fo)
{
return static_cast<QTextDocument*>(ptr)->objectForFormat(*static_cast<QTextFormat*>(fo));
}
void* QTextDocument_DefaultTextOption(void* ptr)
{
return new QTextOption(static_cast<QTextDocument*>(ptr)->defaultTextOption());
}
void* QTextDocument_BaseUrl(void* ptr)
{
return new QUrl(static_cast<QTextDocument*>(ptr)->baseUrl());
}
void* QTextDocument_Resource(void* ptr, int ty, void* name)
{
return new QVariant(static_cast<QTextDocument*>(ptr)->resource(ty, *static_cast<QUrl*>(name)));
}
struct QtGui_PackedList QTextDocument_AllFormats(void* ptr)
{
return ({ QVector<QTextFormat>* tmpValue = new QVector<QTextFormat>(static_cast<QTextDocument*>(ptr)->allFormats()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
long long QTextDocument_DefaultCursorMoveStyle(void* ptr)
{
return static_cast<QTextDocument*>(ptr)->defaultCursorMoveStyle();
}
char QTextDocument_IsEmpty(void* ptr)
{
return static_cast<QTextDocument*>(ptr)->isEmpty();
}
char QTextDocument_IsModified(void* ptr)
{
return static_cast<QTextDocument*>(ptr)->isModified();
}
char QTextDocument_IsRedoAvailable(void* ptr)
{
return static_cast<QTextDocument*>(ptr)->isRedoAvailable();
}
char QTextDocument_IsUndoAvailable(void* ptr)
{
return static_cast<QTextDocument*>(ptr)->isUndoAvailable();
}
char QTextDocument_IsUndoRedoEnabled(void* ptr)
{
return static_cast<QTextDocument*>(ptr)->isUndoRedoEnabled();
}
char QTextDocument_UseDesignMetrics(void* ptr)
{
return static_cast<QTextDocument*>(ptr)->useDesignMetrics();
}
void* QTextDocument_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QTextDocument*>(ptr)->QTextDocument::metaObject());
}
int QTextDocument_AvailableRedoSteps(void* ptr)
{
return static_cast<QTextDocument*>(ptr)->availableRedoSteps();
}
int QTextDocument_AvailableUndoSteps(void* ptr)
{
return static_cast<QTextDocument*>(ptr)->availableUndoSteps();
}
int QTextDocument_BlockCount(void* ptr)
{
return static_cast<QTextDocument*>(ptr)->blockCount();
}
int QTextDocument_CharacterCount(void* ptr)
{
return static_cast<QTextDocument*>(ptr)->characterCount();
}
int QTextDocument_LineCount(void* ptr)
{
return static_cast<QTextDocument*>(ptr)->lineCount();
}
int QTextDocument_MaximumBlockCount(void* ptr)
{
return static_cast<QTextDocument*>(ptr)->maximumBlockCount();
}
int QTextDocument_PageCount(void* ptr)
{
return static_cast<QTextDocument*>(ptr)->pageCount();
}
int QTextDocument_Revision(void* ptr)
{
return static_cast<QTextDocument*>(ptr)->revision();
}
double QTextDocument_DocumentMargin(void* ptr)
{
return static_cast<QTextDocument*>(ptr)->documentMargin();
}
double QTextDocument_IdealWidth(void* ptr)
{
return static_cast<QTextDocument*>(ptr)->idealWidth();
}
double QTextDocument_IndentWidth(void* ptr)
{
return static_cast<QTextDocument*>(ptr)->indentWidth();
}
double QTextDocument_TextWidth(void* ptr)
{
return static_cast<QTextDocument*>(ptr)->textWidth();
}
void QTextDocument_Print(void* ptr, void* printer)
{
#ifndef Q_OS_IOS
if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(printer))) {
static_cast<QTextDocument*>(ptr)->print(static_cast<QPdfWriter*>(printer));
} else {
static_cast<QTextDocument*>(ptr)->print(static_cast<QPagedPaintDevice*>(printer));
}
#endif
}
void* QTextDocument___allFormats_atList(void* ptr, int i)
{
return new QTextFormat(({QTextFormat tmp = static_cast<QVector<QTextFormat>*>(ptr)->at(i); if (i == static_cast<QVector<QTextFormat>*>(ptr)->size()-1) { static_cast<QVector<QTextFormat>*>(ptr)->~QVector(); free(ptr); }; tmp; }));
}
void QTextDocument___allFormats_setList(void* ptr, void* i)
{
static_cast<QVector<QTextFormat>*>(ptr)->append(*static_cast<QTextFormat*>(i));
}
void* QTextDocument___allFormats_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QTextFormat>();
}
void* QTextDocument___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QTextDocument___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QTextDocument___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QTextDocument___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QTextDocument___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QTextDocument___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QTextDocument___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QTextDocument___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QTextDocument___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QTextDocument___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QTextDocument___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QTextDocument___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QTextDocument___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QTextDocument___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QTextDocument___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QTextDocument_EventDefault(void* ptr, void* e)
{
return static_cast<QTextDocument*>(ptr)->QTextDocument::event(static_cast<QEvent*>(e));
}
char QTextDocument_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QTextDocument*>(ptr)->QTextDocument::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QTextDocument*>(ptr)->QTextDocument::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QTextDocument*>(ptr)->QTextDocument::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QTextDocument*>(ptr)->QTextDocument::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QTextDocument*>(ptr)->QTextDocument::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void QTextDocument_ChildEventDefault(void* ptr, void* event)
{
static_cast<QTextDocument*>(ptr)->QTextDocument::childEvent(static_cast<QChildEvent*>(event));
}
void QTextDocument_ConnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QTextDocument*>(ptr)->QTextDocument::connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QTextDocument_CustomEventDefault(void* ptr, void* event)
{
static_cast<QTextDocument*>(ptr)->QTextDocument::customEvent(static_cast<QEvent*>(event));
}
void QTextDocument_DeleteLaterDefault(void* ptr)
{
static_cast<QTextDocument*>(ptr)->QTextDocument::deleteLater();
}
void QTextDocument_DisconnectNotifyDefault(void* ptr, void* sign)
{
static_cast<QTextDocument*>(ptr)->QTextDocument::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QTextDocument_TimerEventDefault(void* ptr, void* event)
{
static_cast<QTextDocument*>(ptr)->QTextDocument::timerEvent(static_cast<QTimerEvent*>(event));
}
void* QTextDocumentFragment_QTextDocumentFragment_FromHtml(struct QtGui_PackedString text)
{
return new QTextDocumentFragment(QTextDocumentFragment::fromHtml(QString::fromUtf8(text.data, text.len)));
}
void* QTextDocumentFragment_QTextDocumentFragment_FromHtml2(struct QtGui_PackedString text, void* resourceProvider)
{
return new QTextDocumentFragment(QTextDocumentFragment::fromHtml(QString::fromUtf8(text.data, text.len), static_cast<QTextDocument*>(resourceProvider)));
}
void* QTextDocumentFragment_QTextDocumentFragment_FromPlainText(struct QtGui_PackedString plainText)
{
return new QTextDocumentFragment(QTextDocumentFragment::fromPlainText(QString::fromUtf8(plainText.data, plainText.len)));
}
void* QTextDocumentFragment_NewQTextDocumentFragment()
{
return new QTextDocumentFragment();
}
void* QTextDocumentFragment_NewQTextDocumentFragment3(void* cursor)
{
return new QTextDocumentFragment(*static_cast<QTextCursor*>(cursor));
}
void* QTextDocumentFragment_NewQTextDocumentFragment2(void* document)
{
return new QTextDocumentFragment(static_cast<QTextDocument*>(document));
}
void* QTextDocumentFragment_NewQTextDocumentFragment4(void* other)
{
return new QTextDocumentFragment(*static_cast<QTextDocumentFragment*>(other));
}
void QTextDocumentFragment_DestroyQTextDocumentFragment(void* ptr)
{
static_cast<QTextDocumentFragment*>(ptr)->~QTextDocumentFragment();
}
struct QtGui_PackedString QTextDocumentFragment_ToHtml(void* ptr, void* encoding)
{
return ({ QByteArray t6dea0f = static_cast<QTextDocumentFragment*>(ptr)->toHtml(*static_cast<QByteArray*>(encoding)).toUtf8(); QtGui_PackedString { const_cast<char*>(t6dea0f.prepend("WHITESPACE").constData()+10), t6dea0f.size()-10 }; });
}
struct QtGui_PackedString QTextDocumentFragment_ToPlainText(void* ptr)
{
return ({ QByteArray td3666e = static_cast<QTextDocumentFragment*>(ptr)->toPlainText().toUtf8(); QtGui_PackedString { const_cast<char*>(td3666e.prepend("WHITESPACE").constData()+10), td3666e.size()-10 }; });
}
char QTextDocumentFragment_IsEmpty(void* ptr)
{
return static_cast<QTextDocumentFragment*>(ptr)->isEmpty();
}
struct QtGui_PackedList QTextDocumentWriter_QTextDocumentWriter_SupportedDocumentFormats()
{
return ({ QList<QByteArray>* tmpValue = new QList<QByteArray>(QTextDocumentWriter::supportedDocumentFormats()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QTextDocumentWriter_NewQTextDocumentWriter()
{
return new QTextDocumentWriter();
}
void* QTextDocumentWriter_NewQTextDocumentWriter2(void* device, void* format)
{
return new QTextDocumentWriter(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format));
}
void* QTextDocumentWriter_NewQTextDocumentWriter3(struct QtGui_PackedString fileName, void* format)
{
return new QTextDocumentWriter(QString::fromUtf8(fileName.data, fileName.len), *static_cast<QByteArray*>(format));
}
char QTextDocumentWriter_Write(void* ptr, void* document)
{
return static_cast<QTextDocumentWriter*>(ptr)->write(static_cast<QTextDocument*>(document));
}
char QTextDocumentWriter_Write2(void* ptr, void* fragment)
{
return static_cast<QTextDocumentWriter*>(ptr)->write(*static_cast<QTextDocumentFragment*>(fragment));
}
void QTextDocumentWriter_SetCodec(void* ptr, void* codec)
{
static_cast<QTextDocumentWriter*>(ptr)->setCodec(static_cast<QTextCodec*>(codec));
}
void QTextDocumentWriter_SetDevice(void* ptr, void* device)
{
static_cast<QTextDocumentWriter*>(ptr)->setDevice(static_cast<QIODevice*>(device));
}
void QTextDocumentWriter_SetFileName(void* ptr, struct QtGui_PackedString fileName)
{
static_cast<QTextDocumentWriter*>(ptr)->setFileName(QString::fromUtf8(fileName.data, fileName.len));
}
void QTextDocumentWriter_SetFormat(void* ptr, void* format)
{
static_cast<QTextDocumentWriter*>(ptr)->setFormat(*static_cast<QByteArray*>(format));
}
void QTextDocumentWriter_DestroyQTextDocumentWriter(void* ptr)
{
static_cast<QTextDocumentWriter*>(ptr)->~QTextDocumentWriter();
}
void* QTextDocumentWriter_Format(void* ptr)
{
return new QByteArray(static_cast<QTextDocumentWriter*>(ptr)->format());
}
void* QTextDocumentWriter_Device(void* ptr)
{
return static_cast<QTextDocumentWriter*>(ptr)->device();
}
struct QtGui_PackedString QTextDocumentWriter_FileName(void* ptr)
{
return ({ QByteArray tbc6b5c = static_cast<QTextDocumentWriter*>(ptr)->fileName().toUtf8(); QtGui_PackedString { const_cast<char*>(tbc6b5c.prepend("WHITESPACE").constData()+10), tbc6b5c.size()-10 }; });
}
void* QTextDocumentWriter_Codec(void* ptr)
{
return static_cast<QTextDocumentWriter*>(ptr)->codec();
}
void* QTextDocumentWriter___supportedDocumentFormats_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QTextDocumentWriter___supportedDocumentFormats_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QTextDocumentWriter___supportedDocumentFormats_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QTextFormat_NewQTextFormat()
{
return new QTextFormat();
}
void* QTextFormat_NewQTextFormat3(void* other)
{
return new QTextFormat(*static_cast<QTextFormat*>(other));
}
void* QTextFormat_NewQTextFormat2(int ty)
{
return new QTextFormat(ty);
}
void QTextFormat_ClearBackground(void* ptr)
{
static_cast<QTextFormat*>(ptr)->clearBackground();
}
void QTextFormat_ClearForeground(void* ptr)
{
static_cast<QTextFormat*>(ptr)->clearForeground();
}
void QTextFormat_ClearProperty(void* ptr, int propertyId)
{
static_cast<QTextFormat*>(ptr)->clearProperty(propertyId);
}
void QTextFormat_Merge(void* ptr, void* other)
{
static_cast<QTextFormat*>(ptr)->merge(*static_cast<QTextFormat*>(other));
}
void QTextFormat_SetBackground(void* ptr, void* brush)
{
static_cast<QTextFormat*>(ptr)->setBackground(*static_cast<QBrush*>(brush));
}
void QTextFormat_SetForeground(void* ptr, void* brush)
{
static_cast<QTextFormat*>(ptr)->setForeground(*static_cast<QBrush*>(brush));
}
void QTextFormat_SetLayoutDirection(void* ptr, long long direction)
{
static_cast<QTextFormat*>(ptr)->setLayoutDirection(static_cast<Qt::LayoutDirection>(direction));
}
void QTextFormat_SetObjectIndex(void* ptr, int index)
{
static_cast<QTextFormat*>(ptr)->setObjectIndex(index);
}
void QTextFormat_SetObjectType(void* ptr, int ty)
{
static_cast<QTextFormat*>(ptr)->setObjectType(ty);
}
void QTextFormat_SetProperty(void* ptr, int propertyId, void* value)
{
static_cast<QTextFormat*>(ptr)->setProperty(propertyId, *static_cast<QVariant*>(value));
}
void QTextFormat_SetProperty2(void* ptr, int propertyId, void* value)
{
static_cast<QTextFormat*>(ptr)->setProperty(propertyId, *static_cast<QVector<QTextLength>*>(value));
}
void QTextFormat_Swap(void* ptr, void* other)
{
static_cast<QTextFormat*>(ptr)->swap(*static_cast<QTextFormat*>(other));
}
void QTextFormat_DestroyQTextFormat(void* ptr)
{
static_cast<QTextFormat*>(ptr)->~QTextFormat();
}
void* QTextFormat_Background(void* ptr)
{
return new QBrush(static_cast<QTextFormat*>(ptr)->background());
}
void* QTextFormat_BrushProperty(void* ptr, int propertyId)
{
return new QBrush(static_cast<QTextFormat*>(ptr)->brushProperty(propertyId));
}
void* QTextFormat_Foreground(void* ptr)
{
return new QBrush(static_cast<QTextFormat*>(ptr)->foreground());
}
void* QTextFormat_ColorProperty(void* ptr, int propertyId)
{
return new QColor(static_cast<QTextFormat*>(ptr)->colorProperty(propertyId));
}
struct QtGui_PackedList QTextFormat_Properties(void* ptr)
{
return ({ QMap<int, QVariant>* tmpValue = new QMap<int, QVariant>(static_cast<QTextFormat*>(ptr)->properties()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QTextFormat_PenProperty(void* ptr, int propertyId)
{
return new QPen(static_cast<QTextFormat*>(ptr)->penProperty(propertyId));
}
struct QtGui_PackedString QTextFormat_StringProperty(void* ptr, int propertyId)
{
return ({ QByteArray tb40d27 = static_cast<QTextFormat*>(ptr)->stringProperty(propertyId).toUtf8(); QtGui_PackedString { const_cast<char*>(tb40d27.prepend("WHITESPACE").constData()+10), tb40d27.size()-10 }; });
}
void* QTextFormat_ToBlockFormat(void* ptr)
{
return new QTextBlockFormat(static_cast<QTextFormat*>(ptr)->toBlockFormat());
}
void* QTextFormat_ToCharFormat(void* ptr)
{
return new QTextCharFormat(static_cast<QTextFormat*>(ptr)->toCharFormat());
}
void* QTextFormat_ToFrameFormat(void* ptr)
{
return new QTextFrameFormat(static_cast<QTextFormat*>(ptr)->toFrameFormat());
}
void* QTextFormat_ToImageFormat(void* ptr)
{
return new QTextImageFormat(static_cast<QTextFormat*>(ptr)->toImageFormat());
}
void* QTextFormat_LengthProperty(void* ptr, int propertyId)
{
return new QTextLength(static_cast<QTextFormat*>(ptr)->lengthProperty(propertyId));
}
void* QTextFormat_ToListFormat(void* ptr)
{
return new QTextListFormat(static_cast<QTextFormat*>(ptr)->toListFormat());
}
void* QTextFormat_ToTableCellFormat(void* ptr)
{
return new QTextTableCellFormat(static_cast<QTextFormat*>(ptr)->toTableCellFormat());
}
void* QTextFormat_ToTableFormat(void* ptr)
{
return new QTextTableFormat(static_cast<QTextFormat*>(ptr)->toTableFormat());
}
void* QTextFormat_Property(void* ptr, int propertyId)
{
return new QVariant(static_cast<QTextFormat*>(ptr)->property(propertyId));
}
long long QTextFormat_LayoutDirection(void* ptr)
{
return static_cast<QTextFormat*>(ptr)->layoutDirection();
}
char QTextFormat_BoolProperty(void* ptr, int propertyId)
{
return static_cast<QTextFormat*>(ptr)->boolProperty(propertyId);
}
char QTextFormat_HasProperty(void* ptr, int propertyId)
{
return static_cast<QTextFormat*>(ptr)->hasProperty(propertyId);
}
char QTextFormat_IsBlockFormat(void* ptr)
{
return static_cast<QTextFormat*>(ptr)->isBlockFormat();
}
char QTextFormat_IsCharFormat(void* ptr)
{
return static_cast<QTextFormat*>(ptr)->isCharFormat();
}
char QTextFormat_IsEmpty(void* ptr)
{
return static_cast<QTextFormat*>(ptr)->isEmpty();
}
char QTextFormat_IsFrameFormat(void* ptr)
{
return static_cast<QTextFormat*>(ptr)->isFrameFormat();
}
char QTextFormat_IsImageFormat(void* ptr)
{
return static_cast<QTextFormat*>(ptr)->isImageFormat();
}
char QTextFormat_IsListFormat(void* ptr)
{
return static_cast<QTextFormat*>(ptr)->isListFormat();
}
char QTextFormat_IsTableCellFormat(void* ptr)
{
return static_cast<QTextFormat*>(ptr)->isTableCellFormat();
}
char QTextFormat_IsTableFormat(void* ptr)
{
return static_cast<QTextFormat*>(ptr)->isTableFormat();
}
char QTextFormat_IsValid(void* ptr)
{
return static_cast<QTextFormat*>(ptr)->isValid();
}
int QTextFormat_IntProperty(void* ptr, int propertyId)
{
return static_cast<QTextFormat*>(ptr)->intProperty(propertyId);
}
int QTextFormat_ObjectIndex(void* ptr)
{
return static_cast<QTextFormat*>(ptr)->objectIndex();
}
int QTextFormat_ObjectType(void* ptr)
{
return static_cast<QTextFormat*>(ptr)->objectType();
}
int QTextFormat_PropertyCount(void* ptr)
{
return static_cast<QTextFormat*>(ptr)->propertyCount();
}
int QTextFormat_Type(void* ptr)
{
return static_cast<QTextFormat*>(ptr)->type();
}
double QTextFormat_DoubleProperty(void* ptr, int propertyId)
{
return static_cast<QTextFormat*>(ptr)->doubleProperty(propertyId);
}
void* QTextFormat___setProperty_value_atList2(void* ptr, int i)
{
return new QTextLength(({QTextLength tmp = static_cast<QVector<QTextLength>*>(ptr)->at(i); if (i == static_cast<QVector<QTextLength>*>(ptr)->size()-1) { static_cast<QVector<QTextLength>*>(ptr)->~QVector(); free(ptr); }; tmp; }));
}
void QTextFormat___setProperty_value_setList2(void* ptr, void* i)
{
static_cast<QVector<QTextLength>*>(ptr)->append(*static_cast<QTextLength*>(i));
}
void* QTextFormat___setProperty_value_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QTextLength>();
}
void* QTextFormat___properties_atList(void* ptr, int v, int i)
{
return new QVariant(({ QVariant tmp = static_cast<QMap<int, QVariant>*>(ptr)->value(v); if (i == static_cast<QMap<int, QVariant>*>(ptr)->size()-1) { static_cast<QMap<int, QVariant>*>(ptr)->~QMap(); free(ptr); }; tmp; }));
}
void QTextFormat___properties_setList(void* ptr, int key, void* i)
{
static_cast<QMap<int, QVariant>*>(ptr)->insert(key, *static_cast<QVariant*>(i));
}
void* QTextFormat___properties_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QMap<int, QVariant>();
}
struct QtGui_PackedList QTextFormat___properties_keyList(void* ptr)
{
return ({ QList<int>* tmpValue = new QList<int>(static_cast<QMap<int, QVariant>*>(ptr)->keys()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QTextFormat___lengthVectorProperty_atList(void* ptr, int i)
{
return new QTextLength(({QTextLength tmp = static_cast<QVector<QTextLength>*>(ptr)->at(i); if (i == static_cast<QVector<QTextLength>*>(ptr)->size()-1) { static_cast<QVector<QTextLength>*>(ptr)->~QVector(); free(ptr); }; tmp; }));
}
void QTextFormat___lengthVectorProperty_setList(void* ptr, void* i)
{
static_cast<QVector<QTextLength>*>(ptr)->append(*static_cast<QTextLength*>(i));
}
void* QTextFormat___lengthVectorProperty_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QTextLength>();
}
int QTextFormat_____properties_keyList_atList(void* ptr, int i)
{
return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QTextFormat_____properties_keyList_setList(void* ptr, int i)
{
static_cast<QList<int>*>(ptr)->append(i);
}
void* QTextFormat_____properties_keyList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<int>();
}
void* QTextFragment_NewQTextFragment()
{
return new QTextFragment();
}
void* QTextFragment_NewQTextFragment3(void* other)
{
return new QTextFragment(*static_cast<QTextFragment*>(other));
}
struct QtGui_PackedList QTextFragment_GlyphRuns(void* ptr, int pos, int l)
{
return ({ QList<QGlyphRun>* tmpValue = new QList<QGlyphRun>(static_cast<QTextFragment*>(ptr)->glyphRuns(pos, l)); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtGui_PackedString QTextFragment_Text(void* ptr)
{
return ({ QByteArray t644af9 = static_cast<QTextFragment*>(ptr)->text().toUtf8(); QtGui_PackedString { const_cast<char*>(t644af9.prepend("WHITESPACE").constData()+10), t644af9.size()-10 }; });
}
void* QTextFragment_CharFormat(void* ptr)
{
return new QTextCharFormat(static_cast<QTextFragment*>(ptr)->charFormat());
}
char QTextFragment_Contains(void* ptr, int position)
{
return static_cast<QTextFragment*>(ptr)->contains(position);
}
char QTextFragment_IsValid(void* ptr)
{
return static_cast<QTextFragment*>(ptr)->isValid();
}
int QTextFragment_CharFormatIndex(void* ptr)
{
return static_cast<QTextFragment*>(ptr)->charFormatIndex();
}
int QTextFragment_Length(void* ptr)
{
return static_cast<QTextFragment*>(ptr)->length();
}
int QTextFragment_Position(void* ptr)
{
return static_cast<QTextFragment*>(ptr)->position();
}
void* QTextFragment___glyphRuns_atList(void* ptr, int i)
{
return new QGlyphRun(({QGlyphRun tmp = static_cast<QList<QGlyphRun>*>(ptr)->at(i); if (i == static_cast<QList<QGlyphRun>*>(ptr)->size()-1) { static_cast<QList<QGlyphRun>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QTextFragment___glyphRuns_setList(void* ptr, void* i)
{
static_cast<QList<QGlyphRun>*>(ptr)->append(*static_cast<QGlyphRun*>(i));
}
void* QTextFragment___glyphRuns_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QGlyphRun>();
}
class MyQTextFrame: public QTextFrame
{
public:
MyQTextFrame(QTextDocument *document) : QTextFrame(document) {QTextFrame_QTextFrame_QRegisterMetaType();};
~MyQTextFrame() { callbackQTextFrame_DestroyQTextFrame(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTextObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQTextObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQTextObject_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQTextObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQTextObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQTextObject_CustomEvent(this, event); };
void deleteLater() { callbackQTextObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQTextObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQTextObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQTextObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQTextObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQTextFrame*)
int QTextFrame_QTextFrame_QRegisterMetaType(){qRegisterMetaType<QTextFrame*>(); return qRegisterMetaType<MyQTextFrame*>();}
void* QTextFrame_NewQTextFrame(void* document)
{
return new MyQTextFrame(static_cast<QTextDocument*>(document));
}
void QTextFrame_SetFrameFormat(void* ptr, void* format)
{
static_cast<QTextFrame*>(ptr)->setFrameFormat(*static_cast<QTextFrameFormat*>(format));
}
void QTextFrame_DestroyQTextFrame(void* ptr)
{
static_cast<QTextFrame*>(ptr)->~QTextFrame();
}
void QTextFrame_DestroyQTextFrameDefault(void* ptr)
{
Q_UNUSED(ptr);
}
struct QtGui_PackedList QTextFrame_ChildFrames(void* ptr)
{
return ({ QList<QTextFrame *>* tmpValue = new QList<QTextFrame *>(static_cast<QTextFrame*>(ptr)->childFrames()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QTextFrame_FirstCursorPosition(void* ptr)
{
return new QTextCursor(static_cast<QTextFrame*>(ptr)->firstCursorPosition());
}
void* QTextFrame_LastCursorPosition(void* ptr)
{
return new QTextCursor(static_cast<QTextFrame*>(ptr)->lastCursorPosition());
}
void* QTextFrame_ParentFrame(void* ptr)
{
return static_cast<QTextFrame*>(ptr)->parentFrame();
}
void* QTextFrame_FrameFormat(void* ptr)
{
return new QTextFrameFormat(static_cast<QTextFrame*>(ptr)->frameFormat());
}
int QTextFrame_FirstPosition(void* ptr)
{
return static_cast<QTextFrame*>(ptr)->firstPosition();
}
int QTextFrame_LastPosition(void* ptr)
{
return static_cast<QTextFrame*>(ptr)->lastPosition();
}
void* QTextFrame___childFrames_atList(void* ptr, int i)
{
return ({QTextFrame * tmp = static_cast<QList<QTextFrame *>*>(ptr)->at(i); if (i == static_cast<QList<QTextFrame *>*>(ptr)->size()-1) { static_cast<QList<QTextFrame *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QTextFrame___childFrames_setList(void* ptr, void* i)
{
static_cast<QList<QTextFrame *>*>(ptr)->append(static_cast<QTextFrame*>(i));
}
void* QTextFrame___childFrames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QTextFrame *>();
}
void* QTextFrameFormat_NewQTextFrameFormat()
{
return new QTextFrameFormat();
}
void QTextFrameFormat_SetBorder(void* ptr, double width)
{
static_cast<QTextFrameFormat*>(ptr)->setBorder(width);
}
void QTextFrameFormat_SetBorderBrush(void* ptr, void* brush)
{
static_cast<QTextFrameFormat*>(ptr)->setBorderBrush(*static_cast<QBrush*>(brush));
}
void QTextFrameFormat_SetBorderStyle(void* ptr, long long style)
{
static_cast<QTextFrameFormat*>(ptr)->setBorderStyle(static_cast<QTextFrameFormat::BorderStyle>(style));
}
void QTextFrameFormat_SetBottomMargin(void* ptr, double margin)
{
static_cast<QTextFrameFormat*>(ptr)->setBottomMargin(margin);
}
void QTextFrameFormat_SetHeight(void* ptr, void* height)
{
static_cast<QTextFrameFormat*>(ptr)->setHeight(*static_cast<QTextLength*>(height));
}
void QTextFrameFormat_SetHeight2(void* ptr, double height)
{
static_cast<QTextFrameFormat*>(ptr)->setHeight(height);
}
void QTextFrameFormat_SetLeftMargin(void* ptr, double margin)
{
static_cast<QTextFrameFormat*>(ptr)->setLeftMargin(margin);
}
void QTextFrameFormat_SetMargin(void* ptr, double margin)
{
static_cast<QTextFrameFormat*>(ptr)->setMargin(margin);
}
void QTextFrameFormat_SetPadding(void* ptr, double width)
{
static_cast<QTextFrameFormat*>(ptr)->setPadding(width);
}
void QTextFrameFormat_SetPageBreakPolicy(void* ptr, long long policy)
{
static_cast<QTextFrameFormat*>(ptr)->setPageBreakPolicy(static_cast<QTextFormat::PageBreakFlag>(policy));
}
void QTextFrameFormat_SetPosition(void* ptr, long long policy)
{
static_cast<QTextFrameFormat*>(ptr)->setPosition(static_cast<QTextFrameFormat::Position>(policy));
}
void QTextFrameFormat_SetRightMargin(void* ptr, double margin)
{
static_cast<QTextFrameFormat*>(ptr)->setRightMargin(margin);
}
void QTextFrameFormat_SetTopMargin(void* ptr, double margin)
{
static_cast<QTextFrameFormat*>(ptr)->setTopMargin(margin);
}
void QTextFrameFormat_SetWidth(void* ptr, void* width)
{
static_cast<QTextFrameFormat*>(ptr)->setWidth(*static_cast<QTextLength*>(width));
}
void QTextFrameFormat_SetWidth2(void* ptr, double width)
{
static_cast<QTextFrameFormat*>(ptr)->setWidth(width);
}
void* QTextFrameFormat_BorderBrush(void* ptr)
{
return new QBrush(static_cast<QTextFrameFormat*>(ptr)->borderBrush());
}
long long QTextFrameFormat_PageBreakPolicy(void* ptr)
{
return static_cast<QTextFrameFormat*>(ptr)->pageBreakPolicy();
}
long long QTextFrameFormat_BorderStyle(void* ptr)
{
return static_cast<QTextFrameFormat*>(ptr)->borderStyle();
}
long long QTextFrameFormat_Position(void* ptr)
{
return static_cast<QTextFrameFormat*>(ptr)->position();
}
void* QTextFrameFormat_Height(void* ptr)
{
return new QTextLength(static_cast<QTextFrameFormat*>(ptr)->height());
}
void* QTextFrameFormat_Width(void* ptr)
{
return new QTextLength(static_cast<QTextFrameFormat*>(ptr)->width());
}
double QTextFrameFormat_Border(void* ptr)
{
return static_cast<QTextFrameFormat*>(ptr)->border();
}
double QTextFrameFormat_BottomMargin(void* ptr)
{
return static_cast<QTextFrameFormat*>(ptr)->bottomMargin();
}
double QTextFrameFormat_LeftMargin(void* ptr)
{
return static_cast<QTextFrameFormat*>(ptr)->leftMargin();
}
double QTextFrameFormat_Margin(void* ptr)
{
return static_cast<QTextFrameFormat*>(ptr)->margin();
}
double QTextFrameFormat_Padding(void* ptr)
{
return static_cast<QTextFrameFormat*>(ptr)->padding();
}
double QTextFrameFormat_RightMargin(void* ptr)
{
return static_cast<QTextFrameFormat*>(ptr)->rightMargin();
}
double QTextFrameFormat_TopMargin(void* ptr)
{
return static_cast<QTextFrameFormat*>(ptr)->topMargin();
}
void* QTextImageFormat_NewQTextImageFormat()
{
return new QTextImageFormat();
}
void QTextImageFormat_SetHeight(void* ptr, double height)
{
static_cast<QTextImageFormat*>(ptr)->setHeight(height);
}
void QTextImageFormat_SetName(void* ptr, struct QtGui_PackedString name)
{
static_cast<QTextImageFormat*>(ptr)->setName(QString::fromUtf8(name.data, name.len));
}
void QTextImageFormat_SetWidth(void* ptr, double width)
{
static_cast<QTextImageFormat*>(ptr)->setWidth(width);
}
struct QtGui_PackedString QTextImageFormat_Name(void* ptr)
{
return ({ QByteArray t290038 = static_cast<QTextImageFormat*>(ptr)->name().toUtf8(); QtGui_PackedString { const_cast<char*>(t290038.prepend("WHITESPACE").constData()+10), t290038.size()-10 }; });
}
double QTextImageFormat_Height(void* ptr)
{
return static_cast<QTextImageFormat*>(ptr)->height();
}
double QTextImageFormat_Width(void* ptr)
{
return static_cast<QTextImageFormat*>(ptr)->width();
}
void QTextInlineObject_SetAscent(void* ptr, double a)
{
static_cast<QTextInlineObject*>(ptr)->setAscent(a);
}
void QTextInlineObject_SetDescent(void* ptr, double d)
{
static_cast<QTextInlineObject*>(ptr)->setDescent(d);
}
void QTextInlineObject_SetWidth(void* ptr, double w)
{
static_cast<QTextInlineObject*>(ptr)->setWidth(w);
}
void* QTextInlineObject_Rect(void* ptr)
{
return ({ QRectF tmpValue = static_cast<QTextInlineObject*>(ptr)->rect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QTextInlineObject_Format(void* ptr)
{
return new QTextFormat(static_cast<QTextInlineObject*>(ptr)->format());
}
long long QTextInlineObject_TextDirection(void* ptr)
{
return static_cast<QTextInlineObject*>(ptr)->textDirection();
}
char QTextInlineObject_IsValid(void* ptr)
{
return static_cast<QTextInlineObject*>(ptr)->isValid();
}
int QTextInlineObject_FormatIndex(void* ptr)
{
return static_cast<QTextInlineObject*>(ptr)->formatIndex();
}
int QTextInlineObject_TextPosition(void* ptr)
{
return static_cast<QTextInlineObject*>(ptr)->textPosition();
}
double QTextInlineObject_Ascent(void* ptr)
{
return static_cast<QTextInlineObject*>(ptr)->ascent();
}
double QTextInlineObject_Descent(void* ptr)
{
return static_cast<QTextInlineObject*>(ptr)->descent();
}
double QTextInlineObject_Height(void* ptr)
{
return static_cast<QTextInlineObject*>(ptr)->height();
}
double QTextInlineObject_Width(void* ptr)
{
return static_cast<QTextInlineObject*>(ptr)->width();
}
void* QTextItem_Font(void* ptr)
{
return new QFont(static_cast<QTextItem*>(ptr)->font());
}
struct QtGui_PackedString QTextItem_Text(void* ptr)
{
return ({ QByteArray te8cb06 = static_cast<QTextItem*>(ptr)->text().toUtf8(); QtGui_PackedString { const_cast<char*>(te8cb06.prepend("WHITESPACE").constData()+10), te8cb06.size()-10 }; });
}
long long QTextItem_RenderFlags(void* ptr)
{
return static_cast<QTextItem*>(ptr)->renderFlags();
}
double QTextItem_Ascent(void* ptr)
{
return static_cast<QTextItem*>(ptr)->ascent();
}
double QTextItem_Descent(void* ptr)
{
return static_cast<QTextItem*>(ptr)->descent();
}
double QTextItem_Width(void* ptr)
{
return static_cast<QTextItem*>(ptr)->width();
}
void* QTextLayout_NewQTextLayout()
{
return new QTextLayout();
}
void* QTextLayout_NewQTextLayout2(struct QtGui_PackedString text)
{
return new QTextLayout(QString::fromUtf8(text.data, text.len));
}
void* QTextLayout_NewQTextLayout3(struct QtGui_PackedString text, void* font, void* paintdevice)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(paintdevice))) {
return new QTextLayout(QString::fromUtf8(text.data, text.len), *static_cast<QFont*>(font), static_cast<QPaintDeviceWindow*>(paintdevice));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(paintdevice))) {
return new QTextLayout(QString::fromUtf8(text.data, text.len), *static_cast<QFont*>(font), static_cast<QPdfWriter*>(paintdevice));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(paintdevice))) {
return new QTextLayout(QString::fromUtf8(text.data, text.len), *static_cast<QFont*>(font), static_cast<QWidget*>(paintdevice));
} else {
return new QTextLayout(QString::fromUtf8(text.data, text.len), *static_cast<QFont*>(font), static_cast<QPaintDevice*>(paintdevice));
}
}
void* QTextLayout_CreateLine(void* ptr)
{
return new QTextLine(static_cast<QTextLayout*>(ptr)->createLine());
}
void QTextLayout_BeginLayout(void* ptr)
{
static_cast<QTextLayout*>(ptr)->beginLayout();
}
void QTextLayout_ClearFormats(void* ptr)
{
static_cast<QTextLayout*>(ptr)->clearFormats();
}
void QTextLayout_ClearLayout(void* ptr)
{
static_cast<QTextLayout*>(ptr)->clearLayout();
}
void QTextLayout_EndLayout(void* ptr)
{
static_cast<QTextLayout*>(ptr)->endLayout();
}
void QTextLayout_SetCacheEnabled(void* ptr, char enable)
{
static_cast<QTextLayout*>(ptr)->setCacheEnabled(enable != 0);
}
void QTextLayout_SetCursorMoveStyle(void* ptr, long long style)
{
static_cast<QTextLayout*>(ptr)->setCursorMoveStyle(static_cast<Qt::CursorMoveStyle>(style));
}
void QTextLayout_SetFont(void* ptr, void* font)
{
static_cast<QTextLayout*>(ptr)->setFont(*static_cast<QFont*>(font));
}
void QTextLayout_SetPosition(void* ptr, void* p)
{
static_cast<QTextLayout*>(ptr)->setPosition(*static_cast<QPointF*>(p));
}
void QTextLayout_SetPreeditArea(void* ptr, int position, struct QtGui_PackedString text)
{
static_cast<QTextLayout*>(ptr)->setPreeditArea(position, QString::fromUtf8(text.data, text.len));
}
void QTextLayout_SetText(void* ptr, struct QtGui_PackedString stri)
{
static_cast<QTextLayout*>(ptr)->setText(QString::fromUtf8(stri.data, stri.len));
}
void QTextLayout_SetTextOption(void* ptr, void* option)
{
static_cast<QTextLayout*>(ptr)->setTextOption(*static_cast<QTextOption*>(option));
}
void QTextLayout_DestroyQTextLayout(void* ptr)
{
static_cast<QTextLayout*>(ptr)->~QTextLayout();
}
void* QTextLayout_Font(void* ptr)
{
return new QFont(static_cast<QTextLayout*>(ptr)->font());
}
struct QtGui_PackedList QTextLayout_GlyphRuns(void* ptr, int from, int length)
{
return ({ QList<QGlyphRun>* tmpValue = new QList<QGlyphRun>(static_cast<QTextLayout*>(ptr)->glyphRuns(from, length)); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QTextLayout_Position(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QTextLayout*>(ptr)->position(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void* QTextLayout_BoundingRect(void* ptr)
{
return ({ QRectF tmpValue = static_cast<QTextLayout*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
struct QtGui_PackedString QTextLayout_PreeditAreaText(void* ptr)
{
return ({ QByteArray t04bdaa = static_cast<QTextLayout*>(ptr)->preeditAreaText().toUtf8(); QtGui_PackedString { const_cast<char*>(t04bdaa.prepend("WHITESPACE").constData()+10), t04bdaa.size()-10 }; });
}
struct QtGui_PackedString QTextLayout_Text(void* ptr)
{
return ({ QByteArray t7e8d3c = static_cast<QTextLayout*>(ptr)->text().toUtf8(); QtGui_PackedString { const_cast<char*>(t7e8d3c.prepend("WHITESPACE").constData()+10), t7e8d3c.size()-10 }; });
}
void* QTextLayout_LineAt(void* ptr, int i)
{
return new QTextLine(static_cast<QTextLayout*>(ptr)->lineAt(i));
}
void* QTextLayout_LineForTextPosition(void* ptr, int pos)
{
return new QTextLine(static_cast<QTextLayout*>(ptr)->lineForTextPosition(pos));
}
long long QTextLayout_CursorMoveStyle(void* ptr)
{
return static_cast<QTextLayout*>(ptr)->cursorMoveStyle();
}
char QTextLayout_CacheEnabled(void* ptr)
{
return static_cast<QTextLayout*>(ptr)->cacheEnabled();
}
char QTextLayout_IsValidCursorPosition(void* ptr, int pos)
{
return static_cast<QTextLayout*>(ptr)->isValidCursorPosition(pos);
}
void* QTextLayout_TextOption(void* ptr)
{
return const_cast<QTextOption*>(&static_cast<QTextLayout*>(ptr)->textOption());
}
int QTextLayout_LeftCursorPosition(void* ptr, int oldPos)
{
return static_cast<QTextLayout*>(ptr)->leftCursorPosition(oldPos);
}
int QTextLayout_LineCount(void* ptr)
{
return static_cast<QTextLayout*>(ptr)->lineCount();
}
int QTextLayout_NextCursorPosition(void* ptr, int oldPos, long long mode)
{
return static_cast<QTextLayout*>(ptr)->nextCursorPosition(oldPos, static_cast<QTextLayout::CursorMode>(mode));
}
int QTextLayout_PreeditAreaPosition(void* ptr)
{
return static_cast<QTextLayout*>(ptr)->preeditAreaPosition();
}
int QTextLayout_PreviousCursorPosition(void* ptr, int oldPos, long long mode)
{
return static_cast<QTextLayout*>(ptr)->previousCursorPosition(oldPos, static_cast<QTextLayout::CursorMode>(mode));
}
int QTextLayout_RightCursorPosition(void* ptr, int oldPos)
{
return static_cast<QTextLayout*>(ptr)->rightCursorPosition(oldPos);
}
double QTextLayout_MaximumWidth(void* ptr)
{
return static_cast<QTextLayout*>(ptr)->maximumWidth();
}
double QTextLayout_MinimumWidth(void* ptr)
{
return static_cast<QTextLayout*>(ptr)->minimumWidth();
}
void QTextLayout_DrawCursor2(void* ptr, void* painter, void* position, int cursorPosition)
{
static_cast<QTextLayout*>(ptr)->drawCursor(static_cast<QPainter*>(painter), *static_cast<QPointF*>(position), cursorPosition);
}
void QTextLayout_DrawCursor(void* ptr, void* painter, void* position, int cursorPosition, int width)
{
static_cast<QTextLayout*>(ptr)->drawCursor(static_cast<QPainter*>(painter), *static_cast<QPointF*>(position), cursorPosition, width);
}
void* QTextLayout___glyphRuns_atList(void* ptr, int i)
{
return new QGlyphRun(({QGlyphRun tmp = static_cast<QList<QGlyphRun>*>(ptr)->at(i); if (i == static_cast<QList<QGlyphRun>*>(ptr)->size()-1) { static_cast<QList<QGlyphRun>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QTextLayout___glyphRuns_setList(void* ptr, void* i)
{
static_cast<QList<QGlyphRun>*>(ptr)->append(*static_cast<QGlyphRun*>(i));
}
void* QTextLayout___glyphRuns_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QGlyphRun>();
}
void* QTextLength_NewQTextLength()
{
return new QTextLength();
}
void* QTextLength_NewQTextLength2(long long ty, double value)
{
return new QTextLength(static_cast<QTextLength::Type>(ty), value);
}
long long QTextLength_Type(void* ptr)
{
return static_cast<QTextLength*>(ptr)->type();
}
double QTextLength_RawValue(void* ptr)
{
return static_cast<QTextLength*>(ptr)->rawValue();
}
double QTextLength_Value(void* ptr, double maximumLength)
{
return static_cast<QTextLength*>(ptr)->value(maximumLength);
}
void* QTextLine_NewQTextLine()
{
return new QTextLine();
}
void QTextLine_SetLeadingIncluded(void* ptr, char included)
{
static_cast<QTextLine*>(ptr)->setLeadingIncluded(included != 0);
}
void QTextLine_SetLineWidth(void* ptr, double width)
{
static_cast<QTextLine*>(ptr)->setLineWidth(width);
}
void QTextLine_SetNumColumns(void* ptr, int numColumns)
{
static_cast<QTextLine*>(ptr)->setNumColumns(numColumns);
}
void QTextLine_SetNumColumns2(void* ptr, int numColumns, double alignmentWidth)
{
static_cast<QTextLine*>(ptr)->setNumColumns(numColumns, alignmentWidth);
}
void QTextLine_SetPosition(void* ptr, void* pos)
{
static_cast<QTextLine*>(ptr)->setPosition(*static_cast<QPointF*>(pos));
}
struct QtGui_PackedList QTextLine_GlyphRuns(void* ptr, int from, int length)
{
return ({ QList<QGlyphRun>* tmpValue = new QList<QGlyphRun>(static_cast<QTextLine*>(ptr)->glyphRuns(from, length)); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QTextLine_Position(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QTextLine*>(ptr)->position(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void* QTextLine_NaturalTextRect(void* ptr)
{
return ({ QRectF tmpValue = static_cast<QTextLine*>(ptr)->naturalTextRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QTextLine_Rect(void* ptr)
{
return ({ QRectF tmpValue = static_cast<QTextLine*>(ptr)->rect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
char QTextLine_IsValid(void* ptr)
{
return static_cast<QTextLine*>(ptr)->isValid();
}
char QTextLine_LeadingIncluded(void* ptr)
{
return static_cast<QTextLine*>(ptr)->leadingIncluded();
}
int QTextLine_LineNumber(void* ptr)
{
return static_cast<QTextLine*>(ptr)->lineNumber();
}
int QTextLine_TextLength(void* ptr)
{
return static_cast<QTextLine*>(ptr)->textLength();
}
int QTextLine_TextStart(void* ptr)
{
return static_cast<QTextLine*>(ptr)->textStart();
}
int QTextLine_XToCursor(void* ptr, double x, long long cpos)
{
return static_cast<QTextLine*>(ptr)->xToCursor(x, static_cast<QTextLine::CursorPosition>(cpos));
}
double QTextLine_Ascent(void* ptr)
{
return static_cast<QTextLine*>(ptr)->ascent();
}
double QTextLine_CursorToX(void* ptr, int cursorPos, long long edge)
{
return static_cast<QTextLine*>(ptr)->cursorToX(&cursorPos, static_cast<QTextLine::Edge>(edge));
}
double QTextLine_CursorToX2(void* ptr, int cursorPos, long long edge)
{
return static_cast<QTextLine*>(ptr)->cursorToX(cursorPos, static_cast<QTextLine::Edge>(edge));
}
double QTextLine_Descent(void* ptr)
{
return static_cast<QTextLine*>(ptr)->descent();
}
double QTextLine_Height(void* ptr)
{
return static_cast<QTextLine*>(ptr)->height();
}
double QTextLine_HorizontalAdvance(void* ptr)
{
return static_cast<QTextLine*>(ptr)->horizontalAdvance();
}
double QTextLine_Leading(void* ptr)
{
return static_cast<QTextLine*>(ptr)->leading();
}
double QTextLine_NaturalTextWidth(void* ptr)
{
return static_cast<QTextLine*>(ptr)->naturalTextWidth();
}
double QTextLine_Width(void* ptr)
{
return static_cast<QTextLine*>(ptr)->width();
}
double QTextLine_X(void* ptr)
{
return static_cast<QTextLine*>(ptr)->x();
}
double QTextLine_Y(void* ptr)
{
return static_cast<QTextLine*>(ptr)->y();
}
void* QTextLine___glyphRuns_atList(void* ptr, int i)
{
return new QGlyphRun(({QGlyphRun tmp = static_cast<QList<QGlyphRun>*>(ptr)->at(i); if (i == static_cast<QList<QGlyphRun>*>(ptr)->size()-1) { static_cast<QList<QGlyphRun>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QTextLine___glyphRuns_setList(void* ptr, void* i)
{
static_cast<QList<QGlyphRun>*>(ptr)->append(*static_cast<QGlyphRun*>(i));
}
void* QTextLine___glyphRuns_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QGlyphRun>();
}
class MyQTextList: public QTextList
{
public:
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTextObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void blockFormatChanged(const QTextBlock & block) { callbackQTextBlockGroup_BlockFormatChanged(this, const_cast<QTextBlock*>(&block)); };
void blockInserted(const QTextBlock & block) { callbackQTextBlockGroup_BlockInserted(this, const_cast<QTextBlock*>(&block)); };
void blockRemoved(const QTextBlock & block) { callbackQTextBlockGroup_BlockRemoved(this, const_cast<QTextBlock*>(&block)); };
bool event(QEvent * e) { return callbackQTextObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQTextObject_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQTextObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQTextObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQTextObject_CustomEvent(this, event); };
void deleteLater() { callbackQTextObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQTextObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQTextObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQTextObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQTextObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQTextList*)
int QTextList_QTextList_QRegisterMetaType(){qRegisterMetaType<QTextList*>(); return qRegisterMetaType<MyQTextList*>();}
void QTextList_Add(void* ptr, void* block)
{
static_cast<QTextList*>(ptr)->add(*static_cast<QTextBlock*>(block));
}
void QTextList_Remove(void* ptr, void* block)
{
static_cast<QTextList*>(ptr)->remove(*static_cast<QTextBlock*>(block));
}
void QTextList_RemoveItem(void* ptr, int i)
{
static_cast<QTextList*>(ptr)->removeItem(i);
}
void QTextList_SetFormat(void* ptr, void* format)
{
static_cast<QTextList*>(ptr)->setFormat(*static_cast<QTextListFormat*>(format));
}
struct QtGui_PackedString QTextList_ItemText(void* ptr, void* block)
{
return ({ QByteArray tedd0af = static_cast<QTextList*>(ptr)->itemText(*static_cast<QTextBlock*>(block)).toUtf8(); QtGui_PackedString { const_cast<char*>(tedd0af.prepend("WHITESPACE").constData()+10), tedd0af.size()-10 }; });
}
void* QTextList_Item(void* ptr, int i)
{
return new QTextBlock(static_cast<QTextList*>(ptr)->item(i));
}
void* QTextList_Format(void* ptr)
{
return new QTextListFormat(static_cast<QTextList*>(ptr)->format());
}
int QTextList_Count(void* ptr)
{
return static_cast<QTextList*>(ptr)->count();
}
int QTextList_ItemNumber(void* ptr, void* block)
{
return static_cast<QTextList*>(ptr)->itemNumber(*static_cast<QTextBlock*>(block));
}
void* QTextListFormat_NewQTextListFormat()
{
return new QTextListFormat();
}
void QTextListFormat_SetIndent(void* ptr, int indentation)
{
static_cast<QTextListFormat*>(ptr)->setIndent(indentation);
}
void QTextListFormat_SetNumberPrefix(void* ptr, struct QtGui_PackedString numberPrefix)
{
static_cast<QTextListFormat*>(ptr)->setNumberPrefix(QString::fromUtf8(numberPrefix.data, numberPrefix.len));
}
void QTextListFormat_SetNumberSuffix(void* ptr, struct QtGui_PackedString numberSuffix)
{
static_cast<QTextListFormat*>(ptr)->setNumberSuffix(QString::fromUtf8(numberSuffix.data, numberSuffix.len));
}
void QTextListFormat_SetStyle(void* ptr, long long style)
{
static_cast<QTextListFormat*>(ptr)->setStyle(static_cast<QTextListFormat::Style>(style));
}
struct QtGui_PackedString QTextListFormat_NumberPrefix(void* ptr)
{
return ({ QByteArray t46a4a3 = static_cast<QTextListFormat*>(ptr)->numberPrefix().toUtf8(); QtGui_PackedString { const_cast<char*>(t46a4a3.prepend("WHITESPACE").constData()+10), t46a4a3.size()-10 }; });
}
struct QtGui_PackedString QTextListFormat_NumberSuffix(void* ptr)
{
return ({ QByteArray t6ba6a5 = static_cast<QTextListFormat*>(ptr)->numberSuffix().toUtf8(); QtGui_PackedString { const_cast<char*>(t6ba6a5.prepend("WHITESPACE").constData()+10), t6ba6a5.size()-10 }; });
}
long long QTextListFormat_Style(void* ptr)
{
return static_cast<QTextListFormat*>(ptr)->style();
}
int QTextListFormat_Indent(void* ptr)
{
return static_cast<QTextListFormat*>(ptr)->indent();
}
class MyQTextObject: public QTextObject
{
public:
MyQTextObject(QTextDocument *document) : QTextObject(document) {QTextObject_QTextObject_QRegisterMetaType();};
~MyQTextObject() { callbackQTextObject_DestroyQTextObject(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTextObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQTextObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQTextObject_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQTextObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQTextObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQTextObject_CustomEvent(this, event); };
void deleteLater() { callbackQTextObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQTextObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQTextObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQTextObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQTextObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQTextObject*)
int QTextObject_QTextObject_QRegisterMetaType(){qRegisterMetaType<QTextObject*>(); return qRegisterMetaType<MyQTextObject*>();}
struct QtGui_PackedString QTextObject_QTextObject_Tr(char* s, char* c, int n)
{
return ({ QByteArray t93b5f6 = QTextObject::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t93b5f6.prepend("WHITESPACE").constData()+10), t93b5f6.size()-10 }; });
}
struct QtGui_PackedString QTextObject_QTextObject_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray t13c192 = QTextObject::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t13c192.prepend("WHITESPACE").constData()+10), t13c192.size()-10 }; });
}
void* QTextObject_NewQTextObject(void* document)
{
return new MyQTextObject(static_cast<QTextDocument*>(document));
}
void QTextObject_SetFormat(void* ptr, void* format)
{
static_cast<QTextObject*>(ptr)->setFormat(*static_cast<QTextFormat*>(format));
}
void QTextObject_DestroyQTextObject(void* ptr)
{
static_cast<QTextObject*>(ptr)->~QTextObject();
}
void QTextObject_DestroyQTextObjectDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QTextObject_Document(void* ptr)
{
return static_cast<QTextObject*>(ptr)->document();
}
void* QTextObject_Format(void* ptr)
{
return new QTextFormat(static_cast<QTextObject*>(ptr)->format());
}
void* QTextObject_MetaObjectDefault(void* ptr)
{
if (dynamic_cast<QTextTable*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QTextTable*>(ptr)->QTextTable::metaObject());
} else if (dynamic_cast<QTextFrame*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QTextFrame*>(ptr)->QTextFrame::metaObject());
} else if (dynamic_cast<QTextList*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QTextList*>(ptr)->QTextList::metaObject());
} else if (dynamic_cast<QTextBlockGroup*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::metaObject());
} else {
return const_cast<QMetaObject*>(static_cast<QTextObject*>(ptr)->QTextObject::metaObject());
}
}
int QTextObject_FormatIndex(void* ptr)
{
return static_cast<QTextObject*>(ptr)->formatIndex();
}
int QTextObject_ObjectIndex(void* ptr)
{
return static_cast<QTextObject*>(ptr)->objectIndex();
}
void* QTextObject___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QTextObject___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QTextObject___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QTextObject___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QTextObject___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QTextObject___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QTextObject___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QTextObject___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QTextObject___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QTextObject___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QTextObject___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QTextObject___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QTextObject___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QTextObject___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QTextObject___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QTextObject_EventDefault(void* ptr, void* e)
{
if (dynamic_cast<QTextTable*>(static_cast<QObject*>(ptr))) {
return static_cast<QTextTable*>(ptr)->QTextTable::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QTextFrame*>(static_cast<QObject*>(ptr))) {
return static_cast<QTextFrame*>(ptr)->QTextFrame::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QTextList*>(static_cast<QObject*>(ptr))) {
return static_cast<QTextList*>(ptr)->QTextList::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QTextBlockGroup*>(static_cast<QObject*>(ptr))) {
return static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::event(static_cast<QEvent*>(e));
} else {
return static_cast<QTextObject*>(ptr)->QTextObject::event(static_cast<QEvent*>(e));
}
}
char QTextObject_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QTextTable*>(static_cast<QObject*>(ptr))) {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QTextTable*>(ptr)->QTextTable::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QTextTable*>(ptr)->QTextTable::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QTextTable*>(ptr)->QTextTable::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QTextTable*>(ptr)->QTextTable::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QTextTable*>(ptr)->QTextTable::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
} else if (dynamic_cast<QTextFrame*>(static_cast<QObject*>(ptr))) {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QTextFrame*>(ptr)->QTextFrame::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QTextFrame*>(ptr)->QTextFrame::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QTextFrame*>(ptr)->QTextFrame::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QTextFrame*>(ptr)->QTextFrame::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QTextFrame*>(ptr)->QTextFrame::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
} else if (dynamic_cast<QTextList*>(static_cast<QObject*>(ptr))) {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QTextList*>(ptr)->QTextList::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QTextList*>(ptr)->QTextList::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QTextList*>(ptr)->QTextList::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QTextList*>(ptr)->QTextList::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QTextList*>(ptr)->QTextList::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
} else if (dynamic_cast<QTextBlockGroup*>(static_cast<QObject*>(ptr))) {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
} else {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QTextObject*>(ptr)->QTextObject::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QTextObject*>(ptr)->QTextObject::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QTextObject*>(ptr)->QTextObject::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QTextObject*>(ptr)->QTextObject::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QTextObject*>(ptr)->QTextObject::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
}
void QTextObject_ChildEventDefault(void* ptr, void* event)
{
if (dynamic_cast<QTextTable*>(static_cast<QObject*>(ptr))) {
static_cast<QTextTable*>(ptr)->QTextTable::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QTextFrame*>(static_cast<QObject*>(ptr))) {
static_cast<QTextFrame*>(ptr)->QTextFrame::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QTextList*>(static_cast<QObject*>(ptr))) {
static_cast<QTextList*>(ptr)->QTextList::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QTextBlockGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::childEvent(static_cast<QChildEvent*>(event));
} else {
static_cast<QTextObject*>(ptr)->QTextObject::childEvent(static_cast<QChildEvent*>(event));
}
}
void QTextObject_ConnectNotifyDefault(void* ptr, void* sign)
{
if (dynamic_cast<QTextTable*>(static_cast<QObject*>(ptr))) {
static_cast<QTextTable*>(ptr)->QTextTable::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QTextFrame*>(static_cast<QObject*>(ptr))) {
static_cast<QTextFrame*>(ptr)->QTextFrame::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QTextList*>(static_cast<QObject*>(ptr))) {
static_cast<QTextList*>(ptr)->QTextList::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QTextBlockGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::connectNotify(*static_cast<QMetaMethod*>(sign));
} else {
static_cast<QTextObject*>(ptr)->QTextObject::connectNotify(*static_cast<QMetaMethod*>(sign));
}
}
void QTextObject_CustomEventDefault(void* ptr, void* event)
{
if (dynamic_cast<QTextTable*>(static_cast<QObject*>(ptr))) {
static_cast<QTextTable*>(ptr)->QTextTable::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QTextFrame*>(static_cast<QObject*>(ptr))) {
static_cast<QTextFrame*>(ptr)->QTextFrame::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QTextList*>(static_cast<QObject*>(ptr))) {
static_cast<QTextList*>(ptr)->QTextList::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QTextBlockGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::customEvent(static_cast<QEvent*>(event));
} else {
static_cast<QTextObject*>(ptr)->QTextObject::customEvent(static_cast<QEvent*>(event));
}
}
void QTextObject_DeleteLaterDefault(void* ptr)
{
if (dynamic_cast<QTextTable*>(static_cast<QObject*>(ptr))) {
static_cast<QTextTable*>(ptr)->QTextTable::deleteLater();
} else if (dynamic_cast<QTextFrame*>(static_cast<QObject*>(ptr))) {
static_cast<QTextFrame*>(ptr)->QTextFrame::deleteLater();
} else if (dynamic_cast<QTextList*>(static_cast<QObject*>(ptr))) {
static_cast<QTextList*>(ptr)->QTextList::deleteLater();
} else if (dynamic_cast<QTextBlockGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::deleteLater();
} else {
static_cast<QTextObject*>(ptr)->QTextObject::deleteLater();
}
}
void QTextObject_DisconnectNotifyDefault(void* ptr, void* sign)
{
if (dynamic_cast<QTextTable*>(static_cast<QObject*>(ptr))) {
static_cast<QTextTable*>(ptr)->QTextTable::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QTextFrame*>(static_cast<QObject*>(ptr))) {
static_cast<QTextFrame*>(ptr)->QTextFrame::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QTextList*>(static_cast<QObject*>(ptr))) {
static_cast<QTextList*>(ptr)->QTextList::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QTextBlockGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else {
static_cast<QTextObject*>(ptr)->QTextObject::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
}
void QTextObject_TimerEventDefault(void* ptr, void* event)
{
if (dynamic_cast<QTextTable*>(static_cast<QObject*>(ptr))) {
static_cast<QTextTable*>(ptr)->QTextTable::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QTextFrame*>(static_cast<QObject*>(ptr))) {
static_cast<QTextFrame*>(ptr)->QTextFrame::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QTextList*>(static_cast<QObject*>(ptr))) {
static_cast<QTextList*>(ptr)->QTextList::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QTextBlockGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::timerEvent(static_cast<QTimerEvent*>(event));
} else {
static_cast<QTextObject*>(ptr)->QTextObject::timerEvent(static_cast<QTimerEvent*>(event));
}
}
class MyQTextObjectInterface: public QTextObjectInterface
{
public:
QSizeF intrinsicSize(QTextDocument * doc, int posInDocument, const QTextFormat & format) { return *static_cast<QSizeF*>(callbackQTextObjectInterface_IntrinsicSize(this, doc, posInDocument, const_cast<QTextFormat*>(&format))); };
void drawObject(QPainter * painter, const QRectF & rect, QTextDocument * doc, int posInDocument, const QTextFormat & format) { callbackQTextObjectInterface_DrawObject(this, painter, const_cast<QRectF*>(&rect), doc, posInDocument, const_cast<QTextFormat*>(&format)); };
~MyQTextObjectInterface() { callbackQTextObjectInterface_DestroyQTextObjectInterface(this); };
};
void* QTextObjectInterface_IntrinsicSize(void* ptr, void* doc, int posInDocument, void* format)
{
return ({ QSizeF tmpValue = static_cast<QTextObjectInterface*>(ptr)->intrinsicSize(static_cast<QTextDocument*>(doc), posInDocument, *static_cast<QTextFormat*>(format)); new QSizeF(tmpValue.width(), tmpValue.height()); });
}
void QTextObjectInterface_DrawObject(void* ptr, void* painter, void* rect, void* doc, int posInDocument, void* format)
{
static_cast<QTextObjectInterface*>(ptr)->drawObject(static_cast<QPainter*>(painter), *static_cast<QRectF*>(rect), static_cast<QTextDocument*>(doc), posInDocument, *static_cast<QTextFormat*>(format));
}
void QTextObjectInterface_DestroyQTextObjectInterface(void* ptr)
{
static_cast<QTextObjectInterface*>(ptr)->~QTextObjectInterface();
}
void QTextObjectInterface_DestroyQTextObjectInterfaceDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QTextOption_NewQTextOption()
{
return new QTextOption();
}
void* QTextOption_NewQTextOption2(long long alignment)
{
return new QTextOption(static_cast<Qt::AlignmentFlag>(alignment));
}
void* QTextOption_NewQTextOption3(void* other)
{
return new QTextOption(*static_cast<QTextOption*>(other));
}
void QTextOption_SetAlignment(void* ptr, long long alignment)
{
static_cast<QTextOption*>(ptr)->setAlignment(static_cast<Qt::AlignmentFlag>(alignment));
}
void QTextOption_SetFlags(void* ptr, long long flags)
{
static_cast<QTextOption*>(ptr)->setFlags(static_cast<QTextOption::Flag>(flags));
}
void QTextOption_SetTabArray(void* ptr, void* tabStops)
{
static_cast<QTextOption*>(ptr)->setTabArray(*static_cast<QList<qreal>*>(tabStops));
}
void QTextOption_SetTabStopDistance(void* ptr, double tabStopDistance)
{
static_cast<QTextOption*>(ptr)->setTabStopDistance(tabStopDistance);
}
void QTextOption_SetTextDirection(void* ptr, long long direction)
{
static_cast<QTextOption*>(ptr)->setTextDirection(static_cast<Qt::LayoutDirection>(direction));
}
void QTextOption_SetUseDesignMetrics(void* ptr, char enable)
{
static_cast<QTextOption*>(ptr)->setUseDesignMetrics(enable != 0);
}
void QTextOption_SetWrapMode(void* ptr, long long mode)
{
static_cast<QTextOption*>(ptr)->setWrapMode(static_cast<QTextOption::WrapMode>(mode));
}
void QTextOption_DestroyQTextOption(void* ptr)
{
static_cast<QTextOption*>(ptr)->~QTextOption();
}
struct QtGui_PackedList QTextOption_TabArray(void* ptr)
{
return ({ QList<qreal>* tmpValue = new QList<qreal>(static_cast<QTextOption*>(ptr)->tabArray()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
long long QTextOption_Flags(void* ptr)
{
return static_cast<QTextOption*>(ptr)->flags();
}
long long QTextOption_WrapMode(void* ptr)
{
return static_cast<QTextOption*>(ptr)->wrapMode();
}
long long QTextOption_Alignment(void* ptr)
{
return static_cast<QTextOption*>(ptr)->alignment();
}
long long QTextOption_TextDirection(void* ptr)
{
return static_cast<QTextOption*>(ptr)->textDirection();
}
char QTextOption_UseDesignMetrics(void* ptr)
{
return static_cast<QTextOption*>(ptr)->useDesignMetrics();
}
double QTextOption_TabStopDistance(void* ptr)
{
return static_cast<QTextOption*>(ptr)->tabStopDistance();
}
double QTextOption___setTabArray_tabStops_atList(void* ptr, int i)
{
return ({qreal tmp = static_cast<QList<qreal>*>(ptr)->at(i); if (i == static_cast<QList<qreal>*>(ptr)->size()-1) { static_cast<QList<qreal>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QTextOption___setTabArray_tabStops_setList(void* ptr, double i)
{
static_cast<QList<qreal>*>(ptr)->append(i);
}
void* QTextOption___setTabArray_tabStops_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<qreal>();
}
double QTextOption___tabArray_atList(void* ptr, int i)
{
return ({qreal tmp = static_cast<QList<qreal>*>(ptr)->at(i); if (i == static_cast<QList<qreal>*>(ptr)->size()-1) { static_cast<QList<qreal>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QTextOption___tabArray_setList(void* ptr, double i)
{
static_cast<QList<qreal>*>(ptr)->append(i);
}
void* QTextOption___tabArray_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<qreal>();
}
class MyQTextTable: public QTextTable
{
public:
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTextObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQTextObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQTextObject_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQTextObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQTextObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQTextObject_CustomEvent(this, event); };
void deleteLater() { callbackQTextObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQTextObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQTextObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQTextObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQTextObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQTextTable*)
int QTextTable_QTextTable_QRegisterMetaType(){qRegisterMetaType<QTextTable*>(); return qRegisterMetaType<MyQTextTable*>();}
void QTextTable_AppendColumns(void* ptr, int count)
{
static_cast<QTextTable*>(ptr)->appendColumns(count);
}
void QTextTable_AppendRows(void* ptr, int count)
{
static_cast<QTextTable*>(ptr)->appendRows(count);
}
void QTextTable_InsertColumns(void* ptr, int index, int columns)
{
static_cast<QTextTable*>(ptr)->insertColumns(index, columns);
}
void QTextTable_InsertRows(void* ptr, int index, int rows)
{
static_cast<QTextTable*>(ptr)->insertRows(index, rows);
}
void QTextTable_MergeCells2(void* ptr, void* cursor)
{
static_cast<QTextTable*>(ptr)->mergeCells(*static_cast<QTextCursor*>(cursor));
}
void QTextTable_MergeCells(void* ptr, int row, int column, int numRows, int numCols)
{
static_cast<QTextTable*>(ptr)->mergeCells(row, column, numRows, numCols);
}
void QTextTable_RemoveColumns(void* ptr, int index, int columns)
{
static_cast<QTextTable*>(ptr)->removeColumns(index, columns);
}
void QTextTable_RemoveRows(void* ptr, int index, int rows)
{
static_cast<QTextTable*>(ptr)->removeRows(index, rows);
}
void QTextTable_Resize(void* ptr, int rows, int columns)
{
static_cast<QTextTable*>(ptr)->resize(rows, columns);
}
void QTextTable_SetFormat(void* ptr, void* format)
{
static_cast<QTextTable*>(ptr)->setFormat(*static_cast<QTextTableFormat*>(format));
}
void QTextTable_SplitCell(void* ptr, int row, int column, int numRows, int numCols)
{
static_cast<QTextTable*>(ptr)->splitCell(row, column, numRows, numCols);
}
void* QTextTable_RowEnd(void* ptr, void* cursor)
{
return new QTextCursor(static_cast<QTextTable*>(ptr)->rowEnd(*static_cast<QTextCursor*>(cursor)));
}
void* QTextTable_RowStart(void* ptr, void* cursor)
{
return new QTextCursor(static_cast<QTextTable*>(ptr)->rowStart(*static_cast<QTextCursor*>(cursor)));
}
void* QTextTable_CellAt3(void* ptr, void* cursor)
{
return new QTextTableCell(static_cast<QTextTable*>(ptr)->cellAt(*static_cast<QTextCursor*>(cursor)));
}
void* QTextTable_CellAt2(void* ptr, int position)
{
return new QTextTableCell(static_cast<QTextTable*>(ptr)->cellAt(position));
}
void* QTextTable_CellAt(void* ptr, int row, int column)
{
return new QTextTableCell(static_cast<QTextTable*>(ptr)->cellAt(row, column));
}
void* QTextTable_Format(void* ptr)
{
return new QTextTableFormat(static_cast<QTextTable*>(ptr)->format());
}
int QTextTable_Columns(void* ptr)
{
return static_cast<QTextTable*>(ptr)->columns();
}
int QTextTable_Rows(void* ptr)
{
return static_cast<QTextTable*>(ptr)->rows();
}
void* QTextTableCell_NewQTextTableCell()
{
return new QTextTableCell();
}
void* QTextTableCell_NewQTextTableCell2(void* other)
{
return new QTextTableCell(*static_cast<QTextTableCell*>(other));
}
void QTextTableCell_SetFormat(void* ptr, void* format)
{
static_cast<QTextTableCell*>(ptr)->setFormat(*static_cast<QTextCharFormat*>(format));
}
void QTextTableCell_DestroyQTextTableCell(void* ptr)
{
static_cast<QTextTableCell*>(ptr)->~QTextTableCell();
}
void* QTextTableCell_Format(void* ptr)
{
return new QTextCharFormat(static_cast<QTextTableCell*>(ptr)->format());
}
void* QTextTableCell_FirstCursorPosition(void* ptr)
{
return new QTextCursor(static_cast<QTextTableCell*>(ptr)->firstCursorPosition());
}
void* QTextTableCell_LastCursorPosition(void* ptr)
{
return new QTextCursor(static_cast<QTextTableCell*>(ptr)->lastCursorPosition());
}
char QTextTableCell_IsValid(void* ptr)
{
return static_cast<QTextTableCell*>(ptr)->isValid();
}
int QTextTableCell_Column(void* ptr)
{
return static_cast<QTextTableCell*>(ptr)->column();
}
int QTextTableCell_ColumnSpan(void* ptr)
{
return static_cast<QTextTableCell*>(ptr)->columnSpan();
}
int QTextTableCell_Row(void* ptr)
{
return static_cast<QTextTableCell*>(ptr)->row();
}
int QTextTableCell_RowSpan(void* ptr)
{
return static_cast<QTextTableCell*>(ptr)->rowSpan();
}
int QTextTableCell_TableCellFormatIndex(void* ptr)
{
return static_cast<QTextTableCell*>(ptr)->tableCellFormatIndex();
}
void* QTextTableCellFormat_NewQTextTableCellFormat()
{
return new QTextTableCellFormat();
}
void QTextTableCellFormat_SetBottomPadding(void* ptr, double padding)
{
static_cast<QTextTableCellFormat*>(ptr)->setBottomPadding(padding);
}
void QTextTableCellFormat_SetLeftPadding(void* ptr, double padding)
{
static_cast<QTextTableCellFormat*>(ptr)->setLeftPadding(padding);
}
void QTextTableCellFormat_SetPadding(void* ptr, double padding)
{
static_cast<QTextTableCellFormat*>(ptr)->setPadding(padding);
}
void QTextTableCellFormat_SetRightPadding(void* ptr, double padding)
{
static_cast<QTextTableCellFormat*>(ptr)->setRightPadding(padding);
}
void QTextTableCellFormat_SetTopPadding(void* ptr, double padding)
{
static_cast<QTextTableCellFormat*>(ptr)->setTopPadding(padding);
}
double QTextTableCellFormat_BottomPadding(void* ptr)
{
return static_cast<QTextTableCellFormat*>(ptr)->bottomPadding();
}
double QTextTableCellFormat_LeftPadding(void* ptr)
{
return static_cast<QTextTableCellFormat*>(ptr)->leftPadding();
}
double QTextTableCellFormat_RightPadding(void* ptr)
{
return static_cast<QTextTableCellFormat*>(ptr)->rightPadding();
}
double QTextTableCellFormat_TopPadding(void* ptr)
{
return static_cast<QTextTableCellFormat*>(ptr)->topPadding();
}
void* QTextTableFormat_NewQTextTableFormat()
{
return new QTextTableFormat();
}
void QTextTableFormat_ClearColumnWidthConstraints(void* ptr)
{
static_cast<QTextTableFormat*>(ptr)->clearColumnWidthConstraints();
}
void QTextTableFormat_SetAlignment(void* ptr, long long alignment)
{
static_cast<QTextTableFormat*>(ptr)->setAlignment(static_cast<Qt::AlignmentFlag>(alignment));
}
void QTextTableFormat_SetCellPadding(void* ptr, double padding)
{
static_cast<QTextTableFormat*>(ptr)->setCellPadding(padding);
}
void QTextTableFormat_SetCellSpacing(void* ptr, double spacing)
{
static_cast<QTextTableFormat*>(ptr)->setCellSpacing(spacing);
}
void QTextTableFormat_SetColumnWidthConstraints(void* ptr, void* constraints)
{
static_cast<QTextTableFormat*>(ptr)->setColumnWidthConstraints(*static_cast<QVector<QTextLength>*>(constraints));
}
void QTextTableFormat_SetHeaderRowCount(void* ptr, int count)
{
static_cast<QTextTableFormat*>(ptr)->setHeaderRowCount(count);
}
long long QTextTableFormat_Alignment(void* ptr)
{
return static_cast<QTextTableFormat*>(ptr)->alignment();
}
int QTextTableFormat_Columns(void* ptr)
{
return static_cast<QTextTableFormat*>(ptr)->columns();
}
int QTextTableFormat_HeaderRowCount(void* ptr)
{
return static_cast<QTextTableFormat*>(ptr)->headerRowCount();
}
double QTextTableFormat_CellPadding(void* ptr)
{
return static_cast<QTextTableFormat*>(ptr)->cellPadding();
}
double QTextTableFormat_CellSpacing(void* ptr)
{
return static_cast<QTextTableFormat*>(ptr)->cellSpacing();
}
void* QTextTableFormat___setColumnWidthConstraints_constraints_atList(void* ptr, int i)
{
return new QTextLength(({QTextLength tmp = static_cast<QVector<QTextLength>*>(ptr)->at(i); if (i == static_cast<QVector<QTextLength>*>(ptr)->size()-1) { static_cast<QVector<QTextLength>*>(ptr)->~QVector(); free(ptr); }; tmp; }));
}
void QTextTableFormat___setColumnWidthConstraints_constraints_setList(void* ptr, void* i)
{
static_cast<QVector<QTextLength>*>(ptr)->append(*static_cast<QTextLength*>(i));
}
void* QTextTableFormat___setColumnWidthConstraints_constraints_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QTextLength>();
}
void* QTextTableFormat___columnWidthConstraints_atList(void* ptr, int i)
{
return new QTextLength(({QTextLength tmp = static_cast<QVector<QTextLength>*>(ptr)->at(i); if (i == static_cast<QVector<QTextLength>*>(ptr)->size()-1) { static_cast<QVector<QTextLength>*>(ptr)->~QVector(); free(ptr); }; tmp; }));
}
void QTextTableFormat___columnWidthConstraints_setList(void* ptr, void* i)
{
static_cast<QVector<QTextLength>*>(ptr)->append(*static_cast<QTextLength*>(i));
}
void* QTextTableFormat___columnWidthConstraints_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QTextLength>();
}
struct QtGui_PackedList QTouchDevice_QTouchDevice_Devices()
{
return ({ QList<const QTouchDevice *>* tmpValue = new QList<const QTouchDevice *>(QTouchDevice::devices()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
void* QTouchDevice_NewQTouchDevice()
{
return new QTouchDevice();
}
void QTouchDevice_SetCapabilities(void* ptr, long long caps)
{
static_cast<QTouchDevice*>(ptr)->setCapabilities(static_cast<QTouchDevice::CapabilityFlag>(caps));
}
void QTouchDevice_SetMaximumTouchPoints(void* ptr, int max)
{
static_cast<QTouchDevice*>(ptr)->setMaximumTouchPoints(max);
}
void QTouchDevice_SetName(void* ptr, struct QtGui_PackedString name)
{
static_cast<QTouchDevice*>(ptr)->setName(QString::fromUtf8(name.data, name.len));
}
void QTouchDevice_SetType(void* ptr, long long devType)
{
static_cast<QTouchDevice*>(ptr)->setType(static_cast<QTouchDevice::DeviceType>(devType));
}
void QTouchDevice_DestroyQTouchDevice(void* ptr)
{
static_cast<QTouchDevice*>(ptr)->~QTouchDevice();
}
struct QtGui_PackedString QTouchDevice_Name(void* ptr)
{
return ({ QByteArray td71303 = static_cast<QTouchDevice*>(ptr)->name().toUtf8(); QtGui_PackedString { const_cast<char*>(td71303.prepend("WHITESPACE").constData()+10), td71303.size()-10 }; });
}
long long QTouchDevice_Capabilities(void* ptr)
{
return static_cast<QTouchDevice*>(ptr)->capabilities();
}
long long QTouchDevice_Type(void* ptr)
{
return static_cast<QTouchDevice*>(ptr)->type();
}
int QTouchDevice_MaximumTouchPoints(void* ptr)
{
return static_cast<QTouchDevice*>(ptr)->maximumTouchPoints();
}
void* QTouchDevice___devices_atList(void* ptr, int i)
{
return const_cast<QTouchDevice*>(({const QTouchDevice * tmp = static_cast<QList<QTouchDevice *>*>(ptr)->at(i); if (i == static_cast<QList<QTouchDevice *>*>(ptr)->size()-1) { static_cast<QList<QTouchDevice *>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QTouchDevice___devices_setList(void* ptr, void* i)
{
static_cast<QList<QTouchDevice *>*>(ptr)->append(static_cast<QTouchDevice*>(i));
}
void* QTouchDevice___devices_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<const QTouchDevice *>();
}
class MyQTouchEvent: public QTouchEvent
{
public:
~MyQTouchEvent() { callbackQTouchEvent_DestroyQTouchEvent(this); };
};
void QTouchEvent_DestroyQTouchEvent(void* ptr)
{
static_cast<QTouchEvent*>(ptr)->~QTouchEvent();
}
void QTouchEvent_DestroyQTouchEventDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QTouchEvent_Target(void* ptr)
{
return static_cast<QTouchEvent*>(ptr)->target();
}
void* QTouchEvent_Device(void* ptr)
{
return static_cast<QTouchEvent*>(ptr)->device();
}
void* QTouchEvent_Window(void* ptr)
{
return static_cast<QTouchEvent*>(ptr)->window();
}
long long QTouchEvent_TouchPointStates(void* ptr)
{
return static_cast<QTouchEvent*>(ptr)->touchPointStates();
}
void* QTouchEvent__device(void* ptr)
{
return static_cast<QTouchEvent*>(ptr)->_device;
}
void QTouchEvent_Set_device(void* ptr, void* vqt)
{
static_cast<QTouchEvent*>(ptr)->_device = static_cast<QTouchDevice*>(vqt);
}
void* QTouchEvent__target(void* ptr)
{
return static_cast<QTouchEvent*>(ptr)->_target;
}
void QTouchEvent_Set_target(void* ptr, void* vqo)
{
static_cast<QTouchEvent*>(ptr)->_target = static_cast<QObject*>(vqo);
}
long long QTouchEvent__touchPointStates(void* ptr)
{
return static_cast<QTouchEvent*>(ptr)->_touchPointStates;
}
void QTouchEvent_Set_touchPointStates(void* ptr, long long vqt)
{
static_cast<QTouchEvent*>(ptr)->_touchPointStates = static_cast<Qt::TouchPointState>(vqt);
}
void* QTouchEvent__window(void* ptr)
{
return static_cast<QTouchEvent*>(ptr)->_window;
}
void QTouchEvent_Set_window(void* ptr, void* vqw)
{
static_cast<QTouchEvent*>(ptr)->_window = static_cast<QWindow*>(vqw);
}
void* QTouchEvent___QTouchEvent_touchPoints_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QTouchEvent::TouchPoint>();
}
void* QTouchEvent___setTouchPoints_touchPoints_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QTouchEvent::TouchPoint>();
}
void* QTouchEvent___touchPoints_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QTouchEvent::TouchPoint>();
}
void* QTouchEvent____touchPoints_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QTouchEvent::TouchPoint>();
}
void* QTouchEvent___set_touchPoints__newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QTouchEvent::TouchPoint>();
}
void* QTransform_Rotate(void* ptr, double angle, long long axis)
{
return new QTransform(static_cast<QTransform*>(ptr)->rotate(angle, static_cast<Qt::Axis>(axis)));
}
void* QTransform_RotateRadians(void* ptr, double angle, long long axis)
{
return new QTransform(static_cast<QTransform*>(ptr)->rotateRadians(angle, static_cast<Qt::Axis>(axis)));
}
void* QTransform_Scale(void* ptr, double sx, double sy)
{
return new QTransform(static_cast<QTransform*>(ptr)->scale(sx, sy));
}
void* QTransform_Shear(void* ptr, double sh, double sv)
{
return new QTransform(static_cast<QTransform*>(ptr)->shear(sh, sv));
}
void* QTransform_Translate(void* ptr, double dx, double dy)
{
return new QTransform(static_cast<QTransform*>(ptr)->translate(dx, dy));
}
void* QTransform_QTransform_FromScale(double sx, double sy)
{
return new QTransform(QTransform::fromScale(sx, sy));
}
void* QTransform_QTransform_FromTranslate(double dx, double dy)
{
return new QTransform(QTransform::fromTranslate(dx, dy));
}
void* QTransform_NewQTransform()
{
return new QTransform();
}
void* QTransform_NewQTransform6(void* other)
{
return new QTransform(*static_cast<QTransform*>(other));
}
void* QTransform_NewQTransform5(void* matrix)
{
return new QTransform(*static_cast<QMatrix*>(matrix));
}
void* QTransform_NewQTransform7(void* other)
{
return new QTransform(*static_cast<QTransform*>(other));
}
void* QTransform_NewQTransform3(double m11, double m12, double m13, double m21, double m22, double m23, double m31, double m32, double m33)
{
return new QTransform(m11, m12, m13, m21, m22, m23, m31, m32, m33);
}
void* QTransform_NewQTransform4(double m11, double m12, double m21, double m22, double dx, double dy)
{
return new QTransform(m11, m12, m21, m22, dx, dy);
}
char QTransform_QTransform_QuadToQuad(void* one, void* two, void* trans)
{
return QTransform::quadToQuad(*static_cast<QPolygonF*>(one), *static_cast<QPolygonF*>(two), *static_cast<QTransform*>(trans));
}
char QTransform_QTransform_QuadToSquare(void* quad, void* trans)
{
return QTransform::quadToSquare(*static_cast<QPolygonF*>(quad), *static_cast<QTransform*>(trans));
}
char QTransform_QTransform_SquareToQuad(void* quad, void* trans)
{
return QTransform::squareToQuad(*static_cast<QPolygonF*>(quad), *static_cast<QTransform*>(trans));
}
void QTransform_Reset(void* ptr)
{
static_cast<QTransform*>(ptr)->reset();
}
void QTransform_SetMatrix(void* ptr, double m11, double m12, double m13, double m21, double m22, double m23, double m31, double m32, double m33)
{
static_cast<QTransform*>(ptr)->setMatrix(m11, m12, m13, m21, m22, m23, m31, m32, m33);
}
void* QTransform_Map3(void* ptr, void* l)
{
return ({ QLine tmpValue = static_cast<QTransform*>(ptr)->map(*static_cast<QLine*>(l)); new QLine(tmpValue.p1(), tmpValue.p2()); });
}
void* QTransform_Map4(void* ptr, void* line)
{
return ({ QLineF tmpValue = static_cast<QTransform*>(ptr)->map(*static_cast<QLineF*>(line)); new QLineF(tmpValue.p1(), tmpValue.p2()); });
}
void* QTransform_Map8(void* ptr, void* path)
{
return new QPainterPath(static_cast<QTransform*>(ptr)->map(*static_cast<QPainterPath*>(path)));
}
void* QTransform_Map10(void* ptr, void* point)
{
return ({ QPoint tmpValue = static_cast<QTransform*>(ptr)->map(*static_cast<QPoint*>(point)); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QTransform_Map2(void* ptr, void* p)
{
return ({ QPointF tmpValue = static_cast<QTransform*>(ptr)->map(*static_cast<QPointF*>(p)); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void* QTransform_Map6(void* ptr, void* polygon)
{
return new QPolygon(static_cast<QTransform*>(ptr)->map(*static_cast<QPolygon*>(polygon)));
}
void* QTransform_MapToPolygon(void* ptr, void* rectangle)
{
return new QPolygon(static_cast<QTransform*>(ptr)->mapToPolygon(*static_cast<QRect*>(rectangle)));
}
void* QTransform_Map5(void* ptr, void* polygon)
{
return new QPolygonF(static_cast<QTransform*>(ptr)->map(*static_cast<QPolygonF*>(polygon)));
}
void* QTransform_MapRect2(void* ptr, void* rectangle)
{
return ({ QRect tmpValue = static_cast<QTransform*>(ptr)->mapRect(*static_cast<QRect*>(rectangle)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QTransform_MapRect(void* ptr, void* rectangle)
{
return ({ QRectF tmpValue = static_cast<QTransform*>(ptr)->mapRect(*static_cast<QRectF*>(rectangle)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QTransform_Map7(void* ptr, void* region)
{
return new QRegion(static_cast<QTransform*>(ptr)->map(*static_cast<QRegion*>(region)));
}
void* QTransform_Adjoint(void* ptr)
{
return new QTransform(static_cast<QTransform*>(ptr)->adjoint());
}
void* QTransform_Inverted(void* ptr, char invertible)
{
Q_UNUSED(invertible);
return new QTransform(static_cast<QTransform*>(ptr)->inverted(NULL));
}
void* QTransform_Transposed(void* ptr)
{
return new QTransform(static_cast<QTransform*>(ptr)->transposed());
}
long long QTransform_Type(void* ptr)
{
return static_cast<QTransform*>(ptr)->type();
}
char QTransform_IsAffine(void* ptr)
{
return static_cast<QTransform*>(ptr)->isAffine();
}
char QTransform_IsIdentity(void* ptr)
{
return static_cast<QTransform*>(ptr)->isIdentity();
}
char QTransform_IsInvertible(void* ptr)
{
return static_cast<QTransform*>(ptr)->isInvertible();
}
char QTransform_IsRotating(void* ptr)
{
return static_cast<QTransform*>(ptr)->isRotating();
}
char QTransform_IsScaling(void* ptr)
{
return static_cast<QTransform*>(ptr)->isScaling();
}
char QTransform_IsTranslating(void* ptr)
{
return static_cast<QTransform*>(ptr)->isTranslating();
}
void* QTransform_ToAffine(void* ptr)
{
return const_cast<QMatrix*>(&static_cast<QTransform*>(ptr)->toAffine());
}
double QTransform_Determinant(void* ptr)
{
return static_cast<QTransform*>(ptr)->determinant();
}
double QTransform_Dx(void* ptr)
{
return static_cast<QTransform*>(ptr)->dx();
}
double QTransform_Dy(void* ptr)
{
return static_cast<QTransform*>(ptr)->dy();
}
double QTransform_M11(void* ptr)
{
return static_cast<QTransform*>(ptr)->m11();
}
double QTransform_M12(void* ptr)
{
return static_cast<QTransform*>(ptr)->m12();
}
double QTransform_M13(void* ptr)
{
return static_cast<QTransform*>(ptr)->m13();
}
double QTransform_M21(void* ptr)
{
return static_cast<QTransform*>(ptr)->m21();
}
double QTransform_M22(void* ptr)
{
return static_cast<QTransform*>(ptr)->m22();
}
double QTransform_M23(void* ptr)
{
return static_cast<QTransform*>(ptr)->m23();
}
double QTransform_M31(void* ptr)
{
return static_cast<QTransform*>(ptr)->m31();
}
double QTransform_M32(void* ptr)
{
return static_cast<QTransform*>(ptr)->m32();
}
double QTransform_M33(void* ptr)
{
return static_cast<QTransform*>(ptr)->m33();
}
void QTransform_Map9(void* ptr, int x, int y, int tx, int ty)
{
static_cast<QTransform*>(ptr)->map(x, y, &tx, &ty);
}
void QTransform_Map(void* ptr, double x, double y, double tx, double ty)
{
static_cast<QTransform*>(ptr)->map(x, y, &tx, &ty);
}
class MyQValidator: public QValidator
{
public:
MyQValidator(QObject *parent = Q_NULLPTR) : QValidator(parent) {QValidator_QValidator_QRegisterMetaType();};
void Signal_Changed() { callbackQValidator_Changed(this); };
~MyQValidator() { callbackQValidator_DestroyQValidator(this); };
QValidator::State validate(QString & input, int & pos) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };return static_cast<QValidator::State>(callbackQValidator_Validate(const_cast<void*>(static_cast<const void*>(this)), inputPacked, pos)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQValidator_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void fixup(QString & input) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };callbackQValidator_Fixup(const_cast<void*>(static_cast<const void*>(this)), inputPacked); };
bool event(QEvent * e) { return callbackQValidator_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQValidator_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQValidator_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQValidator_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQValidator_CustomEvent(this, event); };
void deleteLater() { callbackQValidator_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQValidator_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQValidator_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQValidator_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQValidator_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQValidator*)
int QValidator_QValidator_QRegisterMetaType(){qRegisterMetaType<QValidator*>(); return qRegisterMetaType<MyQValidator*>();}
struct QtGui_PackedString QValidator_QValidator_Tr(char* s, char* c, int n)
{
return ({ QByteArray tb7ce9e = QValidator::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(tb7ce9e.prepend("WHITESPACE").constData()+10), tb7ce9e.size()-10 }; });
}
struct QtGui_PackedString QValidator_QValidator_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray t11aa72 = QValidator::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t11aa72.prepend("WHITESPACE").constData()+10), t11aa72.size()-10 }; });
}
void* QValidator_NewQValidator(void* parent)
{
if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQValidator(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQValidator(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQValidator(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQValidator(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQValidator(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQValidator(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQValidator(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQValidator(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQValidator(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQValidator(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQValidator(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQValidator(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQValidator(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQValidator(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQValidator(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQValidator(static_cast<QWindow*>(parent));
} else {
return new MyQValidator(static_cast<QObject*>(parent));
}
}
void QValidator_ConnectChanged(void* ptr)
{
QObject::connect(static_cast<QValidator*>(ptr), static_cast<void (QValidator::*)()>(&QValidator::changed), static_cast<MyQValidator*>(ptr), static_cast<void (MyQValidator::*)()>(&MyQValidator::Signal_Changed));
}
void QValidator_DisconnectChanged(void* ptr)
{
QObject::disconnect(static_cast<QValidator*>(ptr), static_cast<void (QValidator::*)()>(&QValidator::changed), static_cast<MyQValidator*>(ptr), static_cast<void (MyQValidator::*)()>(&MyQValidator::Signal_Changed));
}
void QValidator_Changed(void* ptr)
{
static_cast<QValidator*>(ptr)->changed();
}
void QValidator_SetLocale(void* ptr, void* locale)
{
static_cast<QValidator*>(ptr)->setLocale(*static_cast<QLocale*>(locale));
}
void QValidator_DestroyQValidator(void* ptr)
{
static_cast<QValidator*>(ptr)->~QValidator();
}
void QValidator_DestroyQValidatorDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QValidator_Locale(void* ptr)
{
return new QLocale(static_cast<QValidator*>(ptr)->locale());
}
long long QValidator_Validate(void* ptr, struct QtGui_PackedString input, int pos)
{
return static_cast<QValidator*>(ptr)->validate(*(new QString(QString::fromUtf8(input.data, input.len))), pos);
}
void* QValidator_MetaObjectDefault(void* ptr)
{
if (dynamic_cast<QRegularExpressionValidator*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::metaObject());
} else if (dynamic_cast<QRegExpValidator*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::metaObject());
} else if (dynamic_cast<QIntValidator*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QIntValidator*>(ptr)->QIntValidator::metaObject());
} else if (dynamic_cast<QDoubleValidator*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::metaObject());
} else {
return const_cast<QMetaObject*>(static_cast<QValidator*>(ptr)->QValidator::metaObject());
}
}
void QValidator_Fixup(void* ptr, struct QtGui_PackedString input)
{
static_cast<QValidator*>(ptr)->fixup(*(new QString(QString::fromUtf8(input.data, input.len))));
}
void QValidator_FixupDefault(void* ptr, struct QtGui_PackedString input)
{
if (dynamic_cast<QRegularExpressionValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::fixup(*(new QString(QString::fromUtf8(input.data, input.len))));
} else if (dynamic_cast<QRegExpValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::fixup(*(new QString(QString::fromUtf8(input.data, input.len))));
} else if (dynamic_cast<QIntValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QIntValidator*>(ptr)->QIntValidator::fixup(*(new QString(QString::fromUtf8(input.data, input.len))));
} else if (dynamic_cast<QDoubleValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::fixup(*(new QString(QString::fromUtf8(input.data, input.len))));
} else {
static_cast<QValidator*>(ptr)->QValidator::fixup(*(new QString(QString::fromUtf8(input.data, input.len))));
}
}
void* QValidator___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QValidator___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QValidator___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QValidator___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QValidator___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QValidator___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QValidator___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QValidator___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QValidator___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QValidator___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QValidator___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QValidator___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QValidator___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QValidator___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
void* QValidator___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
char QValidator_EventDefault(void* ptr, void* e)
{
if (dynamic_cast<QRegularExpressionValidator*>(static_cast<QObject*>(ptr))) {
return static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QRegExpValidator*>(static_cast<QObject*>(ptr))) {
return static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QIntValidator*>(static_cast<QObject*>(ptr))) {
return static_cast<QIntValidator*>(ptr)->QIntValidator::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QDoubleValidator*>(static_cast<QObject*>(ptr))) {
return static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::event(static_cast<QEvent*>(e));
} else {
return static_cast<QValidator*>(ptr)->QValidator::event(static_cast<QEvent*>(e));
}
}
char QValidator_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QRegularExpressionValidator*>(static_cast<QObject*>(ptr))) {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
} else if (dynamic_cast<QRegExpValidator*>(static_cast<QObject*>(ptr))) {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
} else if (dynamic_cast<QIntValidator*>(static_cast<QObject*>(ptr))) {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QIntValidator*>(ptr)->QIntValidator::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QIntValidator*>(ptr)->QIntValidator::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QIntValidator*>(ptr)->QIntValidator::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QIntValidator*>(ptr)->QIntValidator::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QIntValidator*>(ptr)->QIntValidator::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
} else if (dynamic_cast<QDoubleValidator*>(static_cast<QObject*>(ptr))) {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
} else {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QValidator*>(ptr)->QValidator::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QValidator*>(ptr)->QValidator::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QValidator*>(ptr)->QValidator::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QValidator*>(ptr)->QValidator::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QValidator*>(ptr)->QValidator::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
}
void QValidator_ChildEventDefault(void* ptr, void* event)
{
if (dynamic_cast<QRegularExpressionValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QRegExpValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QIntValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QIntValidator*>(ptr)->QIntValidator::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QDoubleValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::childEvent(static_cast<QChildEvent*>(event));
} else {
static_cast<QValidator*>(ptr)->QValidator::childEvent(static_cast<QChildEvent*>(event));
}
}
void QValidator_ConnectNotifyDefault(void* ptr, void* sign)
{
if (dynamic_cast<QRegularExpressionValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QRegExpValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QIntValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QIntValidator*>(ptr)->QIntValidator::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QDoubleValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::connectNotify(*static_cast<QMetaMethod*>(sign));
} else {
static_cast<QValidator*>(ptr)->QValidator::connectNotify(*static_cast<QMetaMethod*>(sign));
}
}
void QValidator_CustomEventDefault(void* ptr, void* event)
{
if (dynamic_cast<QRegularExpressionValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QRegExpValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QIntValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QIntValidator*>(ptr)->QIntValidator::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QDoubleValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::customEvent(static_cast<QEvent*>(event));
} else {
static_cast<QValidator*>(ptr)->QValidator::customEvent(static_cast<QEvent*>(event));
}
}
void QValidator_DeleteLaterDefault(void* ptr)
{
if (dynamic_cast<QRegularExpressionValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::deleteLater();
} else if (dynamic_cast<QRegExpValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::deleteLater();
} else if (dynamic_cast<QIntValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QIntValidator*>(ptr)->QIntValidator::deleteLater();
} else if (dynamic_cast<QDoubleValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::deleteLater();
} else {
static_cast<QValidator*>(ptr)->QValidator::deleteLater();
}
}
void QValidator_DisconnectNotifyDefault(void* ptr, void* sign)
{
if (dynamic_cast<QRegularExpressionValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QRegExpValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QIntValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QIntValidator*>(ptr)->QIntValidator::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QDoubleValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else {
static_cast<QValidator*>(ptr)->QValidator::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
}
void QValidator_TimerEventDefault(void* ptr, void* event)
{
if (dynamic_cast<QRegularExpressionValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QRegExpValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QIntValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QIntValidator*>(ptr)->QIntValidator::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QDoubleValidator*>(static_cast<QObject*>(ptr))) {
static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::timerEvent(static_cast<QTimerEvent*>(event));
} else {
static_cast<QValidator*>(ptr)->QValidator::timerEvent(static_cast<QTimerEvent*>(event));
}
}
void* QVector2D_NewQVector2D()
{
return new QVector2D();
}
void* QVector2D_NewQVector2D4(void* point)
{
return new QVector2D(*static_cast<QPoint*>(point));
}
void* QVector2D_NewQVector2D5(void* point)
{
return new QVector2D(*static_cast<QPointF*>(point));
}
void* QVector2D_NewQVector2D6(void* vector)
{
return new QVector2D(*static_cast<QVector3D*>(vector));
}
void* QVector2D_NewQVector2D7(void* vector)
{
return new QVector2D(*static_cast<QVector4D*>(vector));
}
void* QVector2D_NewQVector2D3(float xpos, float ypos)
{
return new QVector2D(xpos, ypos);
}
float QVector2D_QVector2D_DotProduct(void* v1, void* v2)
{
return QVector2D::dotProduct(*static_cast<QVector2D*>(v1), *static_cast<QVector2D*>(v2));
}
void QVector2D_Normalize(void* ptr)
{
static_cast<QVector2D*>(ptr)->normalize();
}
void QVector2D_SetX(void* ptr, float x)
{
static_cast<QVector2D*>(ptr)->setX(x);
}
void QVector2D_SetY(void* ptr, float y)
{
static_cast<QVector2D*>(ptr)->setY(y);
}
void* QVector2D_ToPoint(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QVector2D*>(ptr)->toPoint(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QVector2D_ToPointF(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QVector2D*>(ptr)->toPointF(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void* QVector2D_Normalized(void* ptr)
{
return new QVector2D(static_cast<QVector2D*>(ptr)->normalized());
}
void* QVector2D_ToVector3D(void* ptr)
{
return new QVector3D(static_cast<QVector2D*>(ptr)->toVector3D());
}
void* QVector2D_ToVector4D(void* ptr)
{
return new QVector4D(static_cast<QVector2D*>(ptr)->toVector4D());
}
char QVector2D_IsNull(void* ptr)
{
return static_cast<QVector2D*>(ptr)->isNull();
}
float QVector2D_DistanceToLine(void* ptr, void* point, void* direction)
{
return static_cast<QVector2D*>(ptr)->distanceToLine(*static_cast<QVector2D*>(point), *static_cast<QVector2D*>(direction));
}
float QVector2D_DistanceToPoint(void* ptr, void* point)
{
return static_cast<QVector2D*>(ptr)->distanceToPoint(*static_cast<QVector2D*>(point));
}
float QVector2D_Length(void* ptr)
{
return static_cast<QVector2D*>(ptr)->length();
}
float QVector2D_LengthSquared(void* ptr)
{
return static_cast<QVector2D*>(ptr)->lengthSquared();
}
float QVector2D_X(void* ptr)
{
return static_cast<QVector2D*>(ptr)->x();
}
float QVector2D_Y(void* ptr)
{
return static_cast<QVector2D*>(ptr)->y();
}
void* QVector3D_QVector3D_CrossProduct(void* v1, void* v2)
{
return new QVector3D(QVector3D::crossProduct(*static_cast<QVector3D*>(v1), *static_cast<QVector3D*>(v2)));
}
void* QVector3D_QVector3D_Normal(void* v1, void* v2)
{
return new QVector3D(QVector3D::normal(*static_cast<QVector3D*>(v1), *static_cast<QVector3D*>(v2)));
}
void* QVector3D_QVector3D_Normal2(void* v1, void* v2, void* v3)
{
return new QVector3D(QVector3D::normal(*static_cast<QVector3D*>(v1), *static_cast<QVector3D*>(v2), *static_cast<QVector3D*>(v3)));
}
void* QVector3D_NewQVector3D()
{
return new QVector3D();
}
void* QVector3D_NewQVector3D4(void* point)
{
return new QVector3D(*static_cast<QPoint*>(point));
}
void* QVector3D_NewQVector3D5(void* point)
{
return new QVector3D(*static_cast<QPointF*>(point));
}
void* QVector3D_NewQVector3D6(void* vector)
{
return new QVector3D(*static_cast<QVector2D*>(vector));
}
void* QVector3D_NewQVector3D7(void* vector, float zpos)
{
return new QVector3D(*static_cast<QVector2D*>(vector), zpos);
}
void* QVector3D_NewQVector3D8(void* vector)
{
return new QVector3D(*static_cast<QVector4D*>(vector));
}
void* QVector3D_NewQVector3D3(float xpos, float ypos, float zpos)
{
return new QVector3D(xpos, ypos, zpos);
}
float QVector3D_QVector3D_DotProduct(void* v1, void* v2)
{
return QVector3D::dotProduct(*static_cast<QVector3D*>(v1), *static_cast<QVector3D*>(v2));
}
void QVector3D_Normalize(void* ptr)
{
static_cast<QVector3D*>(ptr)->normalize();
}
void QVector3D_SetX(void* ptr, float x)
{
static_cast<QVector3D*>(ptr)->setX(x);
}
void QVector3D_SetY(void* ptr, float y)
{
static_cast<QVector3D*>(ptr)->setY(y);
}
void QVector3D_SetZ(void* ptr, float z)
{
static_cast<QVector3D*>(ptr)->setZ(z);
}
void* QVector3D_ToPoint(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QVector3D*>(ptr)->toPoint(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QVector3D_ToPointF(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QVector3D*>(ptr)->toPointF(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void* QVector3D_ToVector2D(void* ptr)
{
return new QVector2D(static_cast<QVector3D*>(ptr)->toVector2D());
}
void* QVector3D_Normalized(void* ptr)
{
return new QVector3D(static_cast<QVector3D*>(ptr)->normalized());
}
void* QVector3D_Project(void* ptr, void* modelView, void* projection, void* viewport)
{
return new QVector3D(static_cast<QVector3D*>(ptr)->project(*static_cast<QMatrix4x4*>(modelView), *static_cast<QMatrix4x4*>(projection), *static_cast<QRect*>(viewport)));
}
void* QVector3D_Unproject(void* ptr, void* modelView, void* projection, void* viewport)
{
return new QVector3D(static_cast<QVector3D*>(ptr)->unproject(*static_cast<QMatrix4x4*>(modelView), *static_cast<QMatrix4x4*>(projection), *static_cast<QRect*>(viewport)));
}
void* QVector3D_ToVector4D(void* ptr)
{
return new QVector4D(static_cast<QVector3D*>(ptr)->toVector4D());
}
char QVector3D_IsNull(void* ptr)
{
return static_cast<QVector3D*>(ptr)->isNull();
}
float QVector3D_DistanceToLine(void* ptr, void* point, void* direction)
{
return static_cast<QVector3D*>(ptr)->distanceToLine(*static_cast<QVector3D*>(point), *static_cast<QVector3D*>(direction));
}
float QVector3D_DistanceToPlane(void* ptr, void* plane, void* normal)
{
return static_cast<QVector3D*>(ptr)->distanceToPlane(*static_cast<QVector3D*>(plane), *static_cast<QVector3D*>(normal));
}
float QVector3D_DistanceToPlane2(void* ptr, void* plane1, void* plane2, void* plane3)
{
return static_cast<QVector3D*>(ptr)->distanceToPlane(*static_cast<QVector3D*>(plane1), *static_cast<QVector3D*>(plane2), *static_cast<QVector3D*>(plane3));
}
float QVector3D_DistanceToPoint(void* ptr, void* point)
{
return static_cast<QVector3D*>(ptr)->distanceToPoint(*static_cast<QVector3D*>(point));
}
float QVector3D_Length(void* ptr)
{
return static_cast<QVector3D*>(ptr)->length();
}
float QVector3D_LengthSquared(void* ptr)
{
return static_cast<QVector3D*>(ptr)->lengthSquared();
}
float QVector3D_X(void* ptr)
{
return static_cast<QVector3D*>(ptr)->x();
}
float QVector3D_Y(void* ptr)
{
return static_cast<QVector3D*>(ptr)->y();
}
float QVector3D_Z(void* ptr)
{
return static_cast<QVector3D*>(ptr)->z();
}
void* QVector4D_NewQVector4D()
{
return new QVector4D();
}
void* QVector4D_NewQVector4D4(void* point)
{
return new QVector4D(*static_cast<QPoint*>(point));
}
void* QVector4D_NewQVector4D5(void* point)
{
return new QVector4D(*static_cast<QPointF*>(point));
}
void* QVector4D_NewQVector4D6(void* vector)
{
return new QVector4D(*static_cast<QVector2D*>(vector));
}
void* QVector4D_NewQVector4D7(void* vector, float zpos, float wpos)
{
return new QVector4D(*static_cast<QVector2D*>(vector), zpos, wpos);
}
void* QVector4D_NewQVector4D8(void* vector)
{
return new QVector4D(*static_cast<QVector3D*>(vector));
}
void* QVector4D_NewQVector4D9(void* vector, float wpos)
{
return new QVector4D(*static_cast<QVector3D*>(vector), wpos);
}
void* QVector4D_NewQVector4D3(float xpos, float ypos, float zpos, float wpos)
{
return new QVector4D(xpos, ypos, zpos, wpos);
}
float QVector4D_QVector4D_DotProduct(void* v1, void* v2)
{
return QVector4D::dotProduct(*static_cast<QVector4D*>(v1), *static_cast<QVector4D*>(v2));
}
void QVector4D_Normalize(void* ptr)
{
static_cast<QVector4D*>(ptr)->normalize();
}
void QVector4D_SetW(void* ptr, float w)
{
static_cast<QVector4D*>(ptr)->setW(w);
}
void QVector4D_SetX(void* ptr, float x)
{
static_cast<QVector4D*>(ptr)->setX(x);
}
void QVector4D_SetY(void* ptr, float y)
{
static_cast<QVector4D*>(ptr)->setY(y);
}
void QVector4D_SetZ(void* ptr, float z)
{
static_cast<QVector4D*>(ptr)->setZ(z);
}
void* QVector4D_ToPoint(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QVector4D*>(ptr)->toPoint(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QVector4D_ToPointF(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QVector4D*>(ptr)->toPointF(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void* QVector4D_ToVector2D(void* ptr)
{
return new QVector2D(static_cast<QVector4D*>(ptr)->toVector2D());
}
void* QVector4D_ToVector2DAffine(void* ptr)
{
return new QVector2D(static_cast<QVector4D*>(ptr)->toVector2DAffine());
}
void* QVector4D_ToVector3D(void* ptr)
{
return new QVector3D(static_cast<QVector4D*>(ptr)->toVector3D());
}
void* QVector4D_ToVector3DAffine(void* ptr)
{
return new QVector3D(static_cast<QVector4D*>(ptr)->toVector3DAffine());
}
void* QVector4D_Normalized(void* ptr)
{
return new QVector4D(static_cast<QVector4D*>(ptr)->normalized());
}
char QVector4D_IsNull(void* ptr)
{
return static_cast<QVector4D*>(ptr)->isNull();
}
float QVector4D_Length(void* ptr)
{
return static_cast<QVector4D*>(ptr)->length();
}
float QVector4D_LengthSquared(void* ptr)
{
return static_cast<QVector4D*>(ptr)->lengthSquared();
}
float QVector4D_W(void* ptr)
{
return static_cast<QVector4D*>(ptr)->w();
}
float QVector4D_X(void* ptr)
{
return static_cast<QVector4D*>(ptr)->x();
}
float QVector4D_Y(void* ptr)
{
return static_cast<QVector4D*>(ptr)->y();
}
float QVector4D_Z(void* ptr)
{
return static_cast<QVector4D*>(ptr)->z();
}
class MyQWhatsThisClickedEvent: public QWhatsThisClickedEvent
{
public:
MyQWhatsThisClickedEvent(const QString &href) : QWhatsThisClickedEvent(href) {};
};
void* QWhatsThisClickedEvent_NewQWhatsThisClickedEvent(struct QtGui_PackedString href)
{
return new MyQWhatsThisClickedEvent(QString::fromUtf8(href.data, href.len));
}
struct QtGui_PackedString QWhatsThisClickedEvent_Href(void* ptr)
{
return ({ QByteArray tc87a51 = static_cast<QWhatsThisClickedEvent*>(ptr)->href().toUtf8(); QtGui_PackedString { const_cast<char*>(tc87a51.prepend("WHITESPACE").constData()+10), tc87a51.size()-10 }; });
}
class MyQWheelEvent: public QWheelEvent
{
public:
MyQWheelEvent(const QPointF &pos, const QPointF &globalPos, QPoint pixelDelta, QPoint angleDelta, int qt4Delta, Qt::Orientation qt4Orientation, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers) : QWheelEvent(pos, globalPos, pixelDelta, angleDelta, qt4Delta, qt4Orientation, buttons, modifiers) {};
MyQWheelEvent(const QPointF &pos, const QPointF &globalPos, QPoint pixelDelta, QPoint angleDelta, int qt4Delta, Qt::Orientation qt4Orientation, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Qt::ScrollPhase phase) : QWheelEvent(pos, globalPos, pixelDelta, angleDelta, qt4Delta, qt4Orientation, buttons, modifiers, phase) {};
MyQWheelEvent(const QPointF &pos, const QPointF &globalPos, QPoint pixelDelta, QPoint angleDelta, int qt4Delta, Qt::Orientation qt4Orientation, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Qt::ScrollPhase phase, Qt::MouseEventSource source) : QWheelEvent(pos, globalPos, pixelDelta, angleDelta, qt4Delta, qt4Orientation, buttons, modifiers, phase, source) {};
MyQWheelEvent(const QPointF &pos, const QPointF &globalPos, QPoint pixelDelta, QPoint angleDelta, int qt4Delta, Qt::Orientation qt4Orientation, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Qt::ScrollPhase phase, Qt::MouseEventSource source, bool inverted) : QWheelEvent(pos, globalPos, pixelDelta, angleDelta, qt4Delta, qt4Orientation, buttons, modifiers, phase, source, inverted) {};
};
void* QWheelEvent_NewQWheelEvent(void* pos, void* globalPos, void* pixelDelta, void* angleDelta, int qt4Delta, long long qt4Orientation, long long buttons, long long modifiers)
{
return new MyQWheelEvent(*static_cast<QPointF*>(pos), *static_cast<QPointF*>(globalPos), *static_cast<QPoint*>(pixelDelta), *static_cast<QPoint*>(angleDelta), qt4Delta, static_cast<Qt::Orientation>(qt4Orientation), static_cast<Qt::MouseButton>(buttons), static_cast<Qt::KeyboardModifier>(modifiers));
}
void* QWheelEvent_NewQWheelEvent4(void* pos, void* globalPos, void* pixelDelta, void* angleDelta, int qt4Delta, long long qt4Orientation, long long buttons, long long modifiers, long long phase)
{
return new MyQWheelEvent(*static_cast<QPointF*>(pos), *static_cast<QPointF*>(globalPos), *static_cast<QPoint*>(pixelDelta), *static_cast<QPoint*>(angleDelta), qt4Delta, static_cast<Qt::Orientation>(qt4Orientation), static_cast<Qt::MouseButton>(buttons), static_cast<Qt::KeyboardModifier>(modifiers), static_cast<Qt::ScrollPhase>(phase));
}
void* QWheelEvent_NewQWheelEvent5(void* pos, void* globalPos, void* pixelDelta, void* angleDelta, int qt4Delta, long long qt4Orientation, long long buttons, long long modifiers, long long phase, long long source)
{
return new MyQWheelEvent(*static_cast<QPointF*>(pos), *static_cast<QPointF*>(globalPos), *static_cast<QPoint*>(pixelDelta), *static_cast<QPoint*>(angleDelta), qt4Delta, static_cast<Qt::Orientation>(qt4Orientation), static_cast<Qt::MouseButton>(buttons), static_cast<Qt::KeyboardModifier>(modifiers), static_cast<Qt::ScrollPhase>(phase), static_cast<Qt::MouseEventSource>(source));
}
void* QWheelEvent_NewQWheelEvent6(void* pos, void* globalPos, void* pixelDelta, void* angleDelta, int qt4Delta, long long qt4Orientation, long long buttons, long long modifiers, long long phase, long long source, char inverted)
{
return new MyQWheelEvent(*static_cast<QPointF*>(pos), *static_cast<QPointF*>(globalPos), *static_cast<QPoint*>(pixelDelta), *static_cast<QPoint*>(angleDelta), qt4Delta, static_cast<Qt::Orientation>(qt4Orientation), static_cast<Qt::MouseButton>(buttons), static_cast<Qt::KeyboardModifier>(modifiers), static_cast<Qt::ScrollPhase>(phase), static_cast<Qt::MouseEventSource>(source), inverted != 0);
}
void* QWheelEvent_AngleDelta(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QWheelEvent*>(ptr)->angleDelta(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QWheelEvent_GlobalPos(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QWheelEvent*>(ptr)->globalPos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QWheelEvent_PixelDelta(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QWheelEvent*>(ptr)->pixelDelta(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QWheelEvent_Pos(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QWheelEvent*>(ptr)->pos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
long long QWheelEvent_Buttons(void* ptr)
{
return static_cast<QWheelEvent*>(ptr)->buttons();
}
long long QWheelEvent_Source(void* ptr)
{
return static_cast<QWheelEvent*>(ptr)->source();
}
long long QWheelEvent_Phase(void* ptr)
{
return static_cast<QWheelEvent*>(ptr)->phase();
}
char QWheelEvent_Inverted(void* ptr)
{
return static_cast<QWheelEvent*>(ptr)->inverted();
}
void* QWheelEvent_GlobalPosF(void* ptr)
{
return const_cast<QPointF*>(&static_cast<QWheelEvent*>(ptr)->globalPosF());
}
void* QWheelEvent_PosF(void* ptr)
{
return const_cast<QPointF*>(&static_cast<QWheelEvent*>(ptr)->posF());
}
int QWheelEvent_GlobalX(void* ptr)
{
return static_cast<QWheelEvent*>(ptr)->globalX();
}
int QWheelEvent_GlobalY(void* ptr)
{
return static_cast<QWheelEvent*>(ptr)->globalY();
}
int QWheelEvent_X(void* ptr)
{
return static_cast<QWheelEvent*>(ptr)->x();
}
int QWheelEvent_Y(void* ptr)
{
return static_cast<QWheelEvent*>(ptr)->y();
}
void* QWheelEvent_AngleD(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QWheelEvent*>(ptr)->angleD; new QPoint(tmpValue.x(), tmpValue.y()); });
}
void QWheelEvent_SetAngleD(void* ptr, void* vqp)
{
static_cast<QWheelEvent*>(ptr)->angleD = *static_cast<QPoint*>(vqp);
}
void* QWheelEvent_G(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QWheelEvent*>(ptr)->g; new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QWheelEvent_SetG(void* ptr, void* vqp)
{
static_cast<QWheelEvent*>(ptr)->g = *static_cast<QPointF*>(vqp);
}
char QWheelEvent_InvertedScrolling(void* ptr)
{
return static_cast<QWheelEvent*>(ptr)->invertedScrolling;
}
void QWheelEvent_SetInvertedScrolling(void* ptr, char vbo)
{
static_cast<QWheelEvent*>(ptr)->invertedScrolling = vbo != 0;
}
long long QWheelEvent_MouseState(void* ptr)
{
return static_cast<QWheelEvent*>(ptr)->mouseState;
}
void QWheelEvent_SetMouseState(void* ptr, long long vqt)
{
static_cast<QWheelEvent*>(ptr)->mouseState = static_cast<Qt::MouseButton>(vqt);
}
void* QWheelEvent_P(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QWheelEvent*>(ptr)->p; new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QWheelEvent_SetP(void* ptr, void* vqp)
{
static_cast<QWheelEvent*>(ptr)->p = *static_cast<QPointF*>(vqp);
}
unsigned int QWheelEvent_Ph(void* ptr)
{
return static_cast<QWheelEvent*>(ptr)->ph;
}
void QWheelEvent_SetPh(void* ptr, unsigned int vui)
{
static_cast<QWheelEvent*>(ptr)->ph = vui;
}
void* QWheelEvent_PixelD(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QWheelEvent*>(ptr)->pixelD; new QPoint(tmpValue.x(), tmpValue.y()); });
}
void QWheelEvent_SetPixelD(void* ptr, void* vqp)
{
static_cast<QWheelEvent*>(ptr)->pixelD = *static_cast<QPoint*>(vqp);
}
int QWheelEvent_Qt4D(void* ptr)
{
return static_cast<QWheelEvent*>(ptr)->qt4D;
}
void QWheelEvent_SetQt4D(void* ptr, int vin)
{
static_cast<QWheelEvent*>(ptr)->qt4D = vin;
}
long long QWheelEvent_Qt4O(void* ptr)
{
return static_cast<QWheelEvent*>(ptr)->qt4O;
}
void QWheelEvent_SetQt4O(void* ptr, long long vqt)
{
static_cast<QWheelEvent*>(ptr)->qt4O = static_cast<Qt::Orientation>(vqt);
}
int QWheelEvent_Reserved(void* ptr)
{
return static_cast<QWheelEvent*>(ptr)->reserved;
}
void QWheelEvent_SetReserved(void* ptr, int vin)
{
static_cast<QWheelEvent*>(ptr)->reserved = vin;
}
unsigned int QWheelEvent_Src(void* ptr)
{
return static_cast<QWheelEvent*>(ptr)->src;
}
void QWheelEvent_SetSrc(void* ptr, unsigned int vui)
{
static_cast<QWheelEvent*>(ptr)->src = vui;
}
class MyQWindow: public QWindow
{
public:
MyQWindow(QScreen *targetScreen = Q_NULLPTR) : QWindow(targetScreen) {QWindow_QWindow_QRegisterMetaType();};
MyQWindow(QWindow *parent) : QWindow(parent) {QWindow_QWindow_QRegisterMetaType();};
bool close() { return callbackQWindow_Close(this) != 0; };
bool event(QEvent * ev) { return callbackQWindow_Event(this, ev) != 0; };
void Signal_ActiveChanged() { callbackQWindow_ActiveChanged(this); };
void alert(int msec) { callbackQWindow_Alert(this, msec); };
void Signal_ContentOrientationChanged(Qt::ScreenOrientation orientation) { callbackQWindow_ContentOrientationChanged(this, orientation); };
void exposeEvent(QExposeEvent * ev) { callbackQWindow_ExposeEvent(this, ev); };
void focusInEvent(QFocusEvent * ev) { callbackQWindow_FocusInEvent(this, ev); };
void Signal_FocusObjectChanged(QObject * object) { callbackQWindow_FocusObjectChanged(this, object); };
void focusOutEvent(QFocusEvent * ev) { callbackQWindow_FocusOutEvent(this, ev); };
void Signal_HeightChanged(int arg) { callbackQWindow_HeightChanged(this, arg); };
void hide() { callbackQWindow_Hide(this); };
void hideEvent(QHideEvent * ev) { callbackQWindow_HideEvent(this, ev); };
void keyPressEvent(QKeyEvent * ev) { callbackQWindow_KeyPressEvent(this, ev); };
void keyReleaseEvent(QKeyEvent * ev) { callbackQWindow_KeyReleaseEvent(this, ev); };
void lower() { callbackQWindow_Lower(this); };
void Signal_MaximumHeightChanged(int arg) { callbackQWindow_MaximumHeightChanged(this, arg); };
void Signal_MaximumWidthChanged(int arg) { callbackQWindow_MaximumWidthChanged(this, arg); };
void Signal_MinimumHeightChanged(int arg) { callbackQWindow_MinimumHeightChanged(this, arg); };
void Signal_MinimumWidthChanged(int arg) { callbackQWindow_MinimumWidthChanged(this, arg); };
void Signal_ModalityChanged(Qt::WindowModality modality) { callbackQWindow_ModalityChanged(this, modality); };
void mouseDoubleClickEvent(QMouseEvent * ev) { callbackQWindow_MouseDoubleClickEvent(this, ev); };
void mouseMoveEvent(QMouseEvent * ev) { callbackQWindow_MouseMoveEvent(this, ev); };
void mousePressEvent(QMouseEvent * ev) { callbackQWindow_MousePressEvent(this, ev); };
void mouseReleaseEvent(QMouseEvent * ev) { callbackQWindow_MouseReleaseEvent(this, ev); };
void moveEvent(QMoveEvent * ev) { callbackQWindow_MoveEvent(this, ev); };
void Signal_OpacityChanged(qreal opacity) { callbackQWindow_OpacityChanged(this, opacity); };
void raise() { callbackQWindow_Raise(this); };
void requestActivate() { callbackQWindow_RequestActivate(this); };
void requestUpdate() { callbackQWindow_RequestUpdate(this); };
void resizeEvent(QResizeEvent * ev) { callbackQWindow_ResizeEvent(this, ev); };
void Signal_ScreenChanged(QScreen * screen) { callbackQWindow_ScreenChanged(this, screen); };
void setGeometry(const QRect & rect) { callbackQWindow_SetGeometry2(this, const_cast<QRect*>(&rect)); };
void setGeometry(int posx, int posy, int w, int h) { callbackQWindow_SetGeometry(this, posx, posy, w, h); };
void setHeight(int arg) { callbackQWindow_SetHeight(this, arg); };
void setMaximumHeight(int h) { callbackQWindow_SetMaximumHeight(this, h); };
void setMaximumWidth(int w) { callbackQWindow_SetMaximumWidth(this, w); };
void setMinimumHeight(int h) { callbackQWindow_SetMinimumHeight(this, h); };
void setMinimumWidth(int w) { callbackQWindow_SetMinimumWidth(this, w); };
void setTitle(const QString & vqs) { QByteArray tda39a3 = vqs.toUtf8(); QtGui_PackedString vqsPacked = { const_cast<char*>(tda39a3.prepend("WHITESPACE").constData()+10), tda39a3.size()-10 };callbackQWindow_SetTitle(this, vqsPacked); };
void setVisible(bool visible) { callbackQWindow_SetVisible(this, visible); };
void setWidth(int arg) { callbackQWindow_SetWidth(this, arg); };
void setX(int arg) { callbackQWindow_SetX(this, arg); };
void setY(int arg) { callbackQWindow_SetY(this, arg); };
void show() { callbackQWindow_Show(this); };
void showEvent(QShowEvent * ev) { callbackQWindow_ShowEvent(this, ev); };
void showFullScreen() { callbackQWindow_ShowFullScreen(this); };
void showMaximized() { callbackQWindow_ShowMaximized(this); };
void showMinimized() { callbackQWindow_ShowMinimized(this); };
void showNormal() { callbackQWindow_ShowNormal(this); };
void tabletEvent(QTabletEvent * ev) { callbackQWindow_TabletEvent(this, ev); };
void touchEvent(QTouchEvent * ev) { callbackQWindow_TouchEvent(this, ev); };
void Signal_VisibilityChanged(QWindow::Visibility visibility) { callbackQWindow_VisibilityChanged(this, visibility); };
void Signal_VisibleChanged(bool arg) { callbackQWindow_VisibleChanged(this, arg); };
void wheelEvent(QWheelEvent * ev) { callbackQWindow_WheelEvent(this, ev); };
void Signal_WidthChanged(int arg) { callbackQWindow_WidthChanged(this, arg); };
void Signal_WindowStateChanged(Qt::WindowState windowState) { callbackQWindow_WindowStateChanged(this, windowState); };
void Signal_WindowTitleChanged(const QString & title) { QByteArray t3c6de1 = title.toUtf8(); QtGui_PackedString titlePacked = { const_cast<char*>(t3c6de1.prepend("WHITESPACE").constData()+10), t3c6de1.size()-10 };callbackQWindow_WindowTitleChanged(this, titlePacked); };
void Signal_XChanged(int arg) { callbackQWindow_XChanged(this, arg); };
void Signal_YChanged(int arg) { callbackQWindow_YChanged(this, arg); };
~MyQWindow() { callbackQWindow_DestroyQWindow(this); };
QObject * focusObject() const { return static_cast<QObject*>(callbackQWindow_FocusObject(const_cast<void*>(static_cast<const void*>(this)))); };
QSize size() const { return *static_cast<QSize*>(callbackQWindow_Size(const_cast<void*>(static_cast<const void*>(this)))); };
QSurface::SurfaceType surfaceType() const { return static_cast<QSurface::SurfaceType>(callbackQWindow_SurfaceType(const_cast<void*>(static_cast<const void*>(this)))); };
QSurfaceFormat format() const { return *static_cast<QSurfaceFormat*>(callbackQWindow_Format(const_cast<void*>(static_cast<const void*>(this)))); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWindow_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQWindow_EventFilter(this, watched, event) != 0; };
void childEvent(QChildEvent * event) { callbackQWindow_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQWindow_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQWindow_CustomEvent(this, event); };
void deleteLater() { callbackQWindow_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQWindow_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQWindow_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQWindow_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQWindow_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(MyQWindow*)
int QWindow_QWindow_QRegisterMetaType(){qRegisterMetaType<QWindow*>(); return qRegisterMetaType<MyQWindow*>();}
struct QtGui_PackedString QWindow_QWindow_Tr(char* s, char* c, int n)
{
return ({ QByteArray tdca59e = QWindow::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(tdca59e.prepend("WHITESPACE").constData()+10), tdca59e.size()-10 }; });
}
struct QtGui_PackedString QWindow_QWindow_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray t82c68d = QWindow::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtGui_PackedString { const_cast<char*>(t82c68d.prepend("WHITESPACE").constData()+10), t82c68d.size()-10 }; });
}
void* QWindow_QWindow_FromWinId(uintptr_t id)
{
return QWindow::fromWinId(id);
}
void* QWindow_NewQWindow(void* targetScreen)
{
return new MyQWindow(static_cast<QScreen*>(targetScreen));
}
void* QWindow_NewQWindow2(void* parent)
{
return new MyQWindow(static_cast<QWindow*>(parent));
}
char QWindow_Close(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
bool returnArg;
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
} else {
bool returnArg;
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
}
char QWindow_CloseDefault(void* ptr)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QRasterWindow*>(ptr)->QRasterWindow::close();
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::close();
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::close();
} else {
return static_cast<QWindow*>(ptr)->QWindow::close();
}
}
char QWindow_Event(void* ptr, void* ev)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->event(static_cast<QEvent*>(ev));
} else {
return static_cast<QWindow*>(ptr)->event(static_cast<QEvent*>(ev));
}
}
char QWindow_EventDefault(void* ptr, void* ev)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QRasterWindow*>(ptr)->QRasterWindow::event(static_cast<QEvent*>(ev));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::event(static_cast<QEvent*>(ev));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::event(static_cast<QEvent*>(ev));
} else {
return static_cast<QWindow*>(ptr)->QWindow::event(static_cast<QEvent*>(ev));
}
}
char QWindow_SetKeyboardGrabEnabled(void* ptr, char grab)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->setKeyboardGrabEnabled(grab != 0);
} else {
return static_cast<QWindow*>(ptr)->setKeyboardGrabEnabled(grab != 0);
}
}
char QWindow_SetMouseGrabEnabled(void* ptr, char grab)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->setMouseGrabEnabled(grab != 0);
} else {
return static_cast<QWindow*>(ptr)->setMouseGrabEnabled(grab != 0);
}
}
void QWindow_ConnectActiveChanged(void* ptr)
{
QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)()>(&QWindow::activeChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)()>(&MyQWindow::Signal_ActiveChanged));
}
void QWindow_DisconnectActiveChanged(void* ptr)
{
QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)()>(&QWindow::activeChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)()>(&MyQWindow::Signal_ActiveChanged));
}
void QWindow_ActiveChanged(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->activeChanged();
} else {
static_cast<QWindow*>(ptr)->activeChanged();
}
}
void QWindow_Alert(void* ptr, int msec)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "alert", Q_ARG(int, msec));
} else {
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "alert", Q_ARG(int, msec));
}
}
void QWindow_AlertDefault(void* ptr, int msec)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::alert(msec);
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::alert(msec);
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::alert(msec);
} else {
static_cast<QWindow*>(ptr)->QWindow::alert(msec);
}
}
void QWindow_ConnectContentOrientationChanged(void* ptr)
{
qRegisterMetaType<Qt::ScreenOrientation>();
QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(Qt::ScreenOrientation)>(&QWindow::contentOrientationChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(Qt::ScreenOrientation)>(&MyQWindow::Signal_ContentOrientationChanged));
}
void QWindow_DisconnectContentOrientationChanged(void* ptr)
{
QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(Qt::ScreenOrientation)>(&QWindow::contentOrientationChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(Qt::ScreenOrientation)>(&MyQWindow::Signal_ContentOrientationChanged));
}
void QWindow_ContentOrientationChanged(void* ptr, long long orientation)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->contentOrientationChanged(static_cast<Qt::ScreenOrientation>(orientation));
} else {
static_cast<QWindow*>(ptr)->contentOrientationChanged(static_cast<Qt::ScreenOrientation>(orientation));
}
}
void QWindow_Create(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->create();
} else {
static_cast<QWindow*>(ptr)->create();
}
}
void QWindow_Destroy(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->destroy();
} else {
static_cast<QWindow*>(ptr)->destroy();
}
}
void QWindow_ExposeEvent(void* ptr, void* ev)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->exposeEvent(static_cast<QExposeEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->exposeEvent(static_cast<QExposeEvent*>(ev));
}
}
void QWindow_ExposeEventDefault(void* ptr, void* ev)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::exposeEvent(static_cast<QExposeEvent*>(ev));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::exposeEvent(static_cast<QExposeEvent*>(ev));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::exposeEvent(static_cast<QExposeEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->QWindow::exposeEvent(static_cast<QExposeEvent*>(ev));
}
}
void QWindow_FocusInEvent(void* ptr, void* ev)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(ev));
}
}
void QWindow_FocusInEventDefault(void* ptr, void* ev)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::focusInEvent(static_cast<QFocusEvent*>(ev));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::focusInEvent(static_cast<QFocusEvent*>(ev));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::focusInEvent(static_cast<QFocusEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->QWindow::focusInEvent(static_cast<QFocusEvent*>(ev));
}
}
void QWindow_ConnectFocusObjectChanged(void* ptr)
{
QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(QObject *)>(&QWindow::focusObjectChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(QObject *)>(&MyQWindow::Signal_FocusObjectChanged));
}
void QWindow_DisconnectFocusObjectChanged(void* ptr)
{
QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(QObject *)>(&QWindow::focusObjectChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(QObject *)>(&MyQWindow::Signal_FocusObjectChanged));
}
void QWindow_FocusObjectChanged(void* ptr, void* object)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(object))) {
static_cast<QPaintDeviceWindow*>(ptr)->focusObjectChanged(static_cast<QOffscreenSurface*>(object));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(object))) {
static_cast<QPaintDeviceWindow*>(ptr)->focusObjectChanged(static_cast<QPaintDeviceWindow*>(object));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(object))) {
static_cast<QPaintDeviceWindow*>(ptr)->focusObjectChanged(static_cast<QPdfWriter*>(object));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(object))) {
static_cast<QPaintDeviceWindow*>(ptr)->focusObjectChanged(static_cast<QWindow*>(object));
} else {
static_cast<QPaintDeviceWindow*>(ptr)->focusObjectChanged(static_cast<QObject*>(object));
}
} else {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(object))) {
static_cast<QWindow*>(ptr)->focusObjectChanged(static_cast<QOffscreenSurface*>(object));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(object))) {
static_cast<QWindow*>(ptr)->focusObjectChanged(static_cast<QPaintDeviceWindow*>(object));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(object))) {
static_cast<QWindow*>(ptr)->focusObjectChanged(static_cast<QPdfWriter*>(object));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(object))) {
static_cast<QWindow*>(ptr)->focusObjectChanged(static_cast<QWindow*>(object));
} else {
static_cast<QWindow*>(ptr)->focusObjectChanged(static_cast<QObject*>(object));
}
}
}
void QWindow_FocusOutEvent(void* ptr, void* ev)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(ev));
}
}
void QWindow_FocusOutEventDefault(void* ptr, void* ev)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::focusOutEvent(static_cast<QFocusEvent*>(ev));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::focusOutEvent(static_cast<QFocusEvent*>(ev));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::focusOutEvent(static_cast<QFocusEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->QWindow::focusOutEvent(static_cast<QFocusEvent*>(ev));
}
}
void QWindow_ConnectHeightChanged(void* ptr)
{
QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::heightChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_HeightChanged));
}
void QWindow_DisconnectHeightChanged(void* ptr)
{
QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::heightChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_HeightChanged));
}
void QWindow_HeightChanged(void* ptr, int arg)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->heightChanged(arg);
} else {
static_cast<QWindow*>(ptr)->heightChanged(arg);
}
}
void QWindow_Hide(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "hide");
} else {
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "hide");
}
}
void QWindow_HideDefault(void* ptr)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::hide();
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::hide();
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::hide();
} else {
static_cast<QWindow*>(ptr)->QWindow::hide();
}
}
void QWindow_HideEvent(void* ptr, void* ev)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->hideEvent(static_cast<QHideEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->hideEvent(static_cast<QHideEvent*>(ev));
}
}
void QWindow_HideEventDefault(void* ptr, void* ev)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::hideEvent(static_cast<QHideEvent*>(ev));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::hideEvent(static_cast<QHideEvent*>(ev));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::hideEvent(static_cast<QHideEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->QWindow::hideEvent(static_cast<QHideEvent*>(ev));
}
}
void QWindow_KeyPressEvent(void* ptr, void* ev)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(ev));
}
}
void QWindow_KeyPressEventDefault(void* ptr, void* ev)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::keyPressEvent(static_cast<QKeyEvent*>(ev));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::keyPressEvent(static_cast<QKeyEvent*>(ev));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::keyPressEvent(static_cast<QKeyEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->QWindow::keyPressEvent(static_cast<QKeyEvent*>(ev));
}
}
void QWindow_KeyReleaseEvent(void* ptr, void* ev)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(ev));
}
}
void QWindow_KeyReleaseEventDefault(void* ptr, void* ev)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::keyReleaseEvent(static_cast<QKeyEvent*>(ev));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::keyReleaseEvent(static_cast<QKeyEvent*>(ev));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::keyReleaseEvent(static_cast<QKeyEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->QWindow::keyReleaseEvent(static_cast<QKeyEvent*>(ev));
}
}
void QWindow_Lower(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "lower");
} else {
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "lower");
}
}
void QWindow_LowerDefault(void* ptr)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::lower();
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::lower();
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::lower();
} else {
static_cast<QWindow*>(ptr)->QWindow::lower();
}
}
void QWindow_ConnectMaximumHeightChanged(void* ptr)
{
QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::maximumHeightChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_MaximumHeightChanged));
}
void QWindow_DisconnectMaximumHeightChanged(void* ptr)
{
QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::maximumHeightChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_MaximumHeightChanged));
}
void QWindow_MaximumHeightChanged(void* ptr, int arg)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->maximumHeightChanged(arg);
} else {
static_cast<QWindow*>(ptr)->maximumHeightChanged(arg);
}
}
void QWindow_ConnectMaximumWidthChanged(void* ptr)
{
QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::maximumWidthChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_MaximumWidthChanged));
}
void QWindow_DisconnectMaximumWidthChanged(void* ptr)
{
QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::maximumWidthChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_MaximumWidthChanged));
}
void QWindow_MaximumWidthChanged(void* ptr, int arg)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->maximumWidthChanged(arg);
} else {
static_cast<QWindow*>(ptr)->maximumWidthChanged(arg);
}
}
void QWindow_ConnectMinimumHeightChanged(void* ptr)
{
QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::minimumHeightChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_MinimumHeightChanged));
}
void QWindow_DisconnectMinimumHeightChanged(void* ptr)
{
QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::minimumHeightChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_MinimumHeightChanged));
}
void QWindow_MinimumHeightChanged(void* ptr, int arg)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->minimumHeightChanged(arg);
} else {
static_cast<QWindow*>(ptr)->minimumHeightChanged(arg);
}
}
void QWindow_ConnectMinimumWidthChanged(void* ptr)
{
QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::minimumWidthChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_MinimumWidthChanged));
}
void QWindow_DisconnectMinimumWidthChanged(void* ptr)
{
QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::minimumWidthChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_MinimumWidthChanged));
}
void QWindow_MinimumWidthChanged(void* ptr, int arg)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->minimumWidthChanged(arg);
} else {
static_cast<QWindow*>(ptr)->minimumWidthChanged(arg);
}
}
void QWindow_ConnectModalityChanged(void* ptr)
{
qRegisterMetaType<Qt::WindowModality>();
QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(Qt::WindowModality)>(&QWindow::modalityChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(Qt::WindowModality)>(&MyQWindow::Signal_ModalityChanged));
}
void QWindow_DisconnectModalityChanged(void* ptr)
{
QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(Qt::WindowModality)>(&QWindow::modalityChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(Qt::WindowModality)>(&MyQWindow::Signal_ModalityChanged));
}
void QWindow_ModalityChanged(void* ptr, long long modality)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->modalityChanged(static_cast<Qt::WindowModality>(modality));
} else {
static_cast<QWindow*>(ptr)->modalityChanged(static_cast<Qt::WindowModality>(modality));
}
}
void QWindow_MouseDoubleClickEvent(void* ptr, void* ev)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(ev));
}
}
void QWindow_MouseDoubleClickEventDefault(void* ptr, void* ev)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::mouseDoubleClickEvent(static_cast<QMouseEvent*>(ev));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::mouseDoubleClickEvent(static_cast<QMouseEvent*>(ev));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::mouseDoubleClickEvent(static_cast<QMouseEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->QWindow::mouseDoubleClickEvent(static_cast<QMouseEvent*>(ev));
}
}
void QWindow_MouseMoveEvent(void* ptr, void* ev)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(ev));
}
}
void QWindow_MouseMoveEventDefault(void* ptr, void* ev)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::mouseMoveEvent(static_cast<QMouseEvent*>(ev));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::mouseMoveEvent(static_cast<QMouseEvent*>(ev));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::mouseMoveEvent(static_cast<QMouseEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->QWindow::mouseMoveEvent(static_cast<QMouseEvent*>(ev));
}
}
void QWindow_MousePressEvent(void* ptr, void* ev)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(ev));
}
}
void QWindow_MousePressEventDefault(void* ptr, void* ev)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::mousePressEvent(static_cast<QMouseEvent*>(ev));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::mousePressEvent(static_cast<QMouseEvent*>(ev));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::mousePressEvent(static_cast<QMouseEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->QWindow::mousePressEvent(static_cast<QMouseEvent*>(ev));
}
}
void QWindow_MouseReleaseEvent(void* ptr, void* ev)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(ev));
}
}
void QWindow_MouseReleaseEventDefault(void* ptr, void* ev)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::mouseReleaseEvent(static_cast<QMouseEvent*>(ev));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::mouseReleaseEvent(static_cast<QMouseEvent*>(ev));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::mouseReleaseEvent(static_cast<QMouseEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->QWindow::mouseReleaseEvent(static_cast<QMouseEvent*>(ev));
}
}
void QWindow_MoveEvent(void* ptr, void* ev)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->moveEvent(static_cast<QMoveEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->moveEvent(static_cast<QMoveEvent*>(ev));
}
}
void QWindow_MoveEventDefault(void* ptr, void* ev)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::moveEvent(static_cast<QMoveEvent*>(ev));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::moveEvent(static_cast<QMoveEvent*>(ev));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::moveEvent(static_cast<QMoveEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->QWindow::moveEvent(static_cast<QMoveEvent*>(ev));
}
}
void QWindow_ConnectOpacityChanged(void* ptr)
{
QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(qreal)>(&QWindow::opacityChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(qreal)>(&MyQWindow::Signal_OpacityChanged));
}
void QWindow_DisconnectOpacityChanged(void* ptr)
{
QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(qreal)>(&QWindow::opacityChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(qreal)>(&MyQWindow::Signal_OpacityChanged));
}
void QWindow_OpacityChanged(void* ptr, double opacity)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->opacityChanged(opacity);
} else {
static_cast<QWindow*>(ptr)->opacityChanged(opacity);
}
}
void QWindow_Raise(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "raise");
} else {
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "raise");
}
}
void QWindow_RaiseDefault(void* ptr)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::raise();
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::raise();
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::raise();
} else {
static_cast<QWindow*>(ptr)->QWindow::raise();
}
}
void QWindow_ReportContentOrientationChange(void* ptr, long long orientation)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->reportContentOrientationChange(static_cast<Qt::ScreenOrientation>(orientation));
} else {
static_cast<QWindow*>(ptr)->reportContentOrientationChange(static_cast<Qt::ScreenOrientation>(orientation));
}
}
void QWindow_RequestActivate(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "requestActivate");
} else {
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "requestActivate");
}
}
void QWindow_RequestActivateDefault(void* ptr)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::requestActivate();
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::requestActivate();
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::requestActivate();
} else {
static_cast<QWindow*>(ptr)->QWindow::requestActivate();
}
}
void QWindow_RequestUpdate(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "requestUpdate");
} else {
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "requestUpdate");
}
}
void QWindow_RequestUpdateDefault(void* ptr)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::requestUpdate();
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::requestUpdate();
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::requestUpdate();
} else {
static_cast<QWindow*>(ptr)->QWindow::requestUpdate();
}
}
void QWindow_Resize(void* ptr, void* newSize)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->resize(*static_cast<QSize*>(newSize));
} else {
static_cast<QWindow*>(ptr)->resize(*static_cast<QSize*>(newSize));
}
}
void QWindow_Resize2(void* ptr, int w, int h)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->resize(w, h);
} else {
static_cast<QWindow*>(ptr)->resize(w, h);
}
}
void QWindow_ResizeEvent(void* ptr, void* ev)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(ev));
}
}
void QWindow_ResizeEventDefault(void* ptr, void* ev)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::resizeEvent(static_cast<QResizeEvent*>(ev));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::resizeEvent(static_cast<QResizeEvent*>(ev));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::resizeEvent(static_cast<QResizeEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->QWindow::resizeEvent(static_cast<QResizeEvent*>(ev));
}
}
void QWindow_ConnectScreenChanged(void* ptr)
{
QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(QScreen *)>(&QWindow::screenChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(QScreen *)>(&MyQWindow::Signal_ScreenChanged));
}
void QWindow_DisconnectScreenChanged(void* ptr)
{
QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(QScreen *)>(&QWindow::screenChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(QScreen *)>(&MyQWindow::Signal_ScreenChanged));
}
void QWindow_ScreenChanged(void* ptr, void* screen)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->screenChanged(static_cast<QScreen*>(screen));
} else {
static_cast<QWindow*>(ptr)->screenChanged(static_cast<QScreen*>(screen));
}
}
void QWindow_SetBaseSize(void* ptr, void* size)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->setBaseSize(*static_cast<QSize*>(size));
} else {
static_cast<QWindow*>(ptr)->setBaseSize(*static_cast<QSize*>(size));
}
}
void QWindow_SetCursor(void* ptr, void* cursor)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->setCursor(*static_cast<QCursor*>(cursor));
} else {
static_cast<QWindow*>(ptr)->setCursor(*static_cast<QCursor*>(cursor));
}
}
void QWindow_SetFilePath(void* ptr, struct QtGui_PackedString filePath)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->setFilePath(QString::fromUtf8(filePath.data, filePath.len));
} else {
static_cast<QWindow*>(ptr)->setFilePath(QString::fromUtf8(filePath.data, filePath.len));
}
}
void QWindow_SetFlag(void* ptr, long long flag, char on)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->setFlag(static_cast<Qt::WindowType>(flag), on != 0);
} else {
static_cast<QWindow*>(ptr)->setFlag(static_cast<Qt::WindowType>(flag), on != 0);
}
}
void QWindow_SetFlags(void* ptr, long long flags)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->setFlags(static_cast<Qt::WindowType>(flags));
} else {
static_cast<QWindow*>(ptr)->setFlags(static_cast<Qt::WindowType>(flags));
}
}
void QWindow_SetFormat(void* ptr, void* format)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->setFormat(*static_cast<QSurfaceFormat*>(format));
} else {
static_cast<QWindow*>(ptr)->setFormat(*static_cast<QSurfaceFormat*>(format));
}
}
void QWindow_SetFramePosition(void* ptr, void* point)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->setFramePosition(*static_cast<QPoint*>(point));
} else {
static_cast<QWindow*>(ptr)->setFramePosition(*static_cast<QPoint*>(point));
}
}
void QWindow_SetGeometry2(void* ptr, void* rect)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "setGeometry", Q_ARG(const QRect, *static_cast<QRect*>(rect)));
} else {
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "setGeometry", Q_ARG(const QRect, *static_cast<QRect*>(rect)));
}
}
void QWindow_SetGeometry2Default(void* ptr, void* rect)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::setGeometry(*static_cast<QRect*>(rect));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::setGeometry(*static_cast<QRect*>(rect));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::setGeometry(*static_cast<QRect*>(rect));
} else {
static_cast<QWindow*>(ptr)->QWindow::setGeometry(*static_cast<QRect*>(rect));
}
}
void QWindow_SetGeometry(void* ptr, int posx, int posy, int w, int h)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "setGeometry", Q_ARG(int, posx), Q_ARG(int, posy), Q_ARG(int, w), Q_ARG(int, h));
} else {
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "setGeometry", Q_ARG(int, posx), Q_ARG(int, posy), Q_ARG(int, w), Q_ARG(int, h));
}
}
void QWindow_SetGeometryDefault(void* ptr, int posx, int posy, int w, int h)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::setGeometry(posx, posy, w, h);
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::setGeometry(posx, posy, w, h);
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::setGeometry(posx, posy, w, h);
} else {
static_cast<QWindow*>(ptr)->QWindow::setGeometry(posx, posy, w, h);
}
}
void QWindow_SetHeight(void* ptr, int arg)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "setHeight", Q_ARG(int, arg));
} else {
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "setHeight", Q_ARG(int, arg));
}
}
void QWindow_SetHeightDefault(void* ptr, int arg)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::setHeight(arg);
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::setHeight(arg);
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::setHeight(arg);
} else {
static_cast<QWindow*>(ptr)->QWindow::setHeight(arg);
}
}
void QWindow_SetIcon(void* ptr, void* icon)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->setIcon(*static_cast<QIcon*>(icon));
} else {
static_cast<QWindow*>(ptr)->setIcon(*static_cast<QIcon*>(icon));
}
}
void QWindow_SetMask(void* ptr, void* region)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->setMask(*static_cast<QRegion*>(region));
} else {
static_cast<QWindow*>(ptr)->setMask(*static_cast<QRegion*>(region));
}
}
void QWindow_SetMaximumHeight(void* ptr, int h)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "setMaximumHeight", Q_ARG(int, h));
} else {
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "setMaximumHeight", Q_ARG(int, h));
}
}
void QWindow_SetMaximumHeightDefault(void* ptr, int h)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::setMaximumHeight(h);
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::setMaximumHeight(h);
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::setMaximumHeight(h);
} else {
static_cast<QWindow*>(ptr)->QWindow::setMaximumHeight(h);
}
}
void QWindow_SetMaximumSize(void* ptr, void* size)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->setMaximumSize(*static_cast<QSize*>(size));
} else {
static_cast<QWindow*>(ptr)->setMaximumSize(*static_cast<QSize*>(size));
}
}
void QWindow_SetMaximumWidth(void* ptr, int w)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "setMaximumWidth", Q_ARG(int, w));
} else {
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "setMaximumWidth", Q_ARG(int, w));
}
}
void QWindow_SetMaximumWidthDefault(void* ptr, int w)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::setMaximumWidth(w);
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::setMaximumWidth(w);
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::setMaximumWidth(w);
} else {
static_cast<QWindow*>(ptr)->QWindow::setMaximumWidth(w);
}
}
void QWindow_SetMinimumHeight(void* ptr, int h)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "setMinimumHeight", Q_ARG(int, h));
} else {
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "setMinimumHeight", Q_ARG(int, h));
}
}
void QWindow_SetMinimumHeightDefault(void* ptr, int h)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::setMinimumHeight(h);
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::setMinimumHeight(h);
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::setMinimumHeight(h);
} else {
static_cast<QWindow*>(ptr)->QWindow::setMinimumHeight(h);
}
}
void QWindow_SetMinimumSize(void* ptr, void* size)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->setMinimumSize(*static_cast<QSize*>(size));
} else {
static_cast<QWindow*>(ptr)->setMinimumSize(*static_cast<QSize*>(size));
}
}
void QWindow_SetMinimumWidth(void* ptr, int w)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "setMinimumWidth", Q_ARG(int, w));
} else {
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "setMinimumWidth", Q_ARG(int, w));
}
}
void QWindow_SetMinimumWidthDefault(void* ptr, int w)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::setMinimumWidth(w);
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::setMinimumWidth(w);
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::setMinimumWidth(w);
} else {
static_cast<QWindow*>(ptr)->QWindow::setMinimumWidth(w);
}
}
void QWindow_SetModality(void* ptr, long long modality)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->setModality(static_cast<Qt::WindowModality>(modality));
} else {
static_cast<QWindow*>(ptr)->setModality(static_cast<Qt::WindowModality>(modality));
}
}
void QWindow_SetOpacity(void* ptr, double level)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->setOpacity(level);
} else {
static_cast<QWindow*>(ptr)->setOpacity(level);
}
}
void QWindow_SetParent(void* ptr, void* parent)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
static_cast<QPaintDeviceWindow*>(ptr)->setParent(static_cast<QPaintDeviceWindow*>(parent));
} else {
static_cast<QPaintDeviceWindow*>(ptr)->setParent(static_cast<QWindow*>(parent));
}
} else {
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
static_cast<QWindow*>(ptr)->setParent(static_cast<QPaintDeviceWindow*>(parent));
} else {
static_cast<QWindow*>(ptr)->setParent(static_cast<QWindow*>(parent));
}
}
}
void QWindow_SetPosition(void* ptr, void* pt)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->setPosition(*static_cast<QPoint*>(pt));
} else {
static_cast<QWindow*>(ptr)->setPosition(*static_cast<QPoint*>(pt));
}
}
void QWindow_SetPosition2(void* ptr, int posx, int posy)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->setPosition(posx, posy);
} else {
static_cast<QWindow*>(ptr)->setPosition(posx, posy);
}
}
void QWindow_SetScreen(void* ptr, void* newScreen)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->setScreen(static_cast<QScreen*>(newScreen));
} else {
static_cast<QWindow*>(ptr)->setScreen(static_cast<QScreen*>(newScreen));
}
}
void QWindow_SetSizeIncrement(void* ptr, void* size)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->setSizeIncrement(*static_cast<QSize*>(size));
} else {
static_cast<QWindow*>(ptr)->setSizeIncrement(*static_cast<QSize*>(size));
}
}
void QWindow_SetSurfaceType(void* ptr, long long surfaceType)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->setSurfaceType(static_cast<QSurface::SurfaceType>(surfaceType));
} else {
static_cast<QWindow*>(ptr)->setSurfaceType(static_cast<QSurface::SurfaceType>(surfaceType));
}
}
void QWindow_SetTitle(void* ptr, struct QtGui_PackedString vqs)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "setTitle", Q_ARG(const QString, QString::fromUtf8(vqs.data, vqs.len)));
} else {
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "setTitle", Q_ARG(const QString, QString::fromUtf8(vqs.data, vqs.len)));
}
}
void QWindow_SetTitleDefault(void* ptr, struct QtGui_PackedString vqs)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::setTitle(QString::fromUtf8(vqs.data, vqs.len));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::setTitle(QString::fromUtf8(vqs.data, vqs.len));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::setTitle(QString::fromUtf8(vqs.data, vqs.len));
} else {
static_cast<QWindow*>(ptr)->QWindow::setTitle(QString::fromUtf8(vqs.data, vqs.len));
}
}
void QWindow_SetTransientParent(void* ptr, void* parent)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
static_cast<QPaintDeviceWindow*>(ptr)->setTransientParent(static_cast<QPaintDeviceWindow*>(parent));
} else {
static_cast<QPaintDeviceWindow*>(ptr)->setTransientParent(static_cast<QWindow*>(parent));
}
} else {
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
static_cast<QWindow*>(ptr)->setTransientParent(static_cast<QPaintDeviceWindow*>(parent));
} else {
static_cast<QWindow*>(ptr)->setTransientParent(static_cast<QWindow*>(parent));
}
}
}
void QWindow_SetVisibility(void* ptr, long long v)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->setVisibility(static_cast<QWindow::Visibility>(v));
} else {
static_cast<QWindow*>(ptr)->setVisibility(static_cast<QWindow::Visibility>(v));
}
}
void QWindow_SetVisible(void* ptr, char visible)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
} else {
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
}
}
void QWindow_SetVisibleDefault(void* ptr, char visible)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::setVisible(visible != 0);
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::setVisible(visible != 0);
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::setVisible(visible != 0);
} else {
static_cast<QWindow*>(ptr)->QWindow::setVisible(visible != 0);
}
}
void QWindow_SetWidth(void* ptr, int arg)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "setWidth", Q_ARG(int, arg));
} else {
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "setWidth", Q_ARG(int, arg));
}
}
void QWindow_SetWidthDefault(void* ptr, int arg)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::setWidth(arg);
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::setWidth(arg);
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::setWidth(arg);
} else {
static_cast<QWindow*>(ptr)->QWindow::setWidth(arg);
}
}
void QWindow_SetWindowState(void* ptr, long long state)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->setWindowState(static_cast<Qt::WindowState>(state));
} else {
static_cast<QWindow*>(ptr)->setWindowState(static_cast<Qt::WindowState>(state));
}
}
void QWindow_SetWindowStates(void* ptr, long long state)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->setWindowStates(static_cast<Qt::WindowState>(state));
} else {
static_cast<QWindow*>(ptr)->setWindowStates(static_cast<Qt::WindowState>(state));
}
}
void QWindow_SetX(void* ptr, int arg)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "setX", Q_ARG(int, arg));
} else {
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "setX", Q_ARG(int, arg));
}
}
void QWindow_SetXDefault(void* ptr, int arg)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::setX(arg);
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::setX(arg);
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::setX(arg);
} else {
static_cast<QWindow*>(ptr)->QWindow::setX(arg);
}
}
void QWindow_SetY(void* ptr, int arg)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "setY", Q_ARG(int, arg));
} else {
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "setY", Q_ARG(int, arg));
}
}
void QWindow_SetYDefault(void* ptr, int arg)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::setY(arg);
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::setY(arg);
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::setY(arg);
} else {
static_cast<QWindow*>(ptr)->QWindow::setY(arg);
}
}
void QWindow_Show(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "show");
} else {
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "show");
}
}
void QWindow_ShowDefault(void* ptr)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::show();
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::show();
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::show();
} else {
static_cast<QWindow*>(ptr)->QWindow::show();
}
}
void QWindow_ShowEvent(void* ptr, void* ev)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->showEvent(static_cast<QShowEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->showEvent(static_cast<QShowEvent*>(ev));
}
}
void QWindow_ShowEventDefault(void* ptr, void* ev)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::showEvent(static_cast<QShowEvent*>(ev));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::showEvent(static_cast<QShowEvent*>(ev));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::showEvent(static_cast<QShowEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->QWindow::showEvent(static_cast<QShowEvent*>(ev));
}
}
void QWindow_ShowFullScreen(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "showFullScreen");
} else {
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "showFullScreen");
}
}
void QWindow_ShowFullScreenDefault(void* ptr)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::showFullScreen();
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::showFullScreen();
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::showFullScreen();
} else {
static_cast<QWindow*>(ptr)->QWindow::showFullScreen();
}
}
void QWindow_ShowMaximized(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "showMaximized");
} else {
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "showMaximized");
}
}
void QWindow_ShowMaximizedDefault(void* ptr)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::showMaximized();
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::showMaximized();
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::showMaximized();
} else {
static_cast<QWindow*>(ptr)->QWindow::showMaximized();
}
}
void QWindow_ShowMinimized(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "showMinimized");
} else {
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "showMinimized");
}
}
void QWindow_ShowMinimizedDefault(void* ptr)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::showMinimized();
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::showMinimized();
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::showMinimized();
} else {
static_cast<QWindow*>(ptr)->QWindow::showMinimized();
}
}
void QWindow_ShowNormal(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "showNormal");
} else {
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "showNormal");
}
}
void QWindow_ShowNormalDefault(void* ptr)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::showNormal();
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::showNormal();
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::showNormal();
} else {
static_cast<QWindow*>(ptr)->QWindow::showNormal();
}
}
void QWindow_TabletEvent(void* ptr, void* ev)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(ev));
}
}
void QWindow_TabletEventDefault(void* ptr, void* ev)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::tabletEvent(static_cast<QTabletEvent*>(ev));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::tabletEvent(static_cast<QTabletEvent*>(ev));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::tabletEvent(static_cast<QTabletEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->QWindow::tabletEvent(static_cast<QTabletEvent*>(ev));
}
}
void QWindow_TouchEvent(void* ptr, void* ev)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->touchEvent(static_cast<QTouchEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->touchEvent(static_cast<QTouchEvent*>(ev));
}
}
void QWindow_TouchEventDefault(void* ptr, void* ev)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::touchEvent(static_cast<QTouchEvent*>(ev));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::touchEvent(static_cast<QTouchEvent*>(ev));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::touchEvent(static_cast<QTouchEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->QWindow::touchEvent(static_cast<QTouchEvent*>(ev));
}
}
void QWindow_UnsetCursor(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->unsetCursor();
} else {
static_cast<QWindow*>(ptr)->unsetCursor();
}
}
void QWindow_ConnectVisibilityChanged(void* ptr)
{
qRegisterMetaType<QWindow::Visibility>();
QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(QWindow::Visibility)>(&QWindow::visibilityChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(QWindow::Visibility)>(&MyQWindow::Signal_VisibilityChanged));
}
void QWindow_DisconnectVisibilityChanged(void* ptr)
{
QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(QWindow::Visibility)>(&QWindow::visibilityChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(QWindow::Visibility)>(&MyQWindow::Signal_VisibilityChanged));
}
void QWindow_VisibilityChanged(void* ptr, long long visibility)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->visibilityChanged(static_cast<QWindow::Visibility>(visibility));
} else {
static_cast<QWindow*>(ptr)->visibilityChanged(static_cast<QWindow::Visibility>(visibility));
}
}
void QWindow_ConnectVisibleChanged(void* ptr)
{
QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(bool)>(&QWindow::visibleChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(bool)>(&MyQWindow::Signal_VisibleChanged));
}
void QWindow_DisconnectVisibleChanged(void* ptr)
{
QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(bool)>(&QWindow::visibleChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(bool)>(&MyQWindow::Signal_VisibleChanged));
}
void QWindow_VisibleChanged(void* ptr, char arg)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->visibleChanged(arg != 0);
} else {
static_cast<QWindow*>(ptr)->visibleChanged(arg != 0);
}
}
void QWindow_WheelEvent(void* ptr, void* ev)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(ev));
}
}
void QWindow_WheelEventDefault(void* ptr, void* ev)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::wheelEvent(static_cast<QWheelEvent*>(ev));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::wheelEvent(static_cast<QWheelEvent*>(ev));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::wheelEvent(static_cast<QWheelEvent*>(ev));
} else {
static_cast<QWindow*>(ptr)->QWindow::wheelEvent(static_cast<QWheelEvent*>(ev));
}
}
void QWindow_ConnectWidthChanged(void* ptr)
{
QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::widthChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_WidthChanged));
}
void QWindow_DisconnectWidthChanged(void* ptr)
{
QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::widthChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_WidthChanged));
}
void QWindow_WidthChanged(void* ptr, int arg)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->widthChanged(arg);
} else {
static_cast<QWindow*>(ptr)->widthChanged(arg);
}
}
void QWindow_ConnectWindowStateChanged(void* ptr)
{
qRegisterMetaType<Qt::WindowState>();
QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(Qt::WindowState)>(&QWindow::windowStateChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(Qt::WindowState)>(&MyQWindow::Signal_WindowStateChanged));
}
void QWindow_DisconnectWindowStateChanged(void* ptr)
{
QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(Qt::WindowState)>(&QWindow::windowStateChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(Qt::WindowState)>(&MyQWindow::Signal_WindowStateChanged));
}
void QWindow_WindowStateChanged(void* ptr, long long windowState)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->windowStateChanged(static_cast<Qt::WindowState>(windowState));
} else {
static_cast<QWindow*>(ptr)->windowStateChanged(static_cast<Qt::WindowState>(windowState));
}
}
void QWindow_ConnectWindowTitleChanged(void* ptr)
{
QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(const QString &)>(&QWindow::windowTitleChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(const QString &)>(&MyQWindow::Signal_WindowTitleChanged));
}
void QWindow_DisconnectWindowTitleChanged(void* ptr)
{
QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(const QString &)>(&QWindow::windowTitleChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(const QString &)>(&MyQWindow::Signal_WindowTitleChanged));
}
void QWindow_WindowTitleChanged(void* ptr, struct QtGui_PackedString title)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->windowTitleChanged(QString::fromUtf8(title.data, title.len));
} else {
static_cast<QWindow*>(ptr)->windowTitleChanged(QString::fromUtf8(title.data, title.len));
}
}
void QWindow_ConnectXChanged(void* ptr)
{
QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::xChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_XChanged));
}
void QWindow_DisconnectXChanged(void* ptr)
{
QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::xChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_XChanged));
}
void QWindow_XChanged(void* ptr, int arg)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->xChanged(arg);
} else {
static_cast<QWindow*>(ptr)->xChanged(arg);
}
}
void QWindow_ConnectYChanged(void* ptr)
{
QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::yChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_YChanged));
}
void QWindow_DisconnectYChanged(void* ptr)
{
QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::yChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_YChanged));
}
void QWindow_YChanged(void* ptr, int arg)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->yChanged(arg);
} else {
static_cast<QWindow*>(ptr)->yChanged(arg);
}
}
void QWindow_DestroyQWindow(void* ptr)
{
static_cast<QWindow*>(ptr)->~QWindow();
}
void QWindow_DestroyQWindowDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QWindow_Cursor(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return new QCursor(static_cast<QPaintDeviceWindow*>(ptr)->cursor());
} else {
return new QCursor(static_cast<QWindow*>(ptr)->cursor());
}
}
void* QWindow_Icon(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return new QIcon(static_cast<QPaintDeviceWindow*>(ptr)->icon());
} else {
return new QIcon(static_cast<QWindow*>(ptr)->icon());
}
}
void* QWindow_FrameMargins(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return ({ QMargins tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->frameMargins(); new QMargins(tmpValue.left(), tmpValue.top(), tmpValue.right(), tmpValue.bottom()); });
} else {
return ({ QMargins tmpValue = static_cast<QWindow*>(ptr)->frameMargins(); new QMargins(tmpValue.left(), tmpValue.top(), tmpValue.right(), tmpValue.bottom()); });
}
}
void* QWindow_FocusObject(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->focusObject();
} else {
return static_cast<QWindow*>(ptr)->focusObject();
}
}
void* QWindow_FocusObjectDefault(void* ptr)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QRasterWindow*>(ptr)->QRasterWindow::focusObject();
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::focusObject();
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::focusObject();
} else {
return static_cast<QWindow*>(ptr)->QWindow::focusObject();
}
}
void* QWindow_FramePosition(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return ({ QPoint tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->framePosition(); new QPoint(tmpValue.x(), tmpValue.y()); });
} else {
return ({ QPoint tmpValue = static_cast<QWindow*>(ptr)->framePosition(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
}
void* QWindow_MapFromGlobal(void* ptr, void* pos)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return ({ QPoint tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->mapFromGlobal(*static_cast<QPoint*>(pos)); new QPoint(tmpValue.x(), tmpValue.y()); });
} else {
return ({ QPoint tmpValue = static_cast<QWindow*>(ptr)->mapFromGlobal(*static_cast<QPoint*>(pos)); new QPoint(tmpValue.x(), tmpValue.y()); });
}
}
void* QWindow_MapToGlobal(void* ptr, void* pos)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return ({ QPoint tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->mapToGlobal(*static_cast<QPoint*>(pos)); new QPoint(tmpValue.x(), tmpValue.y()); });
} else {
return ({ QPoint tmpValue = static_cast<QWindow*>(ptr)->mapToGlobal(*static_cast<QPoint*>(pos)); new QPoint(tmpValue.x(), tmpValue.y()); });
}
}
void* QWindow_Position(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return ({ QPoint tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->position(); new QPoint(tmpValue.x(), tmpValue.y()); });
} else {
return ({ QPoint tmpValue = static_cast<QWindow*>(ptr)->position(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
}
void* QWindow_FrameGeometry(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return ({ QRect tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->frameGeometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
} else {
return ({ QRect tmpValue = static_cast<QWindow*>(ptr)->frameGeometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
}
void* QWindow_Geometry(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return ({ QRect tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
} else {
return ({ QRect tmpValue = static_cast<QWindow*>(ptr)->geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
}
void* QWindow_Mask(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return new QRegion(static_cast<QPaintDeviceWindow*>(ptr)->mask());
} else {
return new QRegion(static_cast<QWindow*>(ptr)->mask());
}
}
void* QWindow_Screen(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->screen();
} else {
return static_cast<QWindow*>(ptr)->screen();
}
}
void* QWindow_BaseSize(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return ({ QSize tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->baseSize(); new QSize(tmpValue.width(), tmpValue.height()); });
} else {
return ({ QSize tmpValue = static_cast<QWindow*>(ptr)->baseSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}
}
void* QWindow_MaximumSize(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return ({ QSize tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
} else {
return ({ QSize tmpValue = static_cast<QWindow*>(ptr)->maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}
}
void* QWindow_MinimumSize(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return ({ QSize tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
} else {
return ({ QSize tmpValue = static_cast<QWindow*>(ptr)->minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}
}
void* QWindow_Size(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return ({ QSize tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
} else {
return ({ QSize tmpValue = static_cast<QWindow*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
}
}
void* QWindow_SizeDefault(void* ptr)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
return ({ QSize tmpValue = static_cast<QRasterWindow*>(ptr)->QRasterWindow::size(); new QSize(tmpValue.width(), tmpValue.height()); });
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
return ({ QSize tmpValue = static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::size(); new QSize(tmpValue.width(), tmpValue.height()); });
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return ({ QSize tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::size(); new QSize(tmpValue.width(), tmpValue.height()); });
} else {
return ({ QSize tmpValue = static_cast<QWindow*>(ptr)->QWindow::size(); new QSize(tmpValue.width(), tmpValue.height()); });
}
}
void* QWindow_SizeIncrement(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return ({ QSize tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->sizeIncrement(); new QSize(tmpValue.width(), tmpValue.height()); });
} else {
return ({ QSize tmpValue = static_cast<QWindow*>(ptr)->sizeIncrement(); new QSize(tmpValue.width(), tmpValue.height()); });
}
}
struct QtGui_PackedString QWindow_FilePath(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return ({ QByteArray t7116fb = static_cast<QPaintDeviceWindow*>(ptr)->filePath().toUtf8(); QtGui_PackedString { const_cast<char*>(t7116fb.prepend("WHITESPACE").constData()+10), t7116fb.size()-10 }; });
} else {
return ({ QByteArray t7116fb = static_cast<QWindow*>(ptr)->filePath().toUtf8(); QtGui_PackedString { const_cast<char*>(t7116fb.prepend("WHITESPACE").constData()+10), t7116fb.size()-10 }; });
}
}
struct QtGui_PackedString QWindow_Title(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return ({ QByteArray t3f590b = static_cast<QPaintDeviceWindow*>(ptr)->title().toUtf8(); QtGui_PackedString { const_cast<char*>(t3f590b.prepend("WHITESPACE").constData()+10), t3f590b.size()-10 }; });
} else {
return ({ QByteArray t3f590b = static_cast<QWindow*>(ptr)->title().toUtf8(); QtGui_PackedString { const_cast<char*>(t3f590b.prepend("WHITESPACE").constData()+10), t3f590b.size()-10 }; });
}
}
long long QWindow_SurfaceType(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->surfaceType();
} else {
return static_cast<QWindow*>(ptr)->surfaceType();
}
}
long long QWindow_SurfaceTypeDefault(void* ptr)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QRasterWindow*>(ptr)->QRasterWindow::surfaceType();
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::surfaceType();
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::surfaceType();
} else {
return static_cast<QWindow*>(ptr)->QWindow::surfaceType();
}
}
void* QWindow_Format(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return new QSurfaceFormat(static_cast<QPaintDeviceWindow*>(ptr)->format());
} else {
return new QSurfaceFormat(static_cast<QWindow*>(ptr)->format());
}
}
void* QWindow_FormatDefault(void* ptr)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
return new QSurfaceFormat(static_cast<QRasterWindow*>(ptr)->QRasterWindow::format());
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
return new QSurfaceFormat(static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::format());
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return new QSurfaceFormat(static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::format());
} else {
return new QSurfaceFormat(static_cast<QWindow*>(ptr)->QWindow::format());
}
}
void* QWindow_RequestedFormat(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return new QSurfaceFormat(static_cast<QPaintDeviceWindow*>(ptr)->requestedFormat());
} else {
return new QSurfaceFormat(static_cast<QWindow*>(ptr)->requestedFormat());
}
}
void* QWindow_Parent2(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->parent();
} else {
return static_cast<QWindow*>(ptr)->parent();
}
}
void* QWindow_Parent(void* ptr, long long mode)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->parent(static_cast<QWindow::AncestorMode>(mode));
} else {
return static_cast<QWindow*>(ptr)->parent(static_cast<QWindow::AncestorMode>(mode));
}
}
void* QWindow_TransientParent(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->transientParent();
} else {
return static_cast<QWindow*>(ptr)->transientParent();
}
}
long long QWindow_Visibility(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->visibility();
} else {
return static_cast<QWindow*>(ptr)->visibility();
}
}
long long QWindow_ContentOrientation(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->contentOrientation();
} else {
return static_cast<QWindow*>(ptr)->contentOrientation();
}
}
long long QWindow_Flags(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->flags();
} else {
return static_cast<QWindow*>(ptr)->flags();
}
}
long long QWindow_Modality(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->modality();
} else {
return static_cast<QWindow*>(ptr)->modality();
}
}
long long QWindow_WindowState(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->windowState();
} else {
return static_cast<QWindow*>(ptr)->windowState();
}
}
long long QWindow_WindowStates(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->windowStates();
} else {
return static_cast<QWindow*>(ptr)->windowStates();
}
}
long long QWindow_Type(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->type();
} else {
return static_cast<QWindow*>(ptr)->type();
}
}
uintptr_t QWindow_WinId(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->winId();
} else {
return static_cast<QWindow*>(ptr)->winId();
}
}
char QWindow_IsActive(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->isActive();
} else {
return static_cast<QWindow*>(ptr)->isActive();
}
}
char QWindow_IsAncestorOf(void* ptr, void* child, long long mode)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(child))) {
return static_cast<QPaintDeviceWindow*>(ptr)->isAncestorOf(static_cast<QPaintDeviceWindow*>(child), static_cast<QWindow::AncestorMode>(mode));
} else {
return static_cast<QPaintDeviceWindow*>(ptr)->isAncestorOf(static_cast<QWindow*>(child), static_cast<QWindow::AncestorMode>(mode));
}
} else {
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(child))) {
return static_cast<QWindow*>(ptr)->isAncestorOf(static_cast<QPaintDeviceWindow*>(child), static_cast<QWindow::AncestorMode>(mode));
} else {
return static_cast<QWindow*>(ptr)->isAncestorOf(static_cast<QWindow*>(child), static_cast<QWindow::AncestorMode>(mode));
}
}
}
char QWindow_IsExposed(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->isExposed();
} else {
return static_cast<QWindow*>(ptr)->isExposed();
}
}
char QWindow_IsModal(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->isModal();
} else {
return static_cast<QWindow*>(ptr)->isModal();
}
}
char QWindow_IsTopLevel(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->isTopLevel();
} else {
return static_cast<QWindow*>(ptr)->isTopLevel();
}
}
char QWindow_IsVisible(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->isVisible();
} else {
return static_cast<QWindow*>(ptr)->isVisible();
}
}
void* QWindow_MetaObject(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QPaintDeviceWindow*>(ptr)->metaObject());
} else {
return const_cast<QMetaObject*>(static_cast<QWindow*>(ptr)->metaObject());
}
}
void* QWindow_MetaObjectDefault(void* ptr)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QRasterWindow*>(ptr)->QRasterWindow::metaObject());
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::metaObject());
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::metaObject());
} else {
return const_cast<QMetaObject*>(static_cast<QWindow*>(ptr)->QWindow::metaObject());
}
}
int QWindow_Height(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->height();
} else {
return static_cast<QWindow*>(ptr)->height();
}
}
int QWindow_MaximumHeight(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->maximumHeight();
} else {
return static_cast<QWindow*>(ptr)->maximumHeight();
}
}
int QWindow_MaximumWidth(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->maximumWidth();
} else {
return static_cast<QWindow*>(ptr)->maximumWidth();
}
}
int QWindow_MinimumHeight(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->minimumHeight();
} else {
return static_cast<QWindow*>(ptr)->minimumHeight();
}
}
int QWindow_MinimumWidth(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->minimumWidth();
} else {
return static_cast<QWindow*>(ptr)->minimumWidth();
}
}
int QWindow_Width(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->width();
} else {
return static_cast<QWindow*>(ptr)->width();
}
}
int QWindow_X(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->x();
} else {
return static_cast<QWindow*>(ptr)->x();
}
}
int QWindow_Y(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->y();
} else {
return static_cast<QWindow*>(ptr)->y();
}
}
double QWindow_DevicePixelRatio(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->devicePixelRatio();
} else {
return static_cast<QWindow*>(ptr)->devicePixelRatio();
}
}
double QWindow_Opacity(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return static_cast<QPaintDeviceWindow*>(ptr)->opacity();
} else {
return static_cast<QWindow*>(ptr)->opacity();
}
}
void* QWindow___dynamicPropertyNames_atList(void* ptr, int i)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
} else {
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
}
void QWindow___dynamicPropertyNames_setList(void* ptr, void* i)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
} else {
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
}
void* QWindow___dynamicPropertyNames_newList(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return new QList<QByteArray>();
} else {
return new QList<QByteArray>();
}
}
void* QWindow___findChildren_atList2(void* ptr, int i)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
} else {
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
}
void QWindow___findChildren_setList2(void* ptr, void* i)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
} else {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
}
void* QWindow___findChildren_newList2(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return new QList<QObject*>();
} else {
return new QList<QObject*>();
}
}
void* QWindow___findChildren_atList3(void* ptr, int i)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
} else {
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
}
void QWindow___findChildren_setList3(void* ptr, void* i)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
} else {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
}
void* QWindow___findChildren_newList3(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return new QList<QObject*>();
} else {
return new QList<QObject*>();
}
}
void* QWindow___findChildren_atList(void* ptr, int i)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
} else {
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
}
void QWindow___findChildren_setList(void* ptr, void* i)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
} else {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
}
}
void* QWindow___findChildren_newList(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return new QList<QObject*>();
} else {
return new QList<QObject*>();
}
}
void* QWindow___children_atList(void* ptr, int i)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
} else {
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
}
void QWindow___children_setList(void* ptr, void* i)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
} else {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
} else {
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
}
}
void* QWindow___children_newList(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
return new QList<QObject *>();
} else {
return new QList<QObject *>();
}
}
char QWindow_EventFilter(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QPaintDeviceWindow*>(ptr)->eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QPaintDeviceWindow*>(ptr)->eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QPaintDeviceWindow*>(ptr)->eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QPaintDeviceWindow*>(ptr)->eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QPaintDeviceWindow*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
} else {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QWindow*>(ptr)->eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QWindow*>(ptr)->eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QWindow*>(ptr)->eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QWindow*>(ptr)->eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QWindow*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
}
char QWindow_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QRasterWindow*>(ptr)->QRasterWindow::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QRasterWindow*>(ptr)->QRasterWindow::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QRasterWindow*>(ptr)->QRasterWindow::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QRasterWindow*>(ptr)->QRasterWindow::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QRasterWindow*>(ptr)->QRasterWindow::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
} else {
if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
return static_cast<QWindow*>(ptr)->QWindow::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QWindow*>(ptr)->QWindow::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
return static_cast<QWindow*>(ptr)->QWindow::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
return static_cast<QWindow*>(ptr)->QWindow::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QWindow*>(ptr)->QWindow::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
}
void QWindow_ChildEvent(void* ptr, void* event)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
} else {
static_cast<QWindow*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}
}
void QWindow_ChildEventDefault(void* ptr, void* event)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::childEvent(static_cast<QChildEvent*>(event));
} else {
static_cast<QWindow*>(ptr)->QWindow::childEvent(static_cast<QChildEvent*>(event));
}
}
void QWindow_ConnectNotify(void* ptr, void* sign)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
} else {
static_cast<QWindow*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}
}
void QWindow_ConnectNotifyDefault(void* ptr, void* sign)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::connectNotify(*static_cast<QMetaMethod*>(sign));
} else {
static_cast<QWindow*>(ptr)->QWindow::connectNotify(*static_cast<QMetaMethod*>(sign));
}
}
void QWindow_CustomEvent(void* ptr, void* event)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->customEvent(static_cast<QEvent*>(event));
} else {
static_cast<QWindow*>(ptr)->customEvent(static_cast<QEvent*>(event));
}
}
void QWindow_CustomEventDefault(void* ptr, void* event)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::customEvent(static_cast<QEvent*>(event));
} else {
static_cast<QWindow*>(ptr)->QWindow::customEvent(static_cast<QEvent*>(event));
}
}
void QWindow_DeleteLater(void* ptr)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "deleteLater");
} else {
QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "deleteLater");
}
}
void QWindow_DeleteLaterDefault(void* ptr)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::deleteLater();
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::deleteLater();
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::deleteLater();
} else {
static_cast<QWindow*>(ptr)->QWindow::deleteLater();
}
}
void QWindow_DisconnectNotify(void* ptr, void* sign)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else {
static_cast<QWindow*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
}
void QWindow_DisconnectNotifyDefault(void* ptr, void* sign)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else {
static_cast<QWindow*>(ptr)->QWindow::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
}
void QWindow_TimerEvent(void* ptr, void* event)
{
if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
} else {
static_cast<QWindow*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}
}
void QWindow_TimerEventDefault(void* ptr, void* event)
{
if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QRasterWindow*>(ptr)->QRasterWindow::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QOpenGLWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QOpenGLWindow*>(ptr)->QOpenGLWindow::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::timerEvent(static_cast<QTimerEvent*>(event));
} else {
static_cast<QWindow*>(ptr)->QWindow::timerEvent(static_cast<QTimerEvent*>(event));
}
}
class MyQWindowStateChangeEvent: public QWindowStateChangeEvent
{
public:
};
long long QWindowStateChangeEvent_OldState(void* ptr)
{
return static_cast<QWindowStateChangeEvent*>(ptr)->oldState();
}
Reference in a new issue View git blame Copy permalink