|
|
#include <PythonQt.h>
|
|
|
#include <QIconEngine>
|
|
|
#include <QImage>
|
|
|
#include <QObject>
|
|
|
#include <QPixmap>
|
|
|
#include <QVariant>
|
|
|
#include <qaction.h>
|
|
|
#include <qbitmap.h>
|
|
|
#include <qbytearray.h>
|
|
|
#include <qcolor.h>
|
|
|
#include <qcoreevent.h>
|
|
|
#include <qcursor.h>
|
|
|
#include <qevent.h>
|
|
|
#include <qfont.h>
|
|
|
#include <qgenericmatrix.h>
|
|
|
#include <qgl.h>
|
|
|
#include <qglbuffer.h>
|
|
|
#include <qglcolormap.h>
|
|
|
#include <qglframebufferobject.h>
|
|
|
#include <qglfunctions.h>
|
|
|
#include <qglpixelbuffer.h>
|
|
|
#include <qglshaderprogram.h>
|
|
|
#include <qgraphicseffect.h>
|
|
|
#include <qgraphicsproxywidget.h>
|
|
|
#include <qimage.h>
|
|
|
#include <qkeysequence.h>
|
|
|
#include <qlayout.h>
|
|
|
#include <qlist.h>
|
|
|
#include <qlocale.h>
|
|
|
#include <qmargins.h>
|
|
|
#include <qmatrix4x4.h>
|
|
|
#include <qobject.h>
|
|
|
#include <qpaintdevice.h>
|
|
|
#include <qpaintengine.h>
|
|
|
#include <qpainter.h>
|
|
|
#include <qpalette.h>
|
|
|
#include <qpixmap.h>
|
|
|
#include <qpoint.h>
|
|
|
#include <qrect.h>
|
|
|
#include <qregion.h>
|
|
|
#include <qsize.h>
|
|
|
#include <qsizepolicy.h>
|
|
|
#include <qstyle.h>
|
|
|
#include <qtransform.h>
|
|
|
#include <qvector2d.h>
|
|
|
#include <qvector3d.h>
|
|
|
#include <qvector4d.h>
|
|
|
#include <qwidget.h>
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_QGLBuffer : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(Type UsagePattern Access )
|
|
|
enum Type{
|
|
|
VertexBuffer = QGLBuffer::VertexBuffer, IndexBuffer = QGLBuffer::IndexBuffer, PixelPackBuffer = QGLBuffer::PixelPackBuffer, PixelUnpackBuffer = QGLBuffer::PixelUnpackBuffer};
|
|
|
enum UsagePattern{
|
|
|
StreamDraw = QGLBuffer::StreamDraw, StreamRead = QGLBuffer::StreamRead, StreamCopy = QGLBuffer::StreamCopy, StaticDraw = QGLBuffer::StaticDraw, StaticRead = QGLBuffer::StaticRead, StaticCopy = QGLBuffer::StaticCopy, DynamicDraw = QGLBuffer::DynamicDraw, DynamicRead = QGLBuffer::DynamicRead, DynamicCopy = QGLBuffer::DynamicCopy};
|
|
|
enum Access{
|
|
|
ReadOnly = QGLBuffer::ReadOnly, WriteOnly = QGLBuffer::WriteOnly, ReadWrite = QGLBuffer::ReadWrite};
|
|
|
public slots:
|
|
|
QGLBuffer* new_QGLBuffer();
|
|
|
QGLBuffer* new_QGLBuffer(QGLBuffer::Type type);
|
|
|
QGLBuffer* new_QGLBuffer(const QGLBuffer& other);
|
|
|
void delete_QGLBuffer(QGLBuffer* obj) { delete obj; }
|
|
|
void allocate(QGLBuffer* theWrappedObject, const void* data, int count);
|
|
|
void allocate(QGLBuffer* theWrappedObject, int count);
|
|
|
bool bind(QGLBuffer* theWrappedObject);
|
|
|
bool create(QGLBuffer* theWrappedObject);
|
|
|
void destroy(QGLBuffer* theWrappedObject);
|
|
|
bool isCreated(QGLBuffer* theWrappedObject) const;
|
|
|
void* map(QGLBuffer* theWrappedObject, QGLBuffer::Access access);
|
|
|
QGLBuffer* operator_assign(QGLBuffer* theWrappedObject, const QGLBuffer& other);
|
|
|
bool read(QGLBuffer* theWrappedObject, int offset, void* data, int count);
|
|
|
void release(QGLBuffer* theWrappedObject);
|
|
|
void static_QGLBuffer_release(QGLBuffer::Type type);
|
|
|
void setUsagePattern(QGLBuffer* theWrappedObject, QGLBuffer::UsagePattern value);
|
|
|
int size(QGLBuffer* theWrappedObject) const;
|
|
|
QGLBuffer::Type type(QGLBuffer* theWrappedObject) const;
|
|
|
bool unmap(QGLBuffer* theWrappedObject);
|
|
|
QGLBuffer::UsagePattern usagePattern(QGLBuffer* theWrappedObject) const;
|
|
|
void write(QGLBuffer* theWrappedObject, int offset, const void* data, int count);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QGLColormap : public QGLColormap
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QGLColormap():QGLColormap(),_wrapper(NULL) {};
|
|
|
PythonQtShell_QGLColormap(const QGLColormap& arg__1):QGLColormap(arg__1),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QGLColormap();
|
|
|
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QGLColormap : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QGLColormap* new_QGLColormap();
|
|
|
QGLColormap* new_QGLColormap(const QGLColormap& arg__1);
|
|
|
void delete_QGLColormap(QGLColormap* obj) { delete obj; }
|
|
|
QColor entryColor(QGLColormap* theWrappedObject, int idx) const;
|
|
|
unsigned int entryRgb(QGLColormap* theWrappedObject, int idx) const;
|
|
|
int find(QGLColormap* theWrappedObject, unsigned int color) const;
|
|
|
int findNearest(QGLColormap* theWrappedObject, unsigned int color) const;
|
|
|
bool isEmpty(QGLColormap* theWrappedObject) const;
|
|
|
void setEntries(QGLColormap* theWrappedObject, int count, const unsigned int* colors, int base = 0);
|
|
|
void setEntry(QGLColormap* theWrappedObject, int idx, const QColor& color);
|
|
|
void setEntry(QGLColormap* theWrappedObject, int idx, unsigned int color);
|
|
|
int size(QGLColormap* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QGLContext : public QGLContext
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QGLContext(const QGLFormat& format):QGLContext(format),_wrapper(NULL) {};
|
|
|
PythonQtShell_QGLContext(const QGLFormat& format, QPaintDevice* device):QGLContext(format, device),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QGLContext();
|
|
|
|
|
|
virtual bool chooseContext(const QGLContext* shareContext = 0);
|
|
|
virtual bool create(const QGLContext* shareContext = 0);
|
|
|
virtual void doneCurrent();
|
|
|
virtual void makeCurrent();
|
|
|
virtual void swapBuffers() const;
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QGLContext : public QGLContext
|
|
|
{ public:
|
|
|
inline bool promoted_chooseContext(const QGLContext* shareContext = 0) { return QGLContext::chooseContext(shareContext); }
|
|
|
inline bool promoted_create(const QGLContext* shareContext = 0) { return QGLContext::create(shareContext); }
|
|
|
inline void promoted_doneCurrent() { QGLContext::doneCurrent(); }
|
|
|
inline void promoted_makeCurrent() { QGLContext::makeCurrent(); }
|
|
|
inline void promoted_swapBuffers() const { QGLContext::swapBuffers(); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QGLContext : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(BindOption )
|
|
|
Q_FLAGS(BindOptions )
|
|
|
enum BindOption{
|
|
|
NoBindOption = QGLContext::NoBindOption, InvertedYBindOption = QGLContext::InvertedYBindOption, MipmapBindOption = QGLContext::MipmapBindOption, PremultipliedAlphaBindOption = QGLContext::PremultipliedAlphaBindOption, LinearFilteringBindOption = QGLContext::LinearFilteringBindOption, MemoryManagedBindOption = QGLContext::MemoryManagedBindOption, CanFlipNativePixmapBindOption = QGLContext::CanFlipNativePixmapBindOption, TemporarilyCachedBindOption = QGLContext::TemporarilyCachedBindOption, DefaultBindOption = QGLContext::DefaultBindOption, InternalBindOption = QGLContext::InternalBindOption};
|
|
|
Q_DECLARE_FLAGS(BindOptions, BindOption)
|
|
|
public slots:
|
|
|
QGLContext* new_QGLContext(const QGLFormat& format);
|
|
|
QGLContext* new_QGLContext(const QGLFormat& format, QPaintDevice* device);
|
|
|
void delete_QGLContext(QGLContext* obj) { delete obj; }
|
|
|
bool static_QGLContext_areSharing(const QGLContext* context1, const QGLContext* context2);
|
|
|
bool chooseContext(QGLContext* theWrappedObject, const QGLContext* shareContext = 0);
|
|
|
bool create(QGLContext* theWrappedObject, const QGLContext* shareContext = 0);
|
|
|
const QGLContext* static_QGLContext_currentContext();
|
|
|
QPaintDevice* device(QGLContext* theWrappedObject) const;
|
|
|
void doneCurrent(QGLContext* theWrappedObject);
|
|
|
QGLFormat format(QGLContext* theWrappedObject) const;
|
|
|
QGLFunctions* functions(QGLContext* theWrappedObject) const;
|
|
|
bool isSharing(QGLContext* theWrappedObject) const;
|
|
|
bool isValid(QGLContext* theWrappedObject) const;
|
|
|
void makeCurrent(QGLContext* theWrappedObject);
|
|
|
void moveToThread(QGLContext* theWrappedObject, QThread* thread);
|
|
|
QColor overlayTransparentColor(QGLContext* theWrappedObject) const;
|
|
|
QGLFormat requestedFormat(QGLContext* theWrappedObject) const;
|
|
|
void reset(QGLContext* theWrappedObject);
|
|
|
void setFormat(QGLContext* theWrappedObject, const QGLFormat& format);
|
|
|
void static_QGLContext_setTextureCacheLimit(int size);
|
|
|
void swapBuffers(QGLContext* theWrappedObject) const;
|
|
|
int static_QGLContext_textureCacheLimit();
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QGLFramebufferObject : public QGLFramebufferObject
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QGLFramebufferObject(const QSize& size, const QGLFramebufferObjectFormat& format):QGLFramebufferObject(size, format),_wrapper(NULL) {};
|
|
|
PythonQtShell_QGLFramebufferObject(int width, int height, const QGLFramebufferObjectFormat& format):QGLFramebufferObject(width, height, format),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QGLFramebufferObject();
|
|
|
|
|
|
virtual int devType() const;
|
|
|
virtual void initPainter(QPainter* painter) const;
|
|
|
virtual int metric(QPaintDevice::PaintDeviceMetric metric) const;
|
|
|
virtual QPaintEngine* paintEngine() const;
|
|
|
virtual QPaintDevice* redirected(QPoint* offset) const;
|
|
|
virtual QPainter* sharedPainter() const;
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QGLFramebufferObject : public QGLFramebufferObject
|
|
|
{ public:
|
|
|
inline int promoted_devType() const { return QGLFramebufferObject::devType(); }
|
|
|
inline int promoted_metric(QPaintDevice::PaintDeviceMetric metric) const { return QGLFramebufferObject::metric(metric); }
|
|
|
inline QPaintEngine* promoted_paintEngine() const { return QGLFramebufferObject::paintEngine(); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QGLFramebufferObject : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(Attachment )
|
|
|
enum Attachment{
|
|
|
NoAttachment = QGLFramebufferObject::NoAttachment, CombinedDepthStencil = QGLFramebufferObject::CombinedDepthStencil, Depth = QGLFramebufferObject::Depth};
|
|
|
public slots:
|
|
|
QGLFramebufferObject* new_QGLFramebufferObject(const QSize& size, const QGLFramebufferObjectFormat& format);
|
|
|
QGLFramebufferObject* new_QGLFramebufferObject(int width, int height, const QGLFramebufferObjectFormat& format);
|
|
|
void delete_QGLFramebufferObject(QGLFramebufferObject* obj) { delete obj; }
|
|
|
QGLFramebufferObject::Attachment attachment(QGLFramebufferObject* theWrappedObject) const;
|
|
|
bool bind(QGLFramebufferObject* theWrappedObject);
|
|
|
bool static_QGLFramebufferObject_bindDefault();
|
|
|
int devType(QGLFramebufferObject* theWrappedObject) const;
|
|
|
QGLFramebufferObjectFormat format(QGLFramebufferObject* theWrappedObject) const;
|
|
|
bool static_QGLFramebufferObject_hasOpenGLFramebufferBlit();
|
|
|
bool static_QGLFramebufferObject_hasOpenGLFramebufferObjects();
|
|
|
bool isBound(QGLFramebufferObject* theWrappedObject) const;
|
|
|
bool isValid(QGLFramebufferObject* theWrappedObject) const;
|
|
|
int metric(QGLFramebufferObject* theWrappedObject, QPaintDevice::PaintDeviceMetric metric) const;
|
|
|
QPaintEngine* paintEngine(QGLFramebufferObject* theWrappedObject) const;
|
|
|
bool release(QGLFramebufferObject* theWrappedObject);
|
|
|
QSize size(QGLFramebufferObject* theWrappedObject) const;
|
|
|
QImage toImage(QGLFramebufferObject* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_QGLFramebufferObjectFormat : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QGLFramebufferObjectFormat* new_QGLFramebufferObjectFormat();
|
|
|
QGLFramebufferObjectFormat* new_QGLFramebufferObjectFormat(const QGLFramebufferObjectFormat& other);
|
|
|
void delete_QGLFramebufferObjectFormat(QGLFramebufferObjectFormat* obj) { delete obj; }
|
|
|
QGLFramebufferObject::Attachment attachment(QGLFramebufferObjectFormat* theWrappedObject) const;
|
|
|
bool mipmap(QGLFramebufferObjectFormat* theWrappedObject) const;
|
|
|
bool __ne__(QGLFramebufferObjectFormat* theWrappedObject, const QGLFramebufferObjectFormat& other) const;
|
|
|
QGLFramebufferObjectFormat* operator_assign(QGLFramebufferObjectFormat* theWrappedObject, const QGLFramebufferObjectFormat& other);
|
|
|
bool __eq__(QGLFramebufferObjectFormat* theWrappedObject, const QGLFramebufferObjectFormat& other) const;
|
|
|
int samples(QGLFramebufferObjectFormat* theWrappedObject) const;
|
|
|
void setAttachment(QGLFramebufferObjectFormat* theWrappedObject, QGLFramebufferObject::Attachment attachment);
|
|
|
void setMipmap(QGLFramebufferObjectFormat* theWrappedObject, bool enabled);
|
|
|
void setSamples(QGLFramebufferObjectFormat* theWrappedObject, int samples);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_QGLFunctions : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(OpenGLFeature )
|
|
|
enum OpenGLFeature{
|
|
|
Multitexture = QGLFunctions::Multitexture, Shaders = QGLFunctions::Shaders, Buffers = QGLFunctions::Buffers, Framebuffers = QGLFunctions::Framebuffers, BlendColor = QGLFunctions::BlendColor, BlendEquation = QGLFunctions::BlendEquation, BlendEquationSeparate = QGLFunctions::BlendEquationSeparate, BlendFuncSeparate = QGLFunctions::BlendFuncSeparate, BlendSubtract = QGLFunctions::BlendSubtract, CompressedTextures = QGLFunctions::CompressedTextures, Multisample = QGLFunctions::Multisample, StencilSeparate = QGLFunctions::StencilSeparate, NPOTTextures = QGLFunctions::NPOTTextures};
|
|
|
public slots:
|
|
|
QGLFunctions* new_QGLFunctions();
|
|
|
QGLFunctions* new_QGLFunctions(const QGLContext* context);
|
|
|
void delete_QGLFunctions(QGLFunctions* obj) { delete obj; }
|
|
|
void glReleaseShaderCompiler(QGLFunctions* theWrappedObject);
|
|
|
bool hasOpenGLFeature(QGLFunctions* theWrappedObject, QGLFunctions::OpenGLFeature feature) const;
|
|
|
void initializeGLFunctions(QGLFunctions* theWrappedObject, const QGLContext* context = 0);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QGLPixelBuffer : public QGLPixelBuffer
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QGLPixelBuffer(const QSize& size, const QGLFormat& format = QGLFormat::defaultFormat(), QGLWidget* shareWidget = 0):QGLPixelBuffer(size, format, shareWidget),_wrapper(NULL) {};
|
|
|
PythonQtShell_QGLPixelBuffer(int width, int height, const QGLFormat& format = QGLFormat::defaultFormat(), QGLWidget* shareWidget = 0):QGLPixelBuffer(width, height, format, shareWidget),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QGLPixelBuffer();
|
|
|
|
|
|
virtual int devType() const;
|
|
|
virtual void initPainter(QPainter* painter) const;
|
|
|
virtual int metric(QPaintDevice::PaintDeviceMetric metric) const;
|
|
|
virtual QPaintEngine* paintEngine() const;
|
|
|
virtual QPaintDevice* redirected(QPoint* offset) const;
|
|
|
virtual QPainter* sharedPainter() const;
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QGLPixelBuffer : public QGLPixelBuffer
|
|
|
{ public:
|
|
|
inline int promoted_devType() const { return QGLPixelBuffer::devType(); }
|
|
|
inline int promoted_metric(QPaintDevice::PaintDeviceMetric metric) const { return QGLPixelBuffer::metric(metric); }
|
|
|
inline QPaintEngine* promoted_paintEngine() const { return QGLPixelBuffer::paintEngine(); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QGLPixelBuffer : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QGLPixelBuffer* new_QGLPixelBuffer(const QSize& size, const QGLFormat& format = QGLFormat::defaultFormat(), QGLWidget* shareWidget = 0);
|
|
|
QGLPixelBuffer* new_QGLPixelBuffer(int width, int height, const QGLFormat& format = QGLFormat::defaultFormat(), QGLWidget* shareWidget = 0);
|
|
|
void delete_QGLPixelBuffer(QGLPixelBuffer* obj) { delete obj; }
|
|
|
QGLContext* context(QGLPixelBuffer* theWrappedObject) const;
|
|
|
int devType(QGLPixelBuffer* theWrappedObject) const;
|
|
|
bool doneCurrent(QGLPixelBuffer* theWrappedObject);
|
|
|
QGLFormat format(QGLPixelBuffer* theWrappedObject) const;
|
|
|
Qt::HANDLE handle(QGLPixelBuffer* theWrappedObject) const;
|
|
|
bool static_QGLPixelBuffer_hasOpenGLPbuffers();
|
|
|
bool isValid(QGLPixelBuffer* theWrappedObject) const;
|
|
|
bool makeCurrent(QGLPixelBuffer* theWrappedObject);
|
|
|
int metric(QGLPixelBuffer* theWrappedObject, QPaintDevice::PaintDeviceMetric metric) const;
|
|
|
QPaintEngine* paintEngine(QGLPixelBuffer* theWrappedObject) const;
|
|
|
void releaseFromDynamicTexture(QGLPixelBuffer* theWrappedObject);
|
|
|
QSize size(QGLPixelBuffer* theWrappedObject) const;
|
|
|
QImage toImage(QGLPixelBuffer* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QGLShader : public QGLShader
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QGLShader(QGLShader::ShaderType type, QObject* parent = 0):QGLShader(type, parent),_wrapper(NULL) {};
|
|
|
PythonQtShell_QGLShader(QGLShader::ShaderType type, const QGLContext* context, QObject* parent = 0):QGLShader(type, context, parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QGLShader();
|
|
|
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
|
virtual void customEvent(QEvent* arg__1);
|
|
|
virtual bool event(QEvent* arg__1);
|
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QGLShader : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(ShaderTypeBit )
|
|
|
Q_FLAGS(ShaderType )
|
|
|
enum ShaderTypeBit{
|
|
|
Vertex = QGLShader::Vertex, Fragment = QGLShader::Fragment, Geometry = QGLShader::Geometry};
|
|
|
Q_DECLARE_FLAGS(ShaderType, ShaderTypeBit)
|
|
|
public slots:
|
|
|
QGLShader* new_QGLShader(QGLShader::ShaderType type, QObject* parent = 0);
|
|
|
QGLShader* new_QGLShader(QGLShader::ShaderType type, const QGLContext* context, QObject* parent = 0);
|
|
|
void delete_QGLShader(QGLShader* obj) { delete obj; }
|
|
|
bool compileSourceCode(QGLShader* theWrappedObject, const QByteArray& source);
|
|
|
bool compileSourceCode(QGLShader* theWrappedObject, const QString& source);
|
|
|
bool compileSourceCode(QGLShader* theWrappedObject, const char* source);
|
|
|
bool compileSourceFile(QGLShader* theWrappedObject, const QString& fileName);
|
|
|
bool static_QGLShader_hasOpenGLShaders(QGLShader::ShaderType type, const QGLContext* context = 0);
|
|
|
bool isCompiled(QGLShader* theWrappedObject) const;
|
|
|
QString log(QGLShader* theWrappedObject) const;
|
|
|
QGLShader::ShaderType shaderType(QGLShader* theWrappedObject) const;
|
|
|
QByteArray sourceCode(QGLShader* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QGLShaderProgram : public QGLShaderProgram
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QGLShaderProgram(QObject* parent = 0):QGLShaderProgram(parent),_wrapper(NULL) {};
|
|
|
PythonQtShell_QGLShaderProgram(const QGLContext* context, QObject* parent = 0):QGLShaderProgram(context, parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QGLShaderProgram();
|
|
|
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
|
virtual void customEvent(QEvent* arg__1);
|
|
|
virtual bool event(QEvent* arg__1);
|
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
|
virtual bool link();
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QGLShaderProgram : public QGLShaderProgram
|
|
|
{ public:
|
|
|
inline bool promoted_link() { return QGLShaderProgram::link(); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QGLShaderProgram : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QGLShaderProgram* new_QGLShaderProgram(QObject* parent = 0);
|
|
|
QGLShaderProgram* new_QGLShaderProgram(const QGLContext* context, QObject* parent = 0);
|
|
|
void delete_QGLShaderProgram(QGLShaderProgram* obj) { delete obj; }
|
|
|
bool addShader(QGLShaderProgram* theWrappedObject, QGLShader* shader);
|
|
|
bool addShaderFromSourceCode(QGLShaderProgram* theWrappedObject, QGLShader::ShaderType type, const QByteArray& source);
|
|
|
bool addShaderFromSourceCode(QGLShaderProgram* theWrappedObject, QGLShader::ShaderType type, const QString& source);
|
|
|
bool addShaderFromSourceCode(QGLShaderProgram* theWrappedObject, QGLShader::ShaderType type, const char* source);
|
|
|
bool addShaderFromSourceFile(QGLShaderProgram* theWrappedObject, QGLShader::ShaderType type, const QString& fileName);
|
|
|
int attributeLocation(QGLShaderProgram* theWrappedObject, const QByteArray& name) const;
|
|
|
int attributeLocation(QGLShaderProgram* theWrappedObject, const QString& name) const;
|
|
|
int attributeLocation(QGLShaderProgram* theWrappedObject, const char* name) const;
|
|
|
bool bind(QGLShaderProgram* theWrappedObject);
|
|
|
void bindAttributeLocation(QGLShaderProgram* theWrappedObject, const QByteArray& name, int location);
|
|
|
void bindAttributeLocation(QGLShaderProgram* theWrappedObject, const QString& name, int location);
|
|
|
void bindAttributeLocation(QGLShaderProgram* theWrappedObject, const char* name, int location);
|
|
|
void disableAttributeArray(QGLShaderProgram* theWrappedObject, const char* name);
|
|
|
void disableAttributeArray(QGLShaderProgram* theWrappedObject, int location);
|
|
|
void enableAttributeArray(QGLShaderProgram* theWrappedObject, const char* name);
|
|
|
void enableAttributeArray(QGLShaderProgram* theWrappedObject, int location);
|
|
|
int geometryOutputVertexCount(QGLShaderProgram* theWrappedObject) const;
|
|
|
bool static_QGLShaderProgram_hasOpenGLShaderPrograms(const QGLContext* context = 0);
|
|
|
bool isLinked(QGLShaderProgram* theWrappedObject) const;
|
|
|
bool link(QGLShaderProgram* theWrappedObject);
|
|
|
QString log(QGLShaderProgram* theWrappedObject) const;
|
|
|
int maxGeometryOutputVertices(QGLShaderProgram* theWrappedObject) const;
|
|
|
void release(QGLShaderProgram* theWrappedObject);
|
|
|
void removeAllShaders(QGLShaderProgram* theWrappedObject);
|
|
|
void removeShader(QGLShaderProgram* theWrappedObject, QGLShader* shader);
|
|
|
void setAttributeArray(QGLShaderProgram* theWrappedObject, const char* name, const QVector2D* values, int stride = 0);
|
|
|
void setAttributeArray(QGLShaderProgram* theWrappedObject, const char* name, const QVector3D* values, int stride = 0);
|
|
|
void setAttributeArray(QGLShaderProgram* theWrappedObject, const char* name, const QVector4D* values, int stride = 0);
|
|
|
void setAttributeArray(QGLShaderProgram* theWrappedObject, int location, const QVector2D* values, int stride = 0);
|
|
|
void setAttributeArray(QGLShaderProgram* theWrappedObject, int location, const QVector3D* values, int stride = 0);
|
|
|
void setAttributeArray(QGLShaderProgram* theWrappedObject, int location, const QVector4D* values, int stride = 0);
|
|
|
void setAttributeValue(QGLShaderProgram* theWrappedObject, const char* name, const QColor& value);
|
|
|
void setAttributeValue(QGLShaderProgram* theWrappedObject, const char* name, const QVector2D& value);
|
|
|
void setAttributeValue(QGLShaderProgram* theWrappedObject, const char* name, const QVector3D& value);
|
|
|
void setAttributeValue(QGLShaderProgram* theWrappedObject, const char* name, const QVector4D& value);
|
|
|
void setAttributeValue(QGLShaderProgram* theWrappedObject, int location, const QColor& value);
|
|
|
void setAttributeValue(QGLShaderProgram* theWrappedObject, int location, const QVector2D& value);
|
|
|
void setAttributeValue(QGLShaderProgram* theWrappedObject, int location, const QVector3D& value);
|
|
|
void setAttributeValue(QGLShaderProgram* theWrappedObject, int location, const QVector4D& value);
|
|
|
void setGeometryOutputVertexCount(QGLShaderProgram* theWrappedObject, int count);
|
|
|
void setUniformValue(QGLShaderProgram* theWrappedObject, const char* name, const QColor& color);
|
|
|
void setUniformValue(QGLShaderProgram* theWrappedObject, const char* name, const QMatrix3x3& value);
|
|
|
void setUniformValue(QGLShaderProgram* theWrappedObject, const char* name, const QMatrix4x4& value);
|
|
|
void setUniformValue(QGLShaderProgram* theWrappedObject, const char* name, const QPoint& point);
|
|
|
void setUniformValue(QGLShaderProgram* theWrappedObject, const char* name, const QPointF& point);
|
|
|
void setUniformValue(QGLShaderProgram* theWrappedObject, const char* name, const QSize& size);
|
|
|
void setUniformValue(QGLShaderProgram* theWrappedObject, const char* name, const QSizeF& size);
|
|
|
void setUniformValue(QGLShaderProgram* theWrappedObject, const char* name, const QTransform& value);
|
|
|
void setUniformValue(QGLShaderProgram* theWrappedObject, const char* name, const QVector2D& value);
|
|
|
void setUniformValue(QGLShaderProgram* theWrappedObject, const char* name, const QVector3D& value);
|
|
|
void setUniformValue(QGLShaderProgram* theWrappedObject, const char* name, const QVector4D& value);
|
|
|
void setUniformValue(QGLShaderProgram* theWrappedObject, int location, const QColor& color);
|
|
|
void setUniformValue(QGLShaderProgram* theWrappedObject, int location, const QMatrix3x3& value);
|
|
|
void setUniformValue(QGLShaderProgram* theWrappedObject, int location, const QMatrix4x4& value);
|
|
|
void setUniformValue(QGLShaderProgram* theWrappedObject, int location, const QPoint& point);
|
|
|
void setUniformValue(QGLShaderProgram* theWrappedObject, int location, const QPointF& point);
|
|
|
void setUniformValue(QGLShaderProgram* theWrappedObject, int location, const QSize& size);
|
|
|
void setUniformValue(QGLShaderProgram* theWrappedObject, int location, const QSizeF& size);
|
|
|
void setUniformValue(QGLShaderProgram* theWrappedObject, int location, const QTransform& value);
|
|
|
void setUniformValue(QGLShaderProgram* theWrappedObject, int location, const QVector2D& value);
|
|
|
void setUniformValue(QGLShaderProgram* theWrappedObject, int location, const QVector3D& value);
|
|
|
void setUniformValue(QGLShaderProgram* theWrappedObject, int location, const QVector4D& value);
|
|
|
void setUniformValueArray(QGLShaderProgram* theWrappedObject, const char* name, const QMatrix3x3* values, int count);
|
|
|
void setUniformValueArray(QGLShaderProgram* theWrappedObject, const char* name, const QMatrix4x4* values, int count);
|
|
|
void setUniformValueArray(QGLShaderProgram* theWrappedObject, const char* name, const QVector2D* values, int count);
|
|
|
void setUniformValueArray(QGLShaderProgram* theWrappedObject, const char* name, const QVector3D* values, int count);
|
|
|
void setUniformValueArray(QGLShaderProgram* theWrappedObject, const char* name, const QVector4D* values, int count);
|
|
|
void setUniformValueArray(QGLShaderProgram* theWrappedObject, int location, const QMatrix3x3* values, int count);
|
|
|
void setUniformValueArray(QGLShaderProgram* theWrappedObject, int location, const QMatrix4x4* values, int count);
|
|
|
void setUniformValueArray(QGLShaderProgram* theWrappedObject, int location, const QVector2D* values, int count);
|
|
|
void setUniformValueArray(QGLShaderProgram* theWrappedObject, int location, const QVector3D* values, int count);
|
|
|
void setUniformValueArray(QGLShaderProgram* theWrappedObject, int location, const QVector4D* values, int count);
|
|
|
QList<QGLShader* > shaders(QGLShaderProgram* theWrappedObject) const;
|
|
|
int uniformLocation(QGLShaderProgram* theWrappedObject, const QByteArray& name) const;
|
|
|
int uniformLocation(QGLShaderProgram* theWrappedObject, const QString& name) const;
|
|
|
int uniformLocation(QGLShaderProgram* theWrappedObject, const char* name) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QGLWidget : public QGLWidget
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QGLWidget(QGLContext* context, QWidget* parent = 0, const QGLWidget* shareWidget = 0, Qt::WindowFlags f = 0):QGLWidget(context, parent, shareWidget, f),_wrapper(NULL) {};
|
|
|
PythonQtShell_QGLWidget(QWidget* parent = 0, const QGLWidget* shareWidget = 0, Qt::WindowFlags f = 0):QGLWidget(parent, shareWidget, f),_wrapper(NULL) {};
|
|
|
PythonQtShell_QGLWidget(const QGLFormat& format, QWidget* parent = 0, const QGLWidget* shareWidget = 0, Qt::WindowFlags f = 0):QGLWidget(format, parent, shareWidget, f),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QGLWidget();
|
|
|
|
|
|
virtual void actionEvent(QActionEvent* arg__1);
|
|
|
virtual void changeEvent(QEvent* arg__1);
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
|
virtual void closeEvent(QCloseEvent* arg__1);
|
|
|
virtual void contextMenuEvent(QContextMenuEvent* arg__1);
|
|
|
virtual void customEvent(QEvent* arg__1);
|
|
|
virtual int devType() const;
|
|
|
virtual void dragEnterEvent(QDragEnterEvent* arg__1);
|
|
|
virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
|
|
|
virtual void dragMoveEvent(QDragMoveEvent* arg__1);
|
|
|
virtual void dropEvent(QDropEvent* arg__1);
|
|
|
virtual void enterEvent(QEvent* arg__1);
|
|
|
virtual bool event(QEvent* arg__1);
|
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
|
virtual void focusInEvent(QFocusEvent* arg__1);
|
|
|
virtual bool focusNextPrevChild(bool next);
|
|
|
virtual void focusOutEvent(QFocusEvent* arg__1);
|
|
|
virtual void glDraw();
|
|
|
virtual void glInit();
|
|
|
virtual bool hasHeightForWidth() const;
|
|
|
virtual int heightForWidth(int arg__1) const;
|
|
|
virtual void hideEvent(QHideEvent* arg__1);
|
|
|
virtual void initPainter(QPainter* painter) const;
|
|
|
virtual void initializeGL();
|
|
|
virtual void initializeOverlayGL();
|
|
|
virtual void inputMethodEvent(QInputMethodEvent* arg__1);
|
|
|
virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
|
|
|
virtual void keyPressEvent(QKeyEvent* arg__1);
|
|
|
virtual void keyReleaseEvent(QKeyEvent* arg__1);
|
|
|
virtual void leaveEvent(QEvent* arg__1);
|
|
|
virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
|
|
|
virtual QSize minimumSizeHint() const;
|
|
|
virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
|
|
|
virtual void mouseMoveEvent(QMouseEvent* arg__1);
|
|
|
virtual void mousePressEvent(QMouseEvent* arg__1);
|
|
|
virtual void mouseReleaseEvent(QMouseEvent* arg__1);
|
|
|
virtual void moveEvent(QMoveEvent* arg__1);
|
|
|
virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
|
|
|
virtual QPaintEngine* paintEngine() const;
|
|
|
virtual void paintEvent(QPaintEvent* arg__1);
|
|
|
virtual void paintGL();
|
|
|
virtual void paintOverlayGL();
|
|
|
virtual QPaintDevice* redirected(QPoint* offset) const;
|
|
|
virtual void resizeEvent(QResizeEvent* arg__1);
|
|
|
virtual void resizeGL(int w, int h);
|
|
|
virtual void resizeOverlayGL(int w, int h);
|
|
|
virtual QPainter* sharedPainter() const;
|
|
|
virtual void showEvent(QShowEvent* arg__1);
|
|
|
virtual QSize sizeHint() const;
|
|
|
virtual void tabletEvent(QTabletEvent* arg__1);
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
virtual void updateGL();
|
|
|
virtual void updateOverlayGL();
|
|
|
virtual void wheelEvent(QWheelEvent* arg__1);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QGLWidget : public QGLWidget
|
|
|
{ public:
|
|
|
inline bool promoted_event(QEvent* arg__1) { return QGLWidget::event(arg__1); }
|
|
|
inline void promoted_glDraw() { QGLWidget::glDraw(); }
|
|
|
inline void promoted_glInit() { QGLWidget::glInit(); }
|
|
|
inline void promoted_initializeGL() { QGLWidget::initializeGL(); }
|
|
|
inline void promoted_initializeOverlayGL() { QGLWidget::initializeOverlayGL(); }
|
|
|
inline QPaintEngine* promoted_paintEngine() const { return QGLWidget::paintEngine(); }
|
|
|
inline void promoted_paintEvent(QPaintEvent* arg__1) { QGLWidget::paintEvent(arg__1); }
|
|
|
inline void promoted_paintGL() { QGLWidget::paintGL(); }
|
|
|
inline void promoted_paintOverlayGL() { QGLWidget::paintOverlayGL(); }
|
|
|
inline void promoted_resizeEvent(QResizeEvent* arg__1) { QGLWidget::resizeEvent(arg__1); }
|
|
|
inline void promoted_resizeGL(int w, int h) { QGLWidget::resizeGL(w, h); }
|
|
|
inline void promoted_resizeOverlayGL(int w, int h) { QGLWidget::resizeOverlayGL(w, h); }
|
|
|
inline void promoted_updateGL() { QGLWidget::updateGL(); }
|
|
|
inline void promoted_updateOverlayGL() { QGLWidget::updateOverlayGL(); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QGLWidget : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QGLWidget* new_QGLWidget(QGLContext* context, QWidget* parent = 0, const QGLWidget* shareWidget = 0, Qt::WindowFlags f = 0);
|
|
|
QGLWidget* new_QGLWidget(QWidget* parent = 0, const QGLWidget* shareWidget = 0, Qt::WindowFlags f = 0);
|
|
|
QGLWidget* new_QGLWidget(const QGLFormat& format, QWidget* parent = 0, const QGLWidget* shareWidget = 0, Qt::WindowFlags f = 0);
|
|
|
void delete_QGLWidget(QGLWidget* obj) { delete obj; }
|
|
|
const QGLColormap* colormap(QGLWidget* theWrappedObject) const;
|
|
|
QGLContext* context(QGLWidget* theWrappedObject) const;
|
|
|
QImage static_QGLWidget_convertToGLFormat(const QImage& img);
|
|
|
void doneCurrent(QGLWidget* theWrappedObject);
|
|
|
bool doubleBuffer(QGLWidget* theWrappedObject) const;
|
|
|
bool event(QGLWidget* theWrappedObject, QEvent* arg__1);
|
|
|
QGLFormat format(QGLWidget* theWrappedObject) const;
|
|
|
void glDraw(QGLWidget* theWrappedObject);
|
|
|
void glInit(QGLWidget* theWrappedObject);
|
|
|
QImage grabFrameBuffer(QGLWidget* theWrappedObject, bool withAlpha = false);
|
|
|
void initializeGL(QGLWidget* theWrappedObject);
|
|
|
void initializeOverlayGL(QGLWidget* theWrappedObject);
|
|
|
bool isSharing(QGLWidget* theWrappedObject) const;
|
|
|
bool isValid(QGLWidget* theWrappedObject) const;
|
|
|
void makeCurrent(QGLWidget* theWrappedObject);
|
|
|
void makeOverlayCurrent(QGLWidget* theWrappedObject);
|
|
|
const QGLContext* overlayContext(QGLWidget* theWrappedObject) const;
|
|
|
QPaintEngine* paintEngine(QGLWidget* theWrappedObject) const;
|
|
|
void paintEvent(QGLWidget* theWrappedObject, QPaintEvent* arg__1);
|
|
|
void paintGL(QGLWidget* theWrappedObject);
|
|
|
void paintOverlayGL(QGLWidget* theWrappedObject);
|
|
|
void qglClearColor(QGLWidget* theWrappedObject, const QColor& c) const;
|
|
|
void qglColor(QGLWidget* theWrappedObject, const QColor& c) const;
|
|
|
QPixmap renderPixmap(QGLWidget* theWrappedObject, int w = 0, int h = 0, bool useContext = false);
|
|
|
void renderText(QGLWidget* theWrappedObject, double x, double y, double z, const QString& str, const QFont& fnt = QFont());
|
|
|
void renderText(QGLWidget* theWrappedObject, int x, int y, const QString& str, const QFont& fnt = QFont());
|
|
|
void resizeEvent(QGLWidget* theWrappedObject, QResizeEvent* arg__1);
|
|
|
void resizeGL(QGLWidget* theWrappedObject, int w, int h);
|
|
|
void resizeOverlayGL(QGLWidget* theWrappedObject, int w, int h);
|
|
|
void setColormap(QGLWidget* theWrappedObject, const QGLColormap& map);
|
|
|
void swapBuffers(QGLWidget* theWrappedObject);
|
|
|
void updateGL(QGLWidget* theWrappedObject);
|
|
|
void updateOverlayGL(QGLWidget* theWrappedObject);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
