예제 #1
0
GraphicsContext3DPrivate::GraphicsContext3DPrivate(GraphicsContext3D* context, HostWindow* hostWindow, GraphicsContext3D::RenderStyle renderStyle)
    : m_context(context)
    , m_hostWindow(hostWindow)
    , m_surface(0)
    , m_platformContext(0)
    , m_surfaceOwner(0)
    , m_platformContextWatcher(0)
{
    if (renderStyle == GraphicsContext3D::RenderToCurrentGLContext) {
        m_platformContext = QOpenGLContext::currentContext();
        if (m_platformContext)
            m_surface = m_platformContext->surface();

        // Watcher needed to invalidate the GL context if destroyed before this instance
        m_platformContextWatcher = new QtContextWatcher(m_platformContext, this);

        initializeOpenGLFunctions();
        return;
    }

    QOpenGLContext* shareContext = 0;
    if (hostWindow && hostWindow->platformPageClient())
        shareContext = hostWindow->platformPageClient()->openGLContextIfAvailable();

    QOffscreenSurface* surface = new QOffscreenSurface;
    surface->create();
    m_surface = surface;
    m_surfaceOwner = surface;

    m_platformContext = new QOpenGLContext(m_surfaceOwner);
    if (shareContext)
        m_platformContext->setShareContext(shareContext);

    if (!m_platformContext->create()) {
        delete m_platformContext;
        m_platformContext = 0;
        return;
    }

    makeCurrentIfNeeded();

    initializeOpenGLFunctions();
#if USE(GRAPHICS_SURFACE)
    IntSize surfaceSize(m_context->m_currentWidth, m_context->m_currentHeight);
    m_surfaceFlags = GraphicsSurface::SupportsTextureTarget
                    | GraphicsSurface::SupportsSharing;

    if (!surfaceSize.isEmpty())
        m_graphicsSurface = GraphicsSurface::create(surfaceSize, m_surfaceFlags, m_platformContext);
#endif
}
예제 #2
0
파일: Viewer.cpp 프로젝트: lrineau/cgal
void Viewer::init()
{
  // Restore previous viewer state.
  restoreStateFromFile();
  initializeOpenGLFunctions();
  // Define 'Control+Q' as the new exit shortcut (default was 'Escape')
  setShortcut(CGAL::qglviewer::EXIT_VIEWER, Qt::CTRL+Qt::Key_Q);

  // Add custom key description (see keyPressEvent).
  setKeyDescription(Qt::Key_W, "Toggles wire frame display");
  setKeyDescription(Qt::Key_F, "Toggles flat shading display");
  setKeyDescription(Qt::Key_E, "Toggles edges display");
  setKeyDescription(Qt::Key_V, "Toggles vertices display");
  setKeyDescription(Qt::Key_N, "Inverse direction of normals");
  setKeyDescription(Qt::Key_Plus, "Increase size of edges");
  setKeyDescription(Qt::Key_Minus, "Decrease size of edges");
  setKeyDescription(Qt::Key_Plus+Qt::ShiftModifier, "Increase size of vertices");
  setKeyDescription(Qt::Key_Minus+Qt::ShiftModifier, "Decrease size of vertices");
  setKeyDescription(Qt::Key_PageDown, "Increase light (all colors, use shift/alt/ctrl for one rgb component)");
  setKeyDescription(Qt::Key_PageUp, "Decrease light (all colors, use shift/alt/ctrl for one rgb component)");

  // Light default parameters
  glLineWidth(size_edges);
  glEnable(GL_POLYGON_OFFSET_FILL);
  glPolygonOffset(1.0f,1.0f);
  glClearColor(1.0f,1.0f,1.0f,0.0f);

  glDisable(GL_BLEND);
  glDisable(GL_LINE_SMOOTH);
  glDisable(GL_POLYGON_SMOOTH_HINT);
  glBlendFunc(GL_ONE, GL_ZERO);
  glHint(GL_LINE_SMOOTH_HINT, GL_FASTEST);
  compile_shaders();
}
예제 #3
0
	void init(QOpenGLContext* ctx)
	{
		glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)ctx->getProcAddress("glFramebufferTexture");

		if(!ctx->isOpenGLES())
			initializeOpenGLFunctions();
	}
예제 #4
0
CardBuffer::CardBuffer(const CardBuilder& builder)
    : _specifications(builder.specifications())
{
    initializeOpenGLFunctions();
    _object = builder.bufferObject(*this);

    glGenBuffers(BufferCount, _buffers);

    _topCount = builder.topIndices().size();
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _buffers[TopIndex]);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER,
        _topCount * sizeof(GLushort),
        builder.topIndices().constData(),
        GL_STATIC_DRAW);

    _middleCount = builder.middleIndices().size();
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _buffers[MiddleIndex]);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER,
        _middleCount * sizeof(GLushort),
        builder.middleIndices().constData(),
        GL_STATIC_DRAW);

    _bottomCount = builder.bottomIndices().size();
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _buffers[BottomIndex]);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER,
        _bottomCount * sizeof(GLushort),
        builder.bottomIndices().constData(),
        GL_STATIC_DRAW);
}
예제 #5
0
void MainWidget::initializeGL()
{
    initializeOpenGLFunctions();



    connect(this, SIGNAL(frameSwapped()), this, SLOT(update()));

    //animationTimer.setSingleShot(true);
    //connect(&animationTimer, SIGNAL(timeout()), this, SLOT(animate()));

    distance = -4;
    trackball = TrackBall(0.0f, QVector3D(0, 1, 0), TrackBall::Sphere);

    glClearColor(0.05, 0.05, 0.05, 1);

    // Enable depth buffer
    glEnable(GL_DEPTH_TEST);

    // Enable back face culling
    glEnable(GL_CULL_FACE);
    glFrontFace(GL_CCW);
    glCullFace(GL_BACK);

    initShaders();
    initTextures();

    geometries = new GeometryEngine(&programearth, &programearthnobump);
    gshhs = new gshhsData(&programgshhs);
    skybox = new SkyBox(&programskybox);

 }
예제 #6
0
GraphicsLayer13::GraphicsLayer13()
{
	initializeOpenGLFunctions();

	AppearanceDialog::setBevelsEnabled(true);

	// Disable unused OpenGL features
	glDisable(GL_LIGHTING);
	glDisable(GL_BLEND);

	// Enable OpenGL features
	glEnable(GL_CULL_FACE);
	glEnable(GL_DEPTH_TEST);
	glEnableClientState(GL_VERTEX_ARRAY);

	// Set OpenGL parameters
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glDepthFunc(GL_LEQUAL);
	glFrontFace(GL_CCW);
	setColor(Qt::white);

	glActiveTexture(GL_TEXTURE1);
	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
	glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_ADD_SIGNED);
	glActiveTexture(GL_TEXTURE0);
}
예제 #7
0
void TFInteg2DGL::newResources(int resolution)
{
    auto f = QOpenGLContext::currentContext()->versionFunctions<QOpenGLFunctions_3_3_Core>();
    f->initializeOpenGLFunctions();
    // painter
    painter.initializeGL(":/volren/shaders/quad.vert", ":/volren/shaders/transferfunction/tfinteg2d.frag");
    // new texture 1d
    tex1d.reset(new QOpenGLTexture(QOpenGLTexture::Target1D));
    tex1d->setFormat(QOpenGLTexture::RGBA32F);
    tex1d->setMinMagFilters(QOpenGLTexture::Nearest, QOpenGLTexture::Nearest);
    tex1d->setWrapMode(QOpenGLTexture::ClampToEdge);
    tex1d->setSize(resolution);
    tex1d->allocateStorage();
    // new texture full
    texFull.reset(new QOpenGLTexture(QOpenGLTexture::Target2D));
    texFull->setFormat(QOpenGLTexture::RGBA32F);
    texFull->setMinMagFilters(QOpenGLTexture::Linear, QOpenGLTexture::Linear);
    texFull->setWrapMode(QOpenGLTexture::ClampToEdge);
    texFull->setSize(resolution, resolution);
    texFull->allocateStorage();
    // new texture back
    texBack.reset(new QOpenGLTexture(QOpenGLTexture::Target2D));
    texBack->setFormat(QOpenGLTexture::RGBA32F);
    texBack->setMinMagFilters(QOpenGLTexture::Linear, QOpenGLTexture::Linear);
    texBack->setWrapMode(QOpenGLTexture::ClampToEdge);
    texBack->setSize(resolution, resolution);
    texBack->allocateStorage();
    // new fbo
    newFbo();
}
예제 #8
0
/**
  This initilizes the texture map in opengl
  */
void cwImageTexture::initialize()
{
    initializeOpenGLFunctions();

    glGenTextures(1, &TextureId);
    glBindTexture(GL_TEXTURE_2D, TextureId);

#ifdef Q_OS_WIN
    //Only upload one texture, GL_LINEAR, because some intel cards,
    //don't support npot dxt1 copression, so we just used GL_LINEAR
    //FIXME: ADD to rendering settings! Use mipmaps.
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
#else
    //All other platforms
    GLfloat fLargest;
    glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &fLargest);

    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, fLargest);
#endif
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
    glBindTexture(GL_TEXTURE_2D, 0);
}
예제 #9
0
void OpenGLWindow::initializeGL()
{
  initializeOpenGLFunctions();

  //
  // shader program
  //

  m_program.reset(new QOpenGLShaderProgram(this));
  m_program->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/vshader.glsl");
  m_program->addShaderFromSourceFile(QOpenGLShader::Fragment, ":/fshader.glsl");
  m_program->link();
  m_program->bind();

  //
  // variables
  //

  m_vertexLocation  = m_program->attributeLocation("vertex");
  m_colorLocation  = m_program->attributeLocation("sourceColor");
  m_program->enableAttributeArray(m_vertexLocation);
  m_program->enableAttributeArray(m_colorLocation);

  m_matrixLocation  = m_program->uniformLocation("matrix");
}
예제 #10
0
void MapWidget::initializeGL()
{
    initializeOpenGLFunctions();

    QString versionString(QLatin1String(reinterpret_cast<const char*>(glGetString(GL_VERSION))));

    QOpenGLContext *ctx = QOpenGLContext::currentContext();
    Q_UNUSED(ctx);
    lg = new QOpenGLDebugLogger(context());
    lg->initialize();
    lg->startLogging(QOpenGLDebugLogger::SynchronousLogging);
    lg->enableMessages();
    connect(lg, SIGNAL(messageLogged(QOpenGLDebugMessage)), this, SLOT(glLog(QOpenGLDebugMessage)));

    qDebug() << "Driver Version String:" << versionString;
    qDebug() << "Current Context:" << ctx->format();

    //glGetIntegerv(GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX, &gpuTotalMemory);
    //qDebug() << "total" << gpuTotalMemory;

    m_renderer = new Renderer();
    m_renderer->createStaticResources();

    //m_painterOverlay = new PainterOverlay();
}
예제 #11
0
void QFFmpegGLWidget::initializeGL()
{
    initializeOpenGLFunctions();

    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

    glEnable(GL_TEXTURE_2D);
    
    /* The following three commented lines if uncommented generate following errors:
     * undefined reference to `_imp__glShadeModel@4'
     * undefined reference to `_imp__glClearDepth@8'
     * bad reloc address 0x20 in section `.eh_frame'
     */
   // glShadeModel(GL_SMOOTH);
    glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
   // glClearDepth(1.0f);
   // glEnable(GL_DEPTH_TEST);

    glDepthFunc(GL_LEQUAL);
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);



    //---------------------
    m_vshaderA = new QOpenGLShader(QOpenGLShader::Vertex);
    m_vshaderA->compileSourceCode(g_vertextShader);
    m_fshaderA = new QOpenGLShader(QOpenGLShader::Fragment);
    m_fshaderA->compileSourceCode(g_fragmentShader);
    m_programA = new QOpenGLShaderProgram;
    m_programA->addShader(m_vshaderA);
    m_programA->addShader(m_fshaderA);
    m_programA->link();

    int positionHandle=m_programA->attributeLocation("aPosition");
    int textureHandle=m_programA->attributeLocation("aTextureCoord");

    glVertexAttribPointer(positionHandle, 3, GL_FLOAT, false,
                          5 * sizeof(GLfloat), m_verticesA);

    glEnableVertexAttribArray(positionHandle);

    glVertexAttribPointer(textureHandle, 2, GL_FLOAT, false,
                          5 * sizeof(GLfloat), &m_verticesA[3]);

    glEnableVertexAttribArray(textureHandle);

    int i=m_programA->uniformLocation("Ytex");
    glUniform1i(i, 0);
    i=m_programA->uniformLocation("Utex");
    glUniform1i(i, 1);
    i=m_programA->uniformLocation("Vtex");
    glUniform1i(i, 2);


    // glViewport(0, 0, width, height);


    //timer->start(30);
}
예제 #12
0
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 SurfaceGraph::initializeGL()
{
    initializeOpenGLFunctions();

    glClearColor(0, 0, 0, 1);


    initShaders();
    initTextures();

    // Enable depth buffer
    glEnable(GL_DEPTH_TEST);

    // Enable back face culling
    glEnable(GL_CULL_FACE);

    // Change znear - zfar
    double fovy = 45.0f;
    double aspect = 1.333f;
    double zNear = 0.1f;
    double zFar = 100.0f;

    GLdouble xmin, xmax, ymin, ymax;
    ymax = zNear * tan( fovy * M_PI / 360.0 );
    ymin = -ymax;
    xmin = ymin * aspect;
    xmax = ymax * aspect;

    glFrustum( xmin, xmax, ymin, ymax, zNear, zFar );

    geometries = new GeometryEngine;

    // Use QBasicTimer because its faster than QTimer
    timer.start(12, this);
}
예제 #14
0
파일: xyz.cpp 프로젝트: Madzzzz/3D-APPS
void XYZ::initVertexBufferObjects()
{
    initializeOpenGLFunctions();

    m_vertices = new Vertex[6];

    //Possisjon
    m_vertices[0].set_xyz(0.0, 0.0, 0.0);
    m_vertices[1].set_xyz(1.0, 0.0, 0.0);
    m_vertices[2].set_xyz(0.0, 0.0, 0.0);
    m_vertices[3].set_xyz(0.0, 1.0, 0.0);
    m_vertices[4].set_xyz(0.0, 0.0, 0.0);
    m_vertices[5].set_xyz(0.0, 0.0, 1.0);

    //Farge
    m_vertices[0].set_rgb(1.0, 0.0, 0.0);
    m_vertices[1].set_rgb(1.0, 0.0, 0.0);
    m_vertices[2].set_rgb(0.0, 1.0, 0.0);
    m_vertices[3].set_rgb(0.0, 1.0, 0.0);
    m_vertices[4].set_rgb(0.0, 0.0, 1.0);
    m_vertices[5].set_rgb(0.0, 0.0, 1.0);

    //Sender vertex possisjon og fargedata til et buffer
    glGenBuffers(1, &m_vertexBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer);
    glBufferData(GL_ARRAY_BUFFER, 6*sizeof(Vertex), m_vertices, GL_STATIC_DRAW);


}
예제 #15
0
SegmentGL::SegmentGL(QOpenGLShaderProgram *prog, SatelliteList *satlist, AVHRRSatellite *seglist )
{

    sats = satlist;
    segs = seglist;

    program = prog;

    initializeOpenGLFunctions();

    program->bind();

    vao.create();
    QOpenGLVertexArrayObject::Binder vaoBinder(&vao);

    positionsBuf.create();
    positionsBuf.setUsagePattern(QOpenGLBuffer::DynamicDraw);
    positionsBuf.bind();

    nbrOfVertices = 50;
    positionsBuf.allocate( nbrOfVertices * 3 * sizeof(GLfloat));

    vertexPosition = program->attributeLocation("VertexPosition");
    program->enableAttributeArray(vertexPosition);
    program->setAttributeBuffer(vertexPosition, GL_FLOAT, 0, 3);


}
예제 #16
0
파일: Viewer.cpp 프로젝트: kriolog/cgal
void Viewer::init()
{
  // Restore previous viewer state.
  restoreStateFromFile();
  initializeOpenGLFunctions();
  // Define 'Control+Q' as the new exit shortcut (default was 'Escape')
  setShortcut(EXIT_VIEWER, Qt::CTRL+Qt::Key_Q);

  // Add custom key description (see keyPressEvent).
  setKeyDescription(Qt::Key_W, "Toggles wire frame display");
  setKeyDescription(Qt::Key_F, "Toggles flat shading display");
  setKeyDescription(Qt::Key_E, "Toggles edges display");
  setKeyDescription(Qt::Key_V, "Toggles vertices display");

  // Light default parameters
  ::glLineWidth(1.4f);
  ::glPointSize(4.f);
  ::glEnable(GL_POLYGON_OFFSET_FILL);
  ::glPolygonOffset(1.0f,1.0f);
  ::glClearColor(1.0f,1.0f,1.0f,0.0f);
  ::glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);

  ::glEnable(GL_LIGHTING);

  ::glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);

  ::glShadeModel(GL_FLAT);
  ::glDisable(GL_BLEND);
  ::glDisable(GL_LINE_SMOOTH);
  ::glDisable(GL_POLYGON_SMOOTH_HINT);
  ::glBlendFunc(GL_ONE, GL_ZERO);
  ::glHint(GL_LINE_SMOOTH_HINT, GL_FASTEST);
  compile_shaders();
}
예제 #17
0
void TriangleSurface::draw(GLint positionAttribute, GLint normalAttribute, GLint
                           textureAttribute)
{
    // Har en array av strukturer (noen Vertex objekter) som skal splittes på to
    // attributter i vertex shader. stride blir her størrelsen av hver struktur
    // Må bruke offset for start
    initializeOpenGLFunctions();//makeCurrent();
    int offset = 0;
    glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer);
    glVertexAttribPointer(positionAttribute, 3, GL_FLOAT, GL_FALSE,
                          sizeof(Vertex), reinterpret_cast<const void*> (offset));
    offset = 3*sizeof(GLfloat);
    glVertexAttribPointer(normalAttribute, 3, GL_FLOAT, GL_FALSE,
                          sizeof(Vertex), reinterpret_cast<const void*> (offset));
    // Tekstur
    if (textureAttribute != -1)
    {
        //glUniform1i(colorAttribute, 0);
        offset = 6*sizeof(GLfloat);
        //glBindBuffer(GL_ARRAY_BUFFER, m_textureBuffer);
        glVertexAttribPointer(textureAttribute, 2, GL_FLOAT, GL_FALSE,
                              sizeof(Vertex), reinterpret_cast<const void*> (offset));
        //glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, m_texture);
    }
    //glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer);
    glDrawArrays(GL_TRIANGLES, 0, m_antallVertices);
    //qDebug() << "TriangleSurface::draw() " << ++i;
}
예제 #18
0
bool QVROSGViewer::initProcess(QVRProcess* /* p */)
{
    // Qt-based OpenGL function pointers
    initializeOpenGLFunctions();

    // FBO
    glGenFramebuffers(1, &_fbo);
    glBindFramebuffer(GL_FRAMEBUFFER, _fbo);
    glGenTextures(1, &_fboDepthTex);
    glBindTexture(GL_TEXTURE_2D, _fboDepthTex);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 1, 1,
            0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
    glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, _fboDepthTex, 0);

    // OSG
    // Since we always only have to deal with one OpenGL context, we set up
    // just one graphics window with a dummy size, and in render() resize and
    // reuse it as necessary.
    _graphicsWindow = _viewer.setUpViewerAsEmbeddedInWindow(0, 0, 640, 480);
    _viewer.setSceneData(_model.get());
    _viewer.realize();

    return true;
}
예제 #19
0
GLSubView::GLSubView(Session *sPtr, QWidget *parent) :
    QGLWidget(parent),
    sessionPtr(sPtr)
{
    makeCurrent();

    initializeOpenGLFunctions();

    glGenBuffers(1, &gratVBO);
    glGenBuffers(1, &gratBorderVBO);

    glBindBuffer(GL_ARRAY_BUFFER, gratVBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(linearInnerPoints),
                 linearInnerPoints, GL_DYNAMIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, gratBorderVBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(linearBorderPoints),
                 linearBorderPoints, GL_DYNAMIC_DRAW);

    innerGratPoints = linearInnerCount;
    borderGratPoints = linearBorderCount;

    doneCurrent();

    setAutoFillBackground(false);
}
 TexturedCubeRenderer( TexturedCube* const cube ):
     m_cube( cube ),
     m_vertexBuffer( QOpenGLBuffer::VertexBuffer ),
     m_texture( QOpenGLTexture::Target2D )
 {
     initializeOpenGLFunctions( );
     // 创建着色器、顶点缓存以及纹理
     const char* vertexShaderSource =
             "attribute highp vec3 position;\
             attribute highp vec3 normal;\
     attribute highp vec2 texCoord;\
     uniform mat4 modelMatrix;\
     uniform mat4 viewMatrix;\
     uniform mat4 projectionMatrix;\
     varying highp vec2 v_texCoord;\
     varying highp vec3 v_normal;\
     void main( void )\
     {\
         gl_Position = projectionMatrix *\
                 viewMatrix *\
                 modelMatrix *\
                 vec4( position, 1.0 );\
         v_texCoord = texCoord;\
         v_normal = normal;\
     }";
예제 #21
0
void TFInteg2DGL::newFbo()
{
    auto f = QOpenGLContext::currentContext()->versionFunctions<QOpenGLFunctions_3_3_Core>();
    f->initializeOpenGLFunctions();
    // new fbo
    fbo.reset([](){
        GLuint* fboPtr = new GLuint();
        QOpenGLContext::currentContext()->functions()->glGenFramebuffers(1, fboPtr);
        return fboPtr;
    }(), [](GLuint* fboPtr){
        QOpenGLContext::currentContext()->functions()->glDeleteFramebuffers(1, fboPtr);
    });
    GLint oFbo;
    f->glGetIntegerv(GL_FRAMEBUFFER_BINDING, &oFbo);
    f->glBindFramebuffer(GL_FRAMEBUFFER, *fbo);
    f->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texFull->textureId(), 0);
    f->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, texBack->textureId(), 0);
    GLenum bufs[2] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 };
    f->glDrawBuffers(2, bufs);
    f->glBindFramebuffer(GL_FRAMEBUFFER, oFbo);
    GLenum status;
    status = f->glCheckFramebufferStatus(GL_FRAMEBUFFER);
    switch (status)
    {
    case GL_FRAMEBUFFER_COMPLETE:
        break;
    default:
        std::cout << "framebuffer back incomplete" << std::endl;
    }
}
예제 #22
0
void QtVLCWidget::initializeGL()
{
    // In this example the widget's corresponding top-level window can change
    // several times during the widget's lifetime. Whenever this happens, the
    // QOpenGLWidget's associated context is destroyed and a new one is created.
    // Therefore we have to be prepared to clean up the resources on the
    // aboutToBeDestroyed() signal, instead of the destructor. The emission of
    // the signal will be followed by an invocation of initializeGL() where we
    // can recreate all resources.
    connect(context(), &QOpenGLContext::aboutToBeDestroyed, this, &QtVLCWidget::cleanup);

    initializeOpenGLFunctions();

    vertexBuffer.create();
    vertexBuffer.bind();
    vertexBuffer.allocate(g_vertex_buffer_data, sizeof(g_vertex_buffer_data));

    vertexIndexBuffer.create();
    vertexIndexBuffer.bind();
    vertexIndexBuffer.allocate(g_element_buffer_data, sizeof(g_element_buffer_data));

    m_program = new QOpenGLShaderProgram;
    m_program->addShaderFromSourceCode(QOpenGLShader::Vertex, vertexShaderSource);
    m_program->addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentShaderSource);
    m_program->link();

    m_program->setUniformValue("texture", 0);

    m_program->bindAttributeLocation("position", 0);
}
예제 #23
0
TextureWriter::TextureWriter(QOpenGLShaderProgram *prog)
{

    program = prog;

    initializeOpenGLFunctions();


    program->bind();

    vao.create();
    QOpenGLVertexArrayObject::Binder vaoBinder(&vao);

    positionsBuf.create();
    positionsBuf.setUsagePattern(QOpenGLBuffer::DynamicDraw);
    positionsBuf.bind();
    vertexPosition = program->attributeLocation("VertexPosition");
    program->enableAttributeArray(vertexPosition);
    program->setAttributeBuffer(vertexPosition, GL_FLOAT, 0, 2);

    texcoordBuf.create();
    texcoordBuf.setUsagePattern(QOpenGLBuffer::DynamicDraw);
    texcoordBuf.bind();
    vertexTexCoord = program->attributeLocation("VertexTexCoord");
    program->enableAttributeArray(vertexTexCoord);
    program->setAttributeBuffer(vertexTexCoord, GL_FLOAT, 0, 1);

    glGenTextures(1, &texturelineId);


}
예제 #24
0
bool Painter::initialize()
{
    initializeOpenGLFunctions();

    glClearColor(1.f, 1.f, 1.f, 0.f);

    m_transform.scale(2.f, 0.16f, 2.f);
    m_transform.translate(-.5f, 0.f, -.5f);

    // prepare vao and vbo
    m_vao.create();
    m_vao.bind();

    m_vertices.create();
    m_vertices.setUsagePattern(QOpenGLBuffer::StaticDraw);
    glEnableVertexAttribArray(0);

    m_vao.release();    

    // create Texture
    m_height = getOrCreateTexture("data/height.png");

    // create shader program
    m_program = createBasicShaderProgram("data/exercise6.vert", "data/exercise6.frag");

    return true;
}
예제 #25
0
파일: grid.cpp 프로젝트: fundies/PolyEditQT
void Grid::render()
{

    initializeOpenGLFunctions();

    // Alpha
    glEnable (GL_BLEND);

    if (alwaysVisible)
        glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO);
    else
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    glDisable(GL_TEXTURE_2D);
    glBegin(GL_LINES);

    for (auto i : mcs)
    {
        QColor c = i.color();
        glColor4f(c.red()/255.f, c.green()/255.f, c.blue()/255.f, c.alpha()/255.f);
        glVertex2f(i.rx(), i.ry());
    }

    glEnd();

    // Reset color to white
    glColor4f(1,1,1,1);

    glDisable(GL_BLEND);
}
예제 #26
0
cubemaker::cubemaker() : indexBuf(QOpenGLBuffer::IndexBuffer)
{
  // Generate 2 VBOs
  initializeOpenGLFunctions();
  makeCubePls();

}
예제 #27
0
Scene::Scene()
{
    initializeOpenGLFunctions();

    this->setSkyBox(NULL);
    m_root.setName ("root");
    this->setRenderType (DEFERRED_SHADING);
    m_mainRenderTarget = new RenderTarget();
    m_mainRenderTarget->setType (RenderTarget::TargetType::ON_SCREEN);
    bloom_fbo1 = new RenderBuffer(1024,768);
    bloom_fbo2 = new RenderBuffer(1024,768);
    bloom_fbo3 = new RenderBuffer(1024,768);
    TMesh * mesh = new TMesh();
    mesh->pushVertex (VertexData(QVector3D(-1,-1,0),QVector2D(0,0)));
    mesh->pushVertex (VertexData(QVector3D(1,-1,0),QVector2D(1,0)));
    mesh->pushVertex (VertexData(QVector3D(1,1,0),QVector2D(1,1)));
    mesh->pushVertex (VertexData(QVector3D(-1,1,0),QVector2D(0,1)));
    mesh->pushIndex (0);
    mesh->pushIndex (1);
    mesh->pushIndex (2);
    mesh->pushIndex (0);
    mesh->pushIndex (2);
    mesh->pushIndex (3);
    mesh->setMaterial (MaterialPool::getInstance ()->createOrGetMaterial ("default"));
    mesh->finishWithoutNormal ();
    m_quad = new Entity();
    m_quad->addMesh (mesh);

    m_guiCamera = new Camera();
    m_guiCamera->setOrtho (0,1024,0,768,0.01,1000);
    m_guiCamera->setPos (QVector3D(0,0,0));

    m_renderType = DEFERRED_SHADING;
}
예제 #28
0
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();
}
예제 #29
0
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();
}
예제 #30
0
void AnimeGLWidget::initializeGL()
{
    initializeOpenGLFunctions();

    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    if (!initShaders(m_textureShaderProgram, "texture"))
    {
        close();
        return;
    }
    m_textureShaderProgram.setUniformValue("texture", 0);

    if (!initShaders(m_lineShaderProgram, "line"))
    {
        close();
        return;
    }

    for (int i = 0; i < m_pEditData->getImageDataListSize(); i++)
    {
        EditData::ImageData *p = m_pEditData->getImageData(i);
        if (!p)
        {
            continue;
        }
        if (p->nTexObj)
        {
            continue;
        }
        p->nTexObj = bindTexture(p->Image);
    }
}