1106 lines
47 KiB
C++
1106 lines
47 KiB
C++
/***************************************************************************
|
|
**
|
|
** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the utilities of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 3 as published by the Free Software
|
|
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
|
|
** included in the packaging of this file. Please review the following
|
|
** information to ensure the GNU General Public License requirements will
|
|
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
#include "codegenerator.h"
|
|
|
|
#include <QDebug>
|
|
#include <QFile>
|
|
#include <QSettings>
|
|
#include <QTextStream>
|
|
|
|
static const QString extensionRegistryFileName = QStringLiteral("qopengl-extension-registry.ini");
|
|
static const QString extensionIdGroupName = QStringLiteral("ExtensionIds");
|
|
|
|
CodeGenerator::CodeGenerator()
|
|
: m_parser(0)
|
|
{
|
|
}
|
|
|
|
void CodeGenerator::generateCoreClasses(const QString &baseFileName) const
|
|
{
|
|
// Output header and implementation files for the backend and base class
|
|
writeCoreHelperClasses(baseFileName + QStringLiteral(".h"), Declaration);
|
|
writeCoreHelperClasses(baseFileName + QStringLiteral(".cpp"), Definition);
|
|
|
|
// Output the per-version and profile public classes
|
|
writeCoreClasses(baseFileName);
|
|
|
|
// We also need to generate a factory class that can be used by
|
|
// QOpenGLContext to actually create version function objects
|
|
writeCoreFactoryHeader(baseFileName + QStringLiteral("factory_p.h"));
|
|
writeCoreFactoryImplementation(baseFileName + QStringLiteral("factory.cpp"));
|
|
}
|
|
|
|
void CodeGenerator::generateExtensionClasses(const QString &baseFileName) const
|
|
{
|
|
writeExtensionHeader(baseFileName + QStringLiteral(".h"));
|
|
writeExtensionImplementation(baseFileName + QStringLiteral(".cpp"));
|
|
}
|
|
|
|
bool CodeGenerator::isLegacyVersion(Version v) const
|
|
{
|
|
return (v.major < 3 || (v.major == 3 && v.minor == 0));
|
|
}
|
|
|
|
bool CodeGenerator::versionHasProfiles(Version v) const
|
|
{
|
|
VersionProfile vp;
|
|
vp.version = v;
|
|
return vp.hasProfiles();
|
|
}
|
|
|
|
void CodeGenerator::writeCoreHelperClasses(const QString &fileName, ClassComponent component) const
|
|
{
|
|
if (!m_parser)
|
|
return;
|
|
|
|
QFile file(fileName);
|
|
if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
|
|
return;
|
|
QTextStream stream(&file);
|
|
|
|
// Write the preamble
|
|
writePreamble(fileName, stream);
|
|
|
|
// Iterate over each OpenGL version. For each version output a private class for
|
|
// core functions and a private class for deprecated functions.
|
|
const QString privateRootClass = QStringLiteral("QOpenGLVersionFunctionsBackend");
|
|
Q_FOREACH (const VersionProfile &versionProfile, m_parser->versionProfiles()) {
|
|
switch (component) {
|
|
case Declaration:
|
|
writeBackendClassDeclaration(stream, versionProfile, privateRootClass);
|
|
break;
|
|
|
|
case Definition:
|
|
writeBackendClassImplementation(stream, versionProfile, privateRootClass);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Write the postamble
|
|
writePostamble(fileName, stream);
|
|
}
|
|
|
|
void CodeGenerator::writeCoreClasses(const QString &baseFileName) const
|
|
{
|
|
// Iterate over each OpenGL version. For each version output a public class (for legacy
|
|
// versions or two public classes (for modern versions with profiles). Each public class
|
|
// is given pointers to private classes containing the actual entry points. For example,
|
|
// the class for OpenGL 1.1 will have pointers to the private classes for 1.0 core, 1.1
|
|
// core, 1.0 deprecated and 1.1 deprecated. Whereas the class for OpenGL 3.2 Core profile
|
|
// will have pointers to the private classes for 1.0 core, 1.1 core, ..., 3.2 core but
|
|
// not to any of the deprecated private classes
|
|
QList<ClassComponent> components = (QList<ClassComponent>() << Declaration << Definition);
|
|
Q_FOREACH (const ClassComponent &component, components) {
|
|
const QString rootClass = QStringLiteral("QAbstractOpenGLFunctions");
|
|
Q_FOREACH (const Version &classVersion, m_parser->versions()) {
|
|
VersionProfile v;
|
|
v.version = classVersion;
|
|
v.profile = VersionProfile::CompatibilityProfile;
|
|
|
|
if (isLegacyVersion(classVersion)) {
|
|
switch (component) {
|
|
case Declaration:
|
|
writePublicClassDeclaration(baseFileName, v, rootClass);
|
|
break;
|
|
|
|
case Definition:
|
|
writePublicClassImplementation(baseFileName, v, rootClass);
|
|
break;
|
|
}
|
|
} else {
|
|
switch (component) {
|
|
case Declaration:
|
|
writePublicClassDeclaration(baseFileName, v, rootClass);
|
|
v.profile = VersionProfile::CoreProfile;
|
|
writePublicClassDeclaration(baseFileName, v, rootClass);
|
|
break;
|
|
|
|
case Definition:
|
|
writePublicClassImplementation(baseFileName, v, rootClass);
|
|
v.profile = VersionProfile::CoreProfile;
|
|
writePublicClassImplementation(baseFileName, v, rootClass);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CodeGenerator::writeCoreFactoryHeader(const QString &fileName) const
|
|
{
|
|
if (!m_parser)
|
|
return;
|
|
|
|
QFile file(fileName);
|
|
if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
|
|
return;
|
|
QTextStream stream(&file);
|
|
|
|
// Write the preamble
|
|
writePreamble(fileName, stream);
|
|
|
|
// Write the postamble
|
|
writePostamble(fileName, stream);
|
|
}
|
|
|
|
void CodeGenerator::writeCoreFactoryImplementation(const QString &fileName) const
|
|
{
|
|
if (!m_parser)
|
|
return;
|
|
|
|
QFile file(fileName);
|
|
if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
|
|
return;
|
|
QTextStream stream(&file);
|
|
|
|
// Write the preamble
|
|
writePreamble(fileName, stream);
|
|
|
|
// Get the set of version functions classes we need to create
|
|
QList<Version> versions = m_parser->versions();
|
|
std::sort(versions.begin(), versions.end(), std::greater<Version>());
|
|
|
|
// Outout the #include statements
|
|
stream << QStringLiteral("#if !defined(QT_OPENGL_ES_2)") << endl;
|
|
Q_FOREACH (const Version &classVersion, versions) {
|
|
if (!versionHasProfiles(classVersion)) {
|
|
stream << QString(QStringLiteral("#include \"qopenglfunctions_%1_%2.h\""))
|
|
.arg(classVersion.major)
|
|
.arg(classVersion.minor) << endl;
|
|
} else {
|
|
const QList<VersionProfile::OpenGLProfile> profiles = (QList<VersionProfile::OpenGLProfile>()
|
|
<< VersionProfile::CoreProfile << VersionProfile::CompatibilityProfile);
|
|
|
|
Q_FOREACH (const VersionProfile::OpenGLProfile profile, profiles) {
|
|
const QString profileSuffix = profile == VersionProfile::CoreProfile
|
|
? QStringLiteral("core")
|
|
: QStringLiteral("compatibility");
|
|
stream << QString(QStringLiteral("#include \"qopenglfunctions_%1_%2_%3.h\""))
|
|
.arg(classVersion.major)
|
|
.arg(classVersion.minor)
|
|
.arg(profileSuffix) << endl;
|
|
}
|
|
}
|
|
}
|
|
stream << QStringLiteral("#else") << endl;
|
|
stream << QStringLiteral("#include \"qopenglfunctions_es2.h\"") << endl;
|
|
stream << QStringLiteral("#endif") << endl;
|
|
|
|
stream << endl;
|
|
|
|
stream << QStringLiteral("QT_BEGIN_NAMESPACE") << endl << endl;
|
|
stream << QStringLiteral("QAbstractOpenGLFunctions *QOpenGLVersionFunctionsFactory::create(const QOpenGLVersionProfile &versionProfile)") << endl;
|
|
stream << QStringLiteral("{") << endl;
|
|
stream << QStringLiteral("#if !defined(QT_OPENGL_ES_2)") << endl;
|
|
stream << QStringLiteral(" const int major = versionProfile.version().first;") << endl;
|
|
stream << QStringLiteral(" const int minor = versionProfile.version().second;") << endl << endl;
|
|
|
|
// Iterate over classes with profiles
|
|
stream << QStringLiteral(" if (versionProfile.hasProfiles()) {") << endl;
|
|
stream << QStringLiteral(" switch (versionProfile.profile()) {") << endl;
|
|
const QList<VersionProfile::OpenGLProfile> profiles = (QList<VersionProfile::OpenGLProfile>()
|
|
<< VersionProfile::CoreProfile << VersionProfile::CompatibilityProfile);
|
|
Q_FOREACH (const VersionProfile::OpenGLProfile profile, profiles) {
|
|
const QString caseLabel = profile == VersionProfile::CoreProfile
|
|
? QStringLiteral("QSurfaceFormat::CoreProfile")
|
|
: QStringLiteral("QSurfaceFormat::CompatibilityProfile");
|
|
stream << QString(QStringLiteral(" case %1:")).arg(caseLabel) << endl;
|
|
|
|
int i = 0;
|
|
Q_FOREACH (const Version &classVersion, versions) {
|
|
if (!versionHasProfiles(classVersion))
|
|
continue;
|
|
|
|
const QString ifString = (i++ == 0) ? QStringLiteral("if") : QStringLiteral("else if");
|
|
stream << QString(QStringLiteral(" %1 (major == %2 && minor == %3)"))
|
|
.arg(ifString)
|
|
.arg(classVersion.major)
|
|
.arg(classVersion.minor) << endl;
|
|
|
|
VersionProfile v;
|
|
v.version = classVersion;
|
|
v.profile = profile;
|
|
stream << QString(QStringLiteral(" return new %1;"))
|
|
.arg(generateClassName(v)) << endl;
|
|
}
|
|
|
|
stream << QStringLiteral(" break;") << endl << endl;
|
|
}
|
|
|
|
stream << QStringLiteral(" case QSurfaceFormat::NoProfile:") << endl;
|
|
stream << QStringLiteral(" default:") << endl;
|
|
stream << QStringLiteral(" break;") << endl;
|
|
stream << QStringLiteral(" };") << endl;
|
|
stream << QStringLiteral(" } else {") << endl;
|
|
|
|
// Iterate over the legacy classes (no profiles)
|
|
int i = 0;
|
|
Q_FOREACH (const Version &classVersion, versions) {
|
|
if (versionHasProfiles(classVersion))
|
|
continue;
|
|
|
|
const QString ifString = (i++ == 0) ? QStringLiteral("if") : QStringLiteral("else if");
|
|
stream << QString(QStringLiteral(" %1 (major == %2 && minor == %3)"))
|
|
.arg(ifString)
|
|
.arg(classVersion.major)
|
|
.arg(classVersion.minor) << endl;
|
|
|
|
VersionProfile v;
|
|
v.version = classVersion;
|
|
stream << QString(QStringLiteral(" return new %1;"))
|
|
.arg(generateClassName(v)) << endl;
|
|
}
|
|
|
|
stream << QStringLiteral(" }") << endl;
|
|
stream << QStringLiteral(" return 0;") << endl;
|
|
|
|
stream << QStringLiteral("#else") << endl;
|
|
stream << QStringLiteral(" Q_UNUSED(versionProfile);") << endl;
|
|
stream << QStringLiteral(" return new QOpenGLFunctions_ES2;") << endl;
|
|
stream << QStringLiteral("#endif") << endl;
|
|
stream << QStringLiteral("}") << endl;
|
|
|
|
// Write the postamble
|
|
writePostamble(fileName, stream);
|
|
}
|
|
|
|
/**
|
|
\returns all functions to be included in the class defined by \a classVersionProfile
|
|
*/
|
|
FunctionCollection CodeGenerator::functionCollection( const VersionProfile& classVersionProfile ) const
|
|
{
|
|
const Version classVersion = classVersionProfile.version;
|
|
FunctionCollection functionSet;
|
|
QList<Version> versions = m_parser->versions();
|
|
|
|
// Populate these based upon the class version and profile
|
|
Version minVersion;
|
|
minVersion.major = 1;
|
|
minVersion.minor = 0;
|
|
Version maxVersion = classVersion;
|
|
QList<VersionProfile::OpenGLProfile> profiles;
|
|
profiles << VersionProfile::CoreProfile; // Always need core functions
|
|
|
|
if (isLegacyVersion(classVersion)
|
|
|| (classVersionProfile.hasProfiles()
|
|
&& classVersionProfile.profile == VersionProfile::CompatibilityProfile)) {
|
|
// For versions < 3.1 and Compatibility profile we include both core and deprecated functions
|
|
profiles << VersionProfile::CompatibilityProfile;
|
|
}
|
|
|
|
Q_FOREACH (const Version &v, versions) {
|
|
// Only include functions from versions in the range
|
|
if (v < minVersion)
|
|
continue;
|
|
if (v > maxVersion)
|
|
break;
|
|
|
|
Q_FOREACH (VersionProfile::OpenGLProfile profile, profiles) {
|
|
// Combine version and profile for this subset of functions
|
|
VersionProfile version;
|
|
version.version = v;
|
|
version.profile = profile;
|
|
|
|
// Fetch the functions and add to collection for this class
|
|
QList<Function> functions = m_parser->functionsForVersion(version);
|
|
functionSet.insert(version, functions);
|
|
}
|
|
}
|
|
|
|
return functionSet;
|
|
}
|
|
|
|
void CodeGenerator::writePreamble(const QString &baseFileName, QTextStream &stream, const QString replacement) const
|
|
{
|
|
const QString fileName = baseFileName + QStringLiteral(".header");
|
|
if (!QFile::exists(fileName))
|
|
return;
|
|
|
|
QFile file(fileName);
|
|
if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
|
QTextStream preambleStream(&file);
|
|
QString preamble = preambleStream.readAll();
|
|
if (!replacement.isEmpty())
|
|
preamble.replace(QStringLiteral("__VERSION__"), replacement, Qt::CaseSensitive);
|
|
stream << preamble;
|
|
}
|
|
}
|
|
|
|
void CodeGenerator::writePostamble(const QString &baseFileName, QTextStream &stream) const
|
|
{
|
|
const QString fileName = baseFileName + QStringLiteral(".footer");
|
|
if (!QFile::exists(fileName))
|
|
return;
|
|
|
|
QFile file(fileName);
|
|
if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
|
QTextStream postambleStream(&file);
|
|
QString postamble = postambleStream.readAll();
|
|
stream << postamble;
|
|
}
|
|
}
|
|
|
|
QString CodeGenerator::passByType(const Argument &arg) const
|
|
{
|
|
QString passBy;
|
|
switch (arg.mode) {
|
|
case Argument::Reference:
|
|
case Argument::Array:
|
|
passBy = QStringLiteral("*");
|
|
break;
|
|
|
|
default:
|
|
case Argument::Value:
|
|
passBy = QString();
|
|
}
|
|
return passBy;
|
|
}
|
|
|
|
QString CodeGenerator::safeArgumentName(const QString& arg) const
|
|
{
|
|
if (arg == QLatin1String("near")) // MS Windows defines near and far
|
|
return QStringLiteral("nearVal");
|
|
else if (arg == QLatin1String("far"))
|
|
return QStringLiteral("farVal");
|
|
else if (arg == QLatin1String("d"))
|
|
return QStringLiteral("dd"); // Don't shadow d pointer
|
|
else
|
|
return arg;
|
|
}
|
|
|
|
QString CodeGenerator::generateClassName(const VersionProfile &classVersion, ClassVisibility visibility) const
|
|
{
|
|
QString className;
|
|
switch ( visibility ) {
|
|
case Public: {
|
|
// Class name and base class
|
|
QString profileSuffix;
|
|
if (classVersion.hasProfiles())
|
|
profileSuffix = (classVersion.profile == VersionProfile::CoreProfile ? QStringLiteral("_Core") : QStringLiteral("_Compatibility"));
|
|
|
|
className = QString(QStringLiteral("QOpenGLFunctions_%1_%2%3"))
|
|
.arg(classVersion.version.major)
|
|
.arg(classVersion.version.minor)
|
|
.arg(profileSuffix);
|
|
break;
|
|
}
|
|
case Private: {
|
|
QString statusSuffix = (classVersion.profile == VersionProfile::CoreProfile ? QStringLiteral("_Core") : QStringLiteral("_Deprecated"));
|
|
|
|
className = QString(QStringLiteral("QOpenGLFunctions_%1_%2%3Private"))
|
|
.arg(classVersion.version.major)
|
|
.arg(classVersion.version.minor)
|
|
.arg(statusSuffix);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return className;
|
|
}
|
|
|
|
void CodeGenerator::writeBackendClassDeclaration(QTextStream &stream,
|
|
const VersionProfile &versionProfile,
|
|
const QString &baseClass) const
|
|
{
|
|
const QString className = backendClassName(versionProfile);
|
|
stream << QString(QStringLiteral("class %1 : public %2"))
|
|
.arg(className)
|
|
.arg(baseClass)
|
|
<< endl;
|
|
stream << QStringLiteral("{") << endl;
|
|
stream << QStringLiteral("public:") << endl;
|
|
stream << QString( QStringLiteral(" %1(QOpenGLContext *context);") ).arg(className) << endl << endl;
|
|
|
|
// Output function used for generating key used in QOpenGLContextPrivate
|
|
stream << QStringLiteral(" static QOpenGLVersionStatus versionStatus();") << endl << endl;
|
|
|
|
// Get the functions needed for this class
|
|
FunctionList functions = m_parser->functionsForVersion(versionProfile);
|
|
FunctionCollection functionSet;
|
|
functionSet.insert(versionProfile, functions);
|
|
|
|
// Declare the functions
|
|
writeClassFunctionDeclarations(stream, functionSet, Private);
|
|
|
|
stream << QStringLiteral("};") << endl;
|
|
stream << endl;
|
|
}
|
|
|
|
void CodeGenerator::writeBackendClassImplementation(QTextStream &stream,
|
|
const VersionProfile &versionProfile,
|
|
const QString &baseClass) const
|
|
{
|
|
const QString className = backendClassName(versionProfile);
|
|
stream << QString(QStringLiteral("%1::%1(QOpenGLContext *context)")).arg(className) << endl;
|
|
stream << QString(QStringLiteral(" : %1(context)")).arg(baseClass) << endl
|
|
<< QStringLiteral("{") << endl;
|
|
|
|
// Resolve the entry points for this set of functions
|
|
// Get the functions needed for this class
|
|
FunctionList functions = m_parser->functionsForVersion(versionProfile);
|
|
FunctionCollection functionSet;
|
|
functionSet.insert(versionProfile, functions);
|
|
writeEntryPointResolutionCode(stream, functionSet);
|
|
|
|
stream << QStringLiteral("}") << endl << endl;
|
|
|
|
stream << QString(QStringLiteral("QOpenGLVersionStatus %1::versionStatus()")).arg(className) << endl;
|
|
stream << QStringLiteral("{") << endl;
|
|
const QString status = versionProfile.profile == VersionProfile::CoreProfile
|
|
? QStringLiteral("QOpenGLVersionStatus::CoreStatus")
|
|
: QStringLiteral("QOpenGLVersionStatus::DeprecatedStatus");
|
|
stream << QString(QStringLiteral(" return QOpenGLVersionStatus(%1, %2, %3);"))
|
|
.arg(versionProfile.version.major)
|
|
.arg(versionProfile.version.minor)
|
|
.arg(status) << endl;
|
|
stream << QStringLiteral("}") << endl << endl;
|
|
}
|
|
|
|
QString CodeGenerator::coreClassFileName(const VersionProfile &versionProfile,
|
|
const QString& fileExtension) const
|
|
{
|
|
QString profileSuffix;
|
|
if (versionProfile.hasProfiles())
|
|
profileSuffix = (versionProfile.profile == VersionProfile::CoreProfile ? QStringLiteral("_core") : QStringLiteral("_compatibility"));
|
|
|
|
const QString fileName = QString(QStringLiteral("qopenglfunctions_%1_%2%3.%4"))
|
|
.arg(versionProfile.version.major)
|
|
.arg(versionProfile.version.minor)
|
|
.arg(profileSuffix)
|
|
.arg(fileExtension);
|
|
return fileName;
|
|
}
|
|
|
|
void CodeGenerator::writePublicClassDeclaration(const QString &baseFileName,
|
|
const VersionProfile &versionProfile,
|
|
const QString &baseClass) const
|
|
{
|
|
const QString fileName = coreClassFileName(versionProfile, QStringLiteral("h"));
|
|
QFile file(fileName);
|
|
if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
|
|
return;
|
|
QTextStream stream(&file);
|
|
|
|
// Write the preamble
|
|
const QString templateFileName = QString(QStringLiteral("%1__VERSION__.h"))
|
|
.arg(baseFileName);
|
|
QString profileSuffix;
|
|
if (versionProfile.hasProfiles())
|
|
profileSuffix = (versionProfile.profile == VersionProfile::CoreProfile ? QStringLiteral("_CORE") : QStringLiteral("_COMPATIBILITY"));
|
|
|
|
const QString versionProfileString = QString(QStringLiteral("_%1_%2%3"))
|
|
.arg(versionProfile.version.major)
|
|
.arg(versionProfile.version.minor)
|
|
.arg(profileSuffix);
|
|
writePreamble(templateFileName, stream, versionProfileString);
|
|
|
|
// Ctor, dtor, and initialize function;
|
|
const QString className = generateClassName(versionProfile, Public);
|
|
stream << QString(QStringLiteral("class Q_GUI_EXPORT %1 : public %2"))
|
|
.arg(className)
|
|
.arg(baseClass)
|
|
<< endl;
|
|
stream << QStringLiteral("{") << endl;
|
|
stream << QStringLiteral("public:") << endl;
|
|
stream << QString(QStringLiteral(" %1();")).arg(className) << endl;
|
|
stream << QString(QStringLiteral(" ~%1();")).arg(className) << endl << endl;
|
|
stream << QStringLiteral(" bool initializeOpenGLFunctions() override;") << endl << endl;
|
|
|
|
// Get the functions needed for this class and declare them
|
|
FunctionCollection functionSet = functionCollection(versionProfile);
|
|
writeClassFunctionDeclarations(stream, functionSet, Public);
|
|
|
|
// isCompatible function and backend variables
|
|
stream << QStringLiteral("private:") << endl;
|
|
stream << QStringLiteral(" friend class QOpenGLContext;") << endl << endl;
|
|
stream << QStringLiteral(" static bool isContextCompatible(QOpenGLContext *context);") << endl;
|
|
stream << QStringLiteral(" static QOpenGLVersionProfile versionProfile();") << endl << endl;
|
|
writeBackendVariableDeclarations(stream, backendsForFunctionCollection(functionSet));
|
|
|
|
stream << QStringLiteral("};") << endl << endl;
|
|
|
|
// Output the inline functions that forward OpenGL calls to the backends' entry points
|
|
writeClassInlineFunctions(stream, className, functionSet);
|
|
|
|
// Write the postamble
|
|
writePostamble(templateFileName, stream);
|
|
}
|
|
|
|
void CodeGenerator::writePublicClassImplementation(const QString &baseFileName,
|
|
const VersionProfile &versionProfile,
|
|
const QString& baseClass) const
|
|
{
|
|
const QString fileName = coreClassFileName(versionProfile, QStringLiteral("cpp"));
|
|
QFile file(fileName);
|
|
if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
|
|
return;
|
|
QTextStream stream(&file);
|
|
|
|
// Write the preamble
|
|
const QString templateFileName = QString(QStringLiteral("%1__VERSION__.cpp"))
|
|
.arg(baseFileName);
|
|
QString profileSuffix;
|
|
if (versionProfile.hasProfiles())
|
|
profileSuffix = (versionProfile.profile == VersionProfile::CoreProfile ? QStringLiteral("_core") : QStringLiteral("_compatibility"));
|
|
|
|
const QString versionProfileString = QString(QStringLiteral("_%1_%2%3"))
|
|
.arg(versionProfile.version.major)
|
|
.arg(versionProfile.version.minor)
|
|
.arg(profileSuffix);
|
|
writePreamble(templateFileName, stream, versionProfileString);
|
|
|
|
const QString className = generateClassName(versionProfile, Public);
|
|
stream << QStringLiteral("/*!") << endl
|
|
<< QStringLiteral(" \\class ") << className << endl
|
|
<< QStringLiteral(" \\inmodule QtGui") << endl
|
|
<< QStringLiteral(" \\since 5.1") << endl
|
|
<< QStringLiteral(" \\wrapper") << endl
|
|
<< QStringLiteral(" \\brief The ") << className
|
|
<< QString(QStringLiteral(" class provides all functions for OpenGL %1.%2 "))
|
|
.arg(versionProfile.version.major)
|
|
.arg(versionProfile.version.minor);
|
|
|
|
if (!profileSuffix.isEmpty()) {
|
|
profileSuffix.remove(0, 1);
|
|
profileSuffix.append(QStringLiteral(" profile"));
|
|
} else {
|
|
profileSuffix = "specification";
|
|
}
|
|
|
|
stream << profileSuffix << QStringLiteral(".") << endl << endl
|
|
<< QStringLiteral(" This class is a wrapper for functions from ")
|
|
<< QString(QStringLiteral("OpenGL %1.%2 "))
|
|
.arg(versionProfile.version.major)
|
|
.arg(versionProfile.version.minor)
|
|
<< profileSuffix << QStringLiteral(".") << endl
|
|
<< QStringLiteral(" See reference pages on \\l {http://www.opengl.org/sdk/docs/}{opengl.org}") << endl
|
|
<< QStringLiteral(" for function documentation.") << endl << endl
|
|
<< QStringLiteral(" \\sa QAbstractOpenGLFunctions") << endl
|
|
<< QStringLiteral("*/") << endl << endl;
|
|
|
|
// Get the data we'll need for this class implementation
|
|
FunctionCollection functionSet = functionCollection(versionProfile);
|
|
QList<VersionProfile> backends = backendsForFunctionCollection(functionSet);
|
|
|
|
// Output default constructor
|
|
stream << className << QStringLiteral("::") << className << QStringLiteral("()") << endl;
|
|
stream << QStringLiteral(" : ") << baseClass << QStringLiteral("()");
|
|
Q_FOREACH (const VersionProfile &v, backends)
|
|
stream << endl << QString(QStringLiteral(" , %1(0)")).arg(backendVariableName(v));
|
|
stream << endl << QStringLiteral("{") << endl << QStringLiteral("}") << endl << endl;
|
|
|
|
// Output the destructor
|
|
stream << className << QStringLiteral("::~") << className << QStringLiteral("()") << endl;
|
|
stream << QStringLiteral("{") << endl;
|
|
Q_FOREACH (const VersionProfile &v, backends) {
|
|
const QString backendVar = backendVariableName(v);
|
|
const QString backendClass = backendClassName(v);
|
|
stream << QString(QStringLiteral(" if (%1 && !%1->refs.deref()) {")).arg(backendVar) << endl;
|
|
stream << QString(QStringLiteral(" QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(%1->context, %2::versionStatus());"))
|
|
.arg(backendVar)
|
|
.arg(backendClass) << endl;
|
|
stream << QString(QStringLiteral(" delete %1;")).arg(backendVar) << endl;
|
|
stream << QStringLiteral(" }") << endl;
|
|
}
|
|
stream << QStringLiteral("}") << endl << endl;
|
|
|
|
// Output the initialize function that creates the backend objects
|
|
stream << QString(QStringLiteral("bool %1::initializeOpenGLFunctions()")).arg(className) << endl;
|
|
stream << QStringLiteral("{") << endl;
|
|
|
|
stream << QStringLiteral(" if ( isInitialized() )") << endl;
|
|
stream << QStringLiteral(" return true;") << endl << endl;
|
|
stream << QStringLiteral(" QOpenGLContext* context = QOpenGLContext::currentContext();") << endl << endl;
|
|
stream << QStringLiteral(" // If owned by a context object make sure it is current.") << endl;
|
|
stream << QStringLiteral(" // Also check that current context is capable of resolving all needed functions") << endl;
|
|
stream << QStringLiteral(" if (((owningContext() && owningContext() == context) || !owningContext())") << endl;
|
|
stream << QString(QStringLiteral(" && %1::isContextCompatible(context))")).arg(className) << endl;
|
|
stream << QStringLiteral(" {") << endl;
|
|
stream << QStringLiteral(" // Associate with private implementation, creating if necessary") << endl;
|
|
stream << QStringLiteral(" // Function pointers in the backends are resolved at creation time") << endl;
|
|
stream << QStringLiteral(" QOpenGLVersionFunctionsBackend* d = 0;") << endl;
|
|
|
|
Q_FOREACH (const VersionProfile &v, backends) {
|
|
const QString backendClass = backendClassName(v);
|
|
const QString backendVar = backendVariableName(v);
|
|
stream << QString(QStringLiteral(" d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, %1::versionStatus());"))
|
|
.arg(backendClass) << endl;
|
|
stream << QStringLiteral(" if (!d) {") << endl;
|
|
stream << QString(QStringLiteral(" d = new %1(context);")).arg(backendClass) << endl;
|
|
stream << QString(QStringLiteral(" QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, %1::versionStatus(), d);"))
|
|
.arg(backendClass) << endl;
|
|
stream << QStringLiteral(" }") << endl;
|
|
stream << QString(QStringLiteral(" %1 = static_cast<%2*>(d);")).arg(backendVar).arg(backendClass) << endl;
|
|
stream << QStringLiteral(" d->refs.ref();") << endl << endl;
|
|
}
|
|
|
|
stream << QStringLiteral(" QAbstractOpenGLFunctions::initializeOpenGLFunctions();") << endl;
|
|
stream << QStringLiteral(" }") << endl;
|
|
|
|
stream << QStringLiteral(" return isInitialized();") << endl;
|
|
stream << QStringLiteral("}") << endl << endl;
|
|
|
|
// Output the context compatibility check function
|
|
stream << QString(QStringLiteral("bool %1::isContextCompatible(QOpenGLContext *context)")).arg(className) << endl;
|
|
stream << QStringLiteral("{") << endl;
|
|
stream << QStringLiteral(" Q_ASSERT(context);") << endl;
|
|
stream << QStringLiteral(" QSurfaceFormat f = context->format();") << endl;
|
|
stream << QStringLiteral(" const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());") << endl;
|
|
stream << QString(QStringLiteral(" if (v < qMakePair(%1, %2))"))
|
|
.arg(versionProfile.version.major)
|
|
.arg(versionProfile.version.minor) << endl;
|
|
stream << QStringLiteral(" return false;") << endl << endl;
|
|
|
|
// If generating a legacy or compatibility profile class we need to ensure that
|
|
// the context does not expose only core functions
|
|
if (versionProfile.profile != VersionProfile::CoreProfile) {
|
|
stream << QStringLiteral(" if (f.profile() == QSurfaceFormat::CoreProfile)") << endl;
|
|
stream << QStringLiteral(" return false;") << endl << endl;
|
|
}
|
|
|
|
stream << QStringLiteral(" return true;") << endl;
|
|
stream << QStringLiteral("}") << endl << endl;
|
|
|
|
// Output static function used as helper in template versionFunctions() function
|
|
// in QOpenGLContext
|
|
stream << QString(QStringLiteral("QOpenGLVersionProfile %1::versionProfile()")).arg(className) << endl;
|
|
stream << QStringLiteral("{") << endl;
|
|
stream << QStringLiteral(" QOpenGLVersionProfile v;") << endl;
|
|
stream << QString(QStringLiteral(" v.setVersion(%1, %2);"))
|
|
.arg(versionProfile.version.major)
|
|
.arg(versionProfile.version.minor) << endl;
|
|
if (versionProfile.hasProfiles()) {
|
|
const QString profileName = versionProfile.profile == VersionProfile::CoreProfile
|
|
? QStringLiteral("QSurfaceFormat::CoreProfile")
|
|
: QStringLiteral("QSurfaceFormat::CompatibilityProfile");
|
|
stream << QString(QStringLiteral(" v.setProfile(%1);")).arg(profileName) << endl;
|
|
}
|
|
stream << QStringLiteral(" return v;") << endl;
|
|
stream << QStringLiteral("}") << endl;
|
|
|
|
// Write the postamble
|
|
writePostamble(templateFileName, stream);
|
|
}
|
|
|
|
void CodeGenerator::writeClassFunctionDeclarations(QTextStream &stream,
|
|
const FunctionCollection &functionSet,
|
|
ClassVisibility visibility) const
|
|
{
|
|
Q_FOREACH (const VersionProfile &version, functionSet.keys()) {
|
|
// Add a comment to the header
|
|
stream << QString(QStringLiteral(" // OpenGL %1.%2 %3 functions"))
|
|
.arg(version.version.major)
|
|
.arg(version.version.minor)
|
|
.arg((version.profile == VersionProfile::CoreProfile) ? QStringLiteral("core") : QStringLiteral("deprecated"))
|
|
<< endl;
|
|
|
|
// Output function declarations
|
|
FunctionList functions = functionSet.value(version);
|
|
Q_FOREACH (const Function &f, functions)
|
|
writeFunctionDeclaration(stream, f, visibility);
|
|
stream << endl;
|
|
} // version and profile
|
|
}
|
|
|
|
void CodeGenerator::writeFunctionDeclaration(QTextStream &stream, const Function &f, ClassVisibility visibility) const
|
|
{
|
|
QStringList argList;
|
|
Q_FOREACH (const Argument &arg, f.arguments) {
|
|
QString a = QString(QStringLiteral("%1%2 %3%4"))
|
|
.arg((arg.direction == Argument::In && arg.mode != Argument::Value) ? QStringLiteral("const ") : QString())
|
|
.arg(arg.type)
|
|
.arg(passByType(arg))
|
|
.arg(safeArgumentName(arg.name));
|
|
argList.append(a);
|
|
}
|
|
QString args = argList.join(QStringLiteral(", "));
|
|
|
|
QString signature;
|
|
switch (visibility) {
|
|
case Public:
|
|
signature = QString(QStringLiteral(" %1 gl%2(%3);")).arg(f.returnType).arg(f.name).arg(args);
|
|
break;
|
|
|
|
case Private:
|
|
default:
|
|
signature = QString(QStringLiteral(" %1 (QOPENGLF_APIENTRYP %2)(%3);")).arg(f.returnType).arg(f.name).arg(args);
|
|
}
|
|
stream << signature << endl;
|
|
}
|
|
|
|
void CodeGenerator::writeClassInlineFunctions(QTextStream &stream,
|
|
const QString &className,
|
|
const FunctionCollection &functionSet) const
|
|
{
|
|
Q_FOREACH (const VersionProfile &version, functionSet.keys()) {
|
|
|
|
// Add a comment to the header
|
|
stream << QString(QStringLiteral("// OpenGL %1.%2 %3 functions"))
|
|
.arg(version.version.major)
|
|
.arg(version.version.minor)
|
|
.arg((version.profile == VersionProfile::CoreProfile) ? QStringLiteral("core") : QStringLiteral("deprecated"))
|
|
<< endl;
|
|
|
|
// Output function declarations
|
|
const QString backendVar = backendVariableName(version);
|
|
FunctionList functions = functionSet.value(version);
|
|
Q_FOREACH (const Function &f, functions)
|
|
writeInlineFunction(stream, className, backendVar, f);
|
|
|
|
stream << endl;
|
|
|
|
} // version and profile
|
|
}
|
|
|
|
void CodeGenerator::writeInlineFunction(QTextStream &stream, const QString &className,
|
|
const QString &backendVar, const Function &f) const
|
|
{
|
|
QStringList argList;
|
|
Q_FOREACH (const Argument &arg, f.arguments) {
|
|
QString a = QString(QStringLiteral("%1%2 %3%4"))
|
|
.arg((arg.direction == Argument::In && arg.mode != Argument::Value) ? QStringLiteral("const ") : QString())
|
|
.arg(arg.type)
|
|
.arg(passByType(arg))
|
|
.arg(safeArgumentName(arg.name));
|
|
argList.append(a);
|
|
}
|
|
QString args = argList.join(", ");
|
|
|
|
|
|
QString signature = QString(QStringLiteral("inline %1 %2::gl%3(%4)"))
|
|
.arg(f.returnType)
|
|
.arg(className)
|
|
.arg(f.name)
|
|
.arg(args);
|
|
stream << signature << endl << QStringLiteral("{") << endl;
|
|
|
|
QStringList argumentNames;
|
|
Q_FOREACH (const Argument &arg, f.arguments)
|
|
argumentNames.append(safeArgumentName(arg.name));
|
|
QString argNames = argumentNames.join(", ");
|
|
|
|
if (f.returnType == QLatin1String("void"))
|
|
stream << QString(QStringLiteral(" %1->%2(%3);")).arg(backendVar).arg(f.name).arg(argNames) << endl;
|
|
else
|
|
stream << QString(QStringLiteral(" return %1->%2(%3);")).arg(backendVar).arg(f.name).arg(argNames) << endl;
|
|
stream << QStringLiteral("}") << endl << endl;
|
|
}
|
|
|
|
void CodeGenerator::writeEntryPointResolutionCode(QTextStream &stream,
|
|
const FunctionCollection &functionSet) const
|
|
{
|
|
bool hasModuleHandle = false;
|
|
Q_FOREACH (const VersionProfile &version, functionSet.keys()) {
|
|
|
|
// Add a comment to the header
|
|
stream << QString(QStringLiteral(" // OpenGL %1.%2 %3 functions"))
|
|
.arg(version.version.major)
|
|
.arg(version.version.minor)
|
|
.arg((version.profile == VersionProfile::CoreProfile) ? QStringLiteral("core") : QStringLiteral("deprecated"))
|
|
<< endl;
|
|
|
|
// Output function declarations
|
|
FunctionList functions = functionSet.value(version);
|
|
|
|
bool useGetProcAddress = (version.version.major == 1 && (version.version.minor == 0 || version.version.minor == 1));
|
|
if (useGetProcAddress) {
|
|
stream << "#if defined(Q_OS_WIN)" << endl;
|
|
if (!hasModuleHandle) {
|
|
stream << " HMODULE handle = GetModuleHandleA(\"opengl32.dll\");" << endl;
|
|
hasModuleHandle = true;
|
|
}
|
|
|
|
Q_FOREACH (const Function &f, functions)
|
|
writeEntryPointResolutionStatement(stream, f, QString(), useGetProcAddress);
|
|
|
|
stream << "#else" << endl;
|
|
}
|
|
|
|
Q_FOREACH (const Function &f, functions)
|
|
writeEntryPointResolutionStatement(stream, f);
|
|
|
|
if (useGetProcAddress)
|
|
stream << "#endif" << endl;
|
|
|
|
stream << endl;
|
|
|
|
} // version and profile
|
|
}
|
|
|
|
void CodeGenerator::writeEntryPointResolutionStatement(QTextStream &stream, const Function &f,
|
|
const QString &prefix, bool useGetProcAddress) const
|
|
{
|
|
QStringList argList;
|
|
Q_FOREACH (const Argument &arg, f.arguments) {
|
|
QString a = QString("%1%2 %3")
|
|
.arg((arg.direction == Argument::In && arg.mode != Argument::Value) ? QStringLiteral("const ") : QString())
|
|
.arg(arg.type)
|
|
.arg(passByType(arg));
|
|
argList.append(a);
|
|
}
|
|
QString args = argList.join(QStringLiteral(", "));
|
|
|
|
QString signature;
|
|
if (!useGetProcAddress) {
|
|
signature = QString(QStringLiteral(" %4%3 = reinterpret_cast<%1 (QOPENGLF_APIENTRYP)(%2)>(context->getProcAddress(\"gl%3\"));"))
|
|
.arg(f.returnType)
|
|
.arg(args)
|
|
.arg(f.name)
|
|
.arg(prefix);
|
|
} else {
|
|
signature = QString(QStringLiteral(" %4%3 = reinterpret_cast<%1 (QOPENGLF_APIENTRYP)(%2)>(GetProcAddress(handle, \"gl%3\"));"))
|
|
.arg(f.returnType)
|
|
.arg(args)
|
|
.arg(f.name)
|
|
.arg(prefix);
|
|
}
|
|
stream << signature << endl;
|
|
}
|
|
|
|
QList<VersionProfile> CodeGenerator::backendsForFunctionCollection(const FunctionCollection &functionSet) const
|
|
{
|
|
QList<VersionProfile> backends;
|
|
Q_FOREACH (const VersionProfile &versionProfile, functionSet.keys()) {
|
|
if (m_parser->versionProfiles().contains(versionProfile))
|
|
backends.append(versionProfile);
|
|
}
|
|
return backends;
|
|
}
|
|
|
|
QString CodeGenerator::backendClassName(const VersionProfile &v) const
|
|
{
|
|
QString statusSuffix = v.profile == VersionProfile::CoreProfile
|
|
? QStringLiteral("_Core")
|
|
: QStringLiteral("_Deprecated");
|
|
const QString className = QString(QStringLiteral("QOpenGLFunctions_%1_%2%3Backend"))
|
|
.arg(v.version.major)
|
|
.arg(v.version.minor)
|
|
.arg(statusSuffix);
|
|
return className;
|
|
}
|
|
|
|
QString CodeGenerator::backendVariableName(const VersionProfile &v) const
|
|
{
|
|
const QString status = (v.profile == VersionProfile::CoreProfile)
|
|
? QStringLiteral("Core")
|
|
: QStringLiteral("Deprecated");
|
|
const QString varName = QString(QStringLiteral("d_%1_%2_%3"))
|
|
.arg(v.version.major)
|
|
.arg(v.version.minor)
|
|
.arg(status);
|
|
return varName;
|
|
}
|
|
|
|
void CodeGenerator::writeBackendVariableDeclarations(QTextStream &stream, const QList<VersionProfile> &backends) const
|
|
{
|
|
// We need a private class for each version and profile (status: core or deprecated)
|
|
Q_FOREACH (const VersionProfile &v, backends) {
|
|
const QString className = backendClassName(v);
|
|
const QString varName = backendVariableName(v);
|
|
stream << QString(QStringLiteral(" %1* %2;")).arg(className).arg(varName) << endl;
|
|
}
|
|
}
|
|
|
|
void CodeGenerator::writeExtensionHeader(const QString &fileName) const
|
|
{
|
|
if (!m_parser)
|
|
return;
|
|
|
|
QFile file(fileName);
|
|
if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
|
|
return;
|
|
QTextStream stream(&file);
|
|
|
|
// Write the preamble
|
|
writePreamble(fileName, stream);
|
|
|
|
// Iterate through the list of extensions and create one class per extension
|
|
QStringList extensions = m_parser->extensions();
|
|
Q_FOREACH (const QString &extension, extensions) {
|
|
writeExtensionClassDeclaration(stream, extension, Private);
|
|
writeExtensionClassDeclaration(stream, extension, Public);
|
|
}
|
|
|
|
// Write the postamble
|
|
writePostamble(fileName, stream);
|
|
}
|
|
|
|
void CodeGenerator::writeExtensionImplementation(const QString &fileName) const
|
|
{
|
|
if (!m_parser)
|
|
return;
|
|
|
|
QFile file(fileName);
|
|
if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
|
|
return;
|
|
QTextStream stream(&file);
|
|
|
|
// Write the preamble
|
|
writePreamble(fileName, stream);
|
|
|
|
// Iterate through the list of extensions and create one class per extension
|
|
QStringList extensions = m_parser->extensions();
|
|
Q_FOREACH (const QString &extension, extensions)
|
|
writeExtensionClassImplementation(stream, extension);
|
|
|
|
// Write the postamble
|
|
writePostamble(fileName, stream);
|
|
}
|
|
|
|
void CodeGenerator::writeExtensionClassDeclaration(QTextStream &stream, const QString &extension, ClassVisibility visibility) const
|
|
{
|
|
const QString className = generateExtensionClassName(extension, visibility);
|
|
|
|
QString baseClass = (visibility == Public) ? QStringLiteral("QAbstractOpenGLExtension") : QStringLiteral("QAbstractOpenGLExtensionPrivate");
|
|
|
|
stream << QString(QStringLiteral("class %2 : public %3"))
|
|
.arg(className)
|
|
.arg(baseClass)
|
|
<< endl << "{" << endl << "public:" << endl;
|
|
|
|
if (visibility == Public) {
|
|
// Default constructor
|
|
stream << QStringLiteral(" ") << className << QStringLiteral("();") << endl << endl;
|
|
|
|
// Base class virtual function(s)
|
|
QString resolveFunction = QStringLiteral(" bool initializeOpenGLFunctions() final;");
|
|
stream << resolveFunction << endl << endl;
|
|
}
|
|
|
|
// Output the functions provided by this extension
|
|
QList<Function> functions = m_parser->functionsForExtension(extension);
|
|
Q_FOREACH (const Function &f, functions)
|
|
writeFunctionDeclaration(stream, f, visibility);
|
|
|
|
if (visibility == Public) {
|
|
// Write out the protected ctor
|
|
stream << endl << QStringLiteral("protected:") << endl;
|
|
stream << QStringLiteral(" Q_DECLARE_PRIVATE(") << className << QStringLiteral(")") << endl;
|
|
}
|
|
|
|
// End the class declaration
|
|
stream << QStringLiteral("};") << endl << endl;
|
|
|
|
// Output the inline functions for public class
|
|
if (visibility == Public) {
|
|
Q_FOREACH (const Function &f, functions)
|
|
writeExtensionInlineFunction(stream, className, f);
|
|
}
|
|
}
|
|
|
|
void CodeGenerator::writeExtensionInlineFunction(QTextStream &stream, const QString &className, const Function &f) const
|
|
{
|
|
QStringList argList;
|
|
Q_FOREACH (const Argument &arg, f.arguments) {
|
|
QString a = QString(QStringLiteral("%1%2 %3%4"))
|
|
.arg((arg.direction == Argument::In && arg.mode != Argument::Value) ? QStringLiteral("const ") : QString())
|
|
.arg(arg.type)
|
|
.arg(passByType(arg))
|
|
.arg(safeArgumentName(arg.name));
|
|
argList.append(a);
|
|
}
|
|
QString args = argList.join(", ");
|
|
|
|
|
|
QString signature = QString(QStringLiteral("inline %1 %2::gl%3(%4)"))
|
|
.arg(f.returnType)
|
|
.arg(className)
|
|
.arg(f.name)
|
|
.arg(args);
|
|
stream << signature << endl << QStringLiteral("{") << endl;
|
|
|
|
stream << QString(QStringLiteral(" Q_D(%1);")).arg(className) << endl;
|
|
|
|
QStringList argumentNames;
|
|
Q_FOREACH (const Argument &arg, f.arguments)
|
|
argumentNames.append(safeArgumentName(arg.name));
|
|
QString argNames = argumentNames.join(", ");
|
|
|
|
if (f.returnType == QStringLiteral("void"))
|
|
stream << QString(QStringLiteral(" d->%1(%2);")).arg(f.name).arg(argNames) << endl;
|
|
else
|
|
stream << QString(QStringLiteral(" return d->%1(%2);")).arg(f.name).arg(argNames) << endl;
|
|
stream << QStringLiteral("}") << endl << endl;
|
|
}
|
|
|
|
void CodeGenerator::writeExtensionClassImplementation(QTextStream &stream, const QString &extension) const
|
|
{
|
|
const QString className = generateExtensionClassName(extension);
|
|
const QString privateClassName = generateExtensionClassName(extension, Private);
|
|
|
|
// Output default constructor
|
|
stream << className << QStringLiteral("::") << className << QStringLiteral("()") << endl;
|
|
stream << QStringLiteral(" : QAbstractOpenGLExtension(*(new ") << privateClassName << QStringLiteral("))") << endl;
|
|
stream << QStringLiteral("{") << endl << QStringLiteral("}") << endl << endl;
|
|
|
|
|
|
// Output function to initialize this class
|
|
stream << QStringLiteral("bool ") << className
|
|
<< QStringLiteral("::initializeOpenGLFunctions()") << endl
|
|
<< QStringLiteral("{") << endl;
|
|
|
|
stream << QStringLiteral(" if (isInitialized())") << endl;
|
|
stream << QStringLiteral(" return true;") << endl << endl;
|
|
|
|
stream << QStringLiteral(" QOpenGLContext *context = QOpenGLContext::currentContext();") << endl;
|
|
stream << QStringLiteral(" if (!context) {") << endl;
|
|
stream << QStringLiteral(" qWarning(\"A current OpenGL context is required to resolve OpenGL extension functions\");")
|
|
<< endl;
|
|
stream << QStringLiteral(" return false;") << endl;
|
|
stream << QStringLiteral(" }") << endl << endl;
|
|
|
|
// Output code to resolve entry points for this class
|
|
stream << QStringLiteral(" // Resolve the functions") << endl;
|
|
stream << QStringLiteral(" Q_D(") << className << QStringLiteral(");") << endl;
|
|
stream << endl;
|
|
|
|
// Output function declarations
|
|
QList<Function> functions = m_parser->functionsForExtension(extension);
|
|
Q_FOREACH (const Function &f, functions)
|
|
writeEntryPointResolutionStatement(stream, f, QStringLiteral("d->"));
|
|
|
|
// Call the base class implementation
|
|
stream << QStringLiteral(" QAbstractOpenGLExtension::initializeOpenGLFunctions();") << endl;
|
|
|
|
// Finish off
|
|
stream << QStringLiteral(" return true;") << endl;
|
|
stream << QStringLiteral("}") << endl << endl;
|
|
}
|
|
|
|
QString CodeGenerator::generateExtensionClassName(const QString &extension, ClassVisibility visibility) const
|
|
{
|
|
QString visibilitySuffix;
|
|
if (visibility == Private)
|
|
visibilitySuffix = QStringLiteral("Private");
|
|
|
|
return QString(QStringLiteral("QOpenGLExtension_%1%2"))
|
|
.arg(extension)
|
|
.arg(visibilitySuffix);
|
|
}
|