void OpenGLWindow::renderNow()
{
if (!isExposed())
return;
bool needsInitialize = false;
// Create an OpenGL context if there is not any
if (!m_context) {
m_context = new QOpenGLContext(this);
m_context->setFormat(requestedFormat());
m_context->create();
needsInitialize = true;
}
m_context->makeCurrent(this);
m_funcs = m_context->versionFunctions<QOpenGLFunctions_3_3_Core>();
if (needsInitialize) {
initializeOpenGLFunctions();
initialize();
}
render();
m_context->swapBuffers(this);
}
void OpenGLWindow::renderNow()
{
if (!isExposed())
return;
m_update_pending = false;
bool needsInitialize = false;
if (!m_context) {
m_context = new QOpenGLContext(this);
m_context->setFormat(requestedFormat());
m_context->create();
needsInitialize = true;
}
m_context->makeCurrent(this);
if (needsInitialize) {
initializeOpenGLFunctions();
initialize();
}
render();
m_context->swapBuffers(this);
if (m_animating)
renderLater();
}
void OpenGLWindow::renderNow()
{
// end function if window is not visible
if (!isExposed())
return;
bool needsInitialize = false;
/*QOpenGLContext represents the OpenGL state of an underlying OpenGL context.
To set up a context, set its screen and format such that they match those of the surface
or surfaces with which the context is meant to be used.*/
if (!m_context) {
m_context = new QOpenGLContext(this);
m_context->setFormat(requestedFormat());
m_context->create();
needsInitialize = true;
}
m_context->makeCurrent(this);
if (needsInitialize) {
// intern OpenGL function
initializeOpenGLFunctions();
initialize();
}
render();
m_context->swapBuffers(this);
if (m_animating)
renderLater();
}
void yage::GLWindow::beginDraw ( void )
{
if (!isExposed()) {
return;
}
bool needInit = false;
if (!m_context) {
qDebug() << "start ctx";
// Specify the format and create platform-specific surface
// Create an OpenGL context
m_context = new QOpenGLContext( this );
m_context->setFormat( requestedFormat() );
m_context->create();
if (!m_context->isValid()) {
qCritical() << "invalid context";
}
// Make the context current on this window
QList<QByteArray> extensions = m_context->extensions().toList();
qDebug() << "Version: " << m_context->format().majorVersion() << "." << m_context->format().minorVersion();
qDebug() << "Profile: " << m_context->format().profile();
//std::sort(extensions.first(), extensions.last());
qDebug() << "Supported extensions (" << extensions.count() << ")";
foreach ( const QByteArray &extension, extensions )
qDebug() << " " << extension;
needInit = true;
}
void MainWindow::renderNow()
{
if (!isExposed())
return;
updatePending = false;
bool needsInitialize = false;
if (!context) {
context = new QOpenGLContext(this);
context->setFormat(requestedFormat());
context->create();
needsInitialize = true;
}
context->makeCurrent(this);
if (world)
world->simulate(timer.elapsed());
timer.start();
if (needsInitialize) {
initializeOpenGLFunctions();
}
render();
context->swapBuffers(this);
if (animating)
renderLater();
}
void RenderSurface::renderNow(const float time)
{
m_globalTime = time;
//if (!isExposed())
//return;
bool needsInitialize = false;
if (!m_context) {
m_context = new QOpenGLContext(this);
m_context->setFormat(requestedFormat());
m_context->create();
needsInitialize = true;
}
m_context->makeCurrent(this);
if (needsInitialize) {
initializeOpenGLFunctions();
initialize();
}
render();
m_context->swapBuffers(this);
if (m_animating)
renderLater();
}
void exposeEvent(QExposeEvent *)
{
if (!isExposed())
return;
if (!gl) {
gl = new QOpenGLContext();
gl->setFormat(requestedFormat());
gl->create();
}
gl->makeCurrent(this);
QOpenGLShaderProgram prog;
prog.addShaderFromSourceCode(QOpenGLShader::Vertex,
"attribute highp vec4 a_Pos;"
"attribute lowp vec4 a_Color;"
"varying lowp vec4 v_Color;"
"void main() {"
" gl_Position = a_Pos;"
" v_Color = a_Color;"
"}");
prog.addShaderFromSourceCode(QOpenGLShader::Fragment,
"varying lowp vec4 v_Color;"
"void main() {"
" gl_FragColor = v_Color;"
"}");
prog.bind();
glClearColor(0, 0, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);
glViewport(0, 0, width(), height());
prog.enableAttributeArray("a_Pos");
prog.enableAttributeArray("a_Color");
float coords[] = { -0.7f, 0.7f,
0.8f, 0.8f,
-0.8f, -0.8f,
0.7f, -0.7f
};
float colors[] = { 1, 0, 0, 1,
0, 1, 0, 1,
0, 0, 1, 1,
0, 0, 0, 0
};
prog.setAttributeArray("a_Pos", GL_FLOAT, coords, 2, 0);
prog.setAttributeArray("a_Color", GL_FLOAT, colors, 4, 0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
prog.disableAttributeArray("a_Pos");
prog.disableAttributeArray("a_Color");
gl->swapBuffers(this);
}
void Window3D::initRendering()
{
if (!m_pContext) {
m_pContext = new QOpenGLContext(this);
m_pContext->setFormat(requestedFormat());
m_pContext->create();
}
m_canRender = true;
m_updateTime.start();
}
//! [4]
void OpenGLWindow::renderNow()
{
if (!isExposed())
return;
bool needsInitialize = false;
if (!m_context) {
m_context = new QOpenGLContext(this);
QGLFormat format = QGLFormat(QGL::DoubleBuffer | QGL::DepthBuffer);
m_context->setFormat(requestedFormat());
m_context->create();
needsInitialize = true;
}
m_context->makeCurrent(this);
if (needsInitialize) {
initializeOpenGLFunctions();
initialize();
GLuint depthRenderbuffer;
//QString tmp((const char*)glGetString(GL_VERSION));
//GL_VENDOR, GL_RENDERER, GL_VERSION, or GL_SHADING_LANGUAGE_VERSION
qDebug()<<"Version: "<<(const char*)glGetString(GL_VERSION);//tmp;
qDebug()<<"Renderer: "<<(const char*)glGetString(GL_RENDERER);
qDebug()<<"Shaders: "<<(const char*)glGetString(GL_SHADING_LANGUAGE_VERSION);
qDebug()<<"Vendor: "<<(const char*)glGetString(GL_VENDOR);
// glGenRenderbuffers(1, &depthRenderbuffer);
// glBindRenderbuffer(GL_RENDERBUFFER, depthRenderbuffer);
// // GL_DEPTH24_STENCIL8_OES: Set a depth buffer and a stencil buffer.
// // GL_DEPTH_COMPONENT16: Set a 16bits depth buffer.
// // GL_DEPTH_COMPONENT24_OES: Set a 24bits depth buffer.
// glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, 800, 600);
// glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthRenderbuffer);
}
render();
m_context->swapBuffers(this);
if (m_animating)
renderLater();
}
void GameWindow::render()
{
bool needsInitialize = false;
if (!m_context) {
m_context = new QOpenGLContext(this);
m_context->setFormat(requestedFormat());
m_context->create();
needsInitialize = true;
}
m_context->makeCurrent(this);
if (needsInitialize)
{
initializeOpenGLFunctions();
}
if (!m_device)
m_device = new QOpenGLPaintDevice();
m_device->setSize(size());
QPainter p;
elapsed = elapsedTimer.elapsed();
if(elapsed > timer.interval() * 0.5) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
this->render((float) elapsed * 0.0005f);
// glDisableVertexAttribArray(GL_DEPTH_TEST);
p.begin(m_device);
p.setPen(Qt::yellow);
p.setFont(QFont("Arial", 20));
p.drawText(10, 30, QString::number((int) (1.0 / (elapsed * 0.001f))));
p.end();
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
elapsed -= timer.interval();
elapsedTimer.restart();
}
}
Window::Window()
: QQuickView()
, m_terrain(nullptr)
, m_mouseDown(false)
, m_speed(0.01)
, m_needsUpdate(true)
, m_generate(false)
, m_paused(false)
, m_curTimeId(0)
{
updateUi();
rootContext()->setContextProperty("Game", this);
setSurfaceType(QWindow::OpenGLSurface);
setClearBeforeRendering(false);
setPersistentOpenGLContext(true);
setResizeMode(QQuickView::SizeRootObjectToView);
setSource(QUrl::fromLocalFile(FileFinder::findFile(FileFinder::Type::Qml, "ui.qml")));
QSurfaceFormat format = requestedFormat();
format.setProfile(QSurfaceFormat::CoreProfile);
format.setMajorVersion(3);
format.setMinorVersion(3);
format.setDepthBufferSize(24);
format.setOption(QSurfaceFormat::DebugContext);
setFormat(format);
resize(1024, 768);
connect(this, &QQuickWindow::beforeRendering, this, &Window::renderNow, Qt::DirectConnection);
connect(this, &QQuickWindow::beforeSynchronizing, this, &Window::sync, Qt::DirectConnection);
connect(this, &QQuickWindow::afterRendering, this, &Window::updateUi);
connect(this, &QQuickWindow::afterRendering, this, &Window::update);
show();
}
void MainWindow::initialize()
{
counter = 0;
m_context = new QOpenGLContext(this);
m_context->setFormat(requestedFormat());
m_context->create();
m_context->makeCurrent(this);
m_program = new QOpenGLShaderProgram(this);
m_program->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/GLSL/main.vert");
m_program->addShaderFromSourceFile(QOpenGLShader::Fragment, ":/GLSL/main.frag");
m_program->link();
m_vertexAttr = m_program->attributeLocation("qt_Vertex");
m_colorUni = m_program->uniformLocation("qt_Color");
m_matrixUni = m_program->uniformLocation("qt_Matrix");
m_glBuffer = new QOpenGLBuffer;
m_glBuffer->create();
m_glBuffer->setUsagePattern(QOpenGLBuffer::DynamicDraw);
m_glBuffer->bind();
m_glBuffer->allocate(planets.size() * 60 * 3600 * sizeof(QVector2D));
m_glBuffer->release();
}
void GLWindow::renderNow()
{
if (!isExposed())
return;
bool needsInitialize = false;
bool enableDebug = false;
if (std::getenv("BIOFORMATS_OPENGL_DEBUG"))
enableDebug = true;
if (!glcontext) {
QSurfaceFormat format = requestedFormat();
// OpenGL 2.0 profile with debugging.
format.setVersion(2, 0);
format.setProfile(QSurfaceFormat::NoProfile);
if (enableDebug)
{
format.setOption(QSurfaceFormat::DebugContext);
}
format.setSamples(8);
format.setDepthBufferSize(24);
glcontext = new QOpenGLContext(this);
glcontext->setFormat(format);
glcontext->create();
makeCurrent();
if (enableDebug)
{
// The debug logger is broken on Windows for Qt 5.2 and earlier, so don't use.
#if !defined(Q_OS_WIN) || QT_VERSION >= 0x050300
logger = new QOpenGLDebugLogger(this);
connect(logger, SIGNAL(messageLogged(QOpenGLDebugMessage)),
this, SLOT(logMessage(QOpenGLDebugMessage)),
Qt::DirectConnection);
if (logger->initialize())
{
logger->startLogging(QOpenGLDebugLogger::SynchronousLogging);
logger->enableMessages();
}
#endif // !defined(Q_OS_WIN) || QT_VERSION >= 0x050300
}
needsInitialize = true;
}
makeCurrent();
if (needsInitialize)
{
initializeOpenGLFunctions();
initialize();
}
render();
glcontext->swapBuffers(this);
if (animating)
renderLater();
}
void OpenGLWindow::renderNow()
{
if (!isExposed())
return;
// initialize opengl context
bool needsInitialize = false;
if (!m_context) {
m_context = new QOpenGLContext(this);
m_context->setFormat(requestedFormat());
if (m_context->create()) {
m_gl = m_context->versionFunctions<GLFunctions>();
if (!m_gl) {
qCritical("Critical: Unable to initialize OpenGL 4.1 Functions");
exit(EXIT_FAILURE);
}
#ifdef DEBUG_OPENGL
m_logger = new QOpenGLDebugLogger(this);
#endif
needsInitialize = true;
m_tickTimer.start();
m_fpsTimer.start();
} else {
qWarning("Warning: Unable to create OpenGL context");
return;
}
}
m_context->makeCurrent(this);
if (needsInitialize) {
m_gl->initializeOpenGLFunctions();
g_glFunctions = m_gl;
#ifdef DEBUG_OPENGL
if (m_context->hasExtension(QByteArrayLiteral("GL_KHR_debug"))) {
m_logger->initialize();
connect(m_logger,
&QOpenGLDebugLogger::messageLogged,
this,
&OpenGLWindow::handleLogMessage,
Qt::DirectConnection);
m_logger->enableMessages();
m_logger->startLogging(QOpenGLDebugLogger::SynchronousLogging);
const QList<QOpenGLDebugMessage> &preInitErrors = m_logger->loggedMessages();
if (preInitErrors.size()) {
qWarning() << "Warning: Pre-Initialization OpenGL Errors (Qt's fault)";
qWarning() << "--[" << preInitErrors << "]--";
}
} else {
qWarning("OpenGL KHR Debugging not available.");
}
#endif
initialize();
}
// check initialize qpainter context
if (!m_device) {
m_device = new QOpenGLPaintDevice;
m_device->setSize(size());
m_painter = new QPainter(m_device);
m_painter->setRenderHint(QPainter::Antialiasing);
m_painter->setRenderHint(QPainter::TextAntialiasing);
}
if (!m_painter->isActive()) {
m_painter->begin(m_device);
}
// render
float seconds = m_tickTimer.restart() * 0.001f;
if (seconds > 1.0f) seconds = 1.0f;
onTick(seconds);
render();
m_context->swapBuffers(this);
if (m_animating)
renderLater();
}
