bool AnimeGLWidget::initShaders(QOpenGLShaderProgram &program, QString prefix) { if (!program.addShaderFromSourceFile(QOpenGLShader::Vertex, ":/root/Resources/shaders/" + prefix + "_v.glsl")) { qDebug() << "failed add shader vertex"; return false; } if (!program.addShaderFromSourceFile(QOpenGLShader::Fragment, ":/root/Resources/shaders/" + prefix + "_f.glsl")) { qDebug() << "failed add shader fragment"; return false; } if (!program.link()) { qDebug() << "failed link"; return false; } if (!program.bind()) { qDebug() << "failed bind"; return false; } return true; }
void Scene_polylines_item_private::initializeBuffers(CGAL::Three::Viewer_interface *viewer = 0) const { float lineWidth[2]; viewer->glGetFloatv(GL_LINE_WIDTH_RANGE, lineWidth); line_Slider->setMaximum(lineWidth[1]); QOpenGLShaderProgram *program; //vao for the lines { program = item->getShaderProgram(Scene_polylines_item::PROGRAM_NO_SELECTION, viewer); program->bind(); item->vaos[Edges]->bind(); item->buffers[Edges_Vertices].bind(); item->buffers[Edges_Vertices].allocate(positions_lines.data(), static_cast<int>(positions_lines.size()*sizeof(float))); program->enableAttributeArray("vertex"); program->setAttributeBuffer("vertex",GL_FLOAT,0,4); item->buffers[Edges_Vertices].release(); item->vaos[Edges]->release(); program->release(); nb_lines = positions_lines.size(); positions_lines.clear(); positions_lines.swap(positions_lines); } item->are_buffers_filled = true; }
void Painter::paint_3_2_label( const QMatrix4x4 & viewProjection , float timef) { QOpenGLShaderProgram * program; glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glActiveTexture(GL_TEXTURE0); program = m_programs[LabelDistanceMapProgram]; program->bind(); glBindTexture(GL_TEXTURE_2D, m_hpicgsLabelDM); program->setUniformValue("mvp", viewProjection * m_transforms[0]); m_hpicgsLabel->draw(*this); glBindTexture(GL_TEXTURE_2D, m_portccLabelDM); program->setUniformValue("mvp", viewProjection * m_transforms[1]); m_portccLabel->draw(*this); program->release(); glBindTexture(GL_TEXTURE_2D, 0); glDisable(GL_BLEND); }
void Scene_polylines_item::initializeBuffers(CGAL::Three::Viewer_interface *viewer = 0) const { QOpenGLShaderProgram *program; //vao for the lines { program = getShaderProgram(PROGRAM_NO_SELECTION, viewer); program->bind(); vaos[Edges]->bind(); buffers[Edges_Vertices].bind(); buffers[Edges_Vertices].allocate(positions_lines.data(), static_cast<int>(positions_lines.size()*sizeof(float))); program->enableAttributeArray("vertex"); program->setAttributeBuffer("vertex",GL_FLOAT,0,4); buffers[Edges_Vertices].release(); vaos[Edges]->release(); program->release(); nb_lines = positions_lines.size(); positions_lines.clear(); positions_lines.swap(positions_lines); } are_buffers_filled = true; }
void load() { shader.addShaderFromSourceCode(QOpenGLShader::Vertex, shaderWithHeader(":/shaders/mvp.vert")); shader.addShaderFromSourceCode(QOpenGLShader::Fragment, shaderWithHeader(":/shaders/flat.frag")); shader.link(); cube.load(shader); }
void AbstractKernel::setUniforms(QOpenGLShaderProgram& program, unsigned int pass) { program.setUniformValue("size", m_size); if(pass == Pass::Second) { program.setUniformValue("factor", m_factor); } }
void QQuickShapeConicalGradientShader::initialize() { QOpenGLShaderProgram *prog = program(); m_opacityLoc = prog->uniformLocation("opacity"); m_matrixLoc = prog->uniformLocation("matrix"); m_angleLoc = prog->uniformLocation("angle"); m_translationPointLoc = prog->uniformLocation("translationPoint"); }
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); }
//! [4] void TriangleWindow::initialize() { m_program = new QOpenGLShaderProgram(this); m_program->addShaderFromSourceCode(QOpenGLShader::Vertex, vertexShaderSource); m_program->addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentShaderSource); m_program->link(); m_posAttr = m_program->attributeLocation("posAttr"); m_colAttr = m_program->attributeLocation("colAttr"); m_matrixUniform = m_program->uniformLocation("matrix"); }
void OpenGLWidgetPrivate::initialize() { initializeOpenGLFunctions(); m_program = new QOpenGLShaderProgram; m_program->addShaderFromSourceCode(QOpenGLShader::Vertex, vertexShaderSource); m_program->addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentShaderSource); m_program->link(); m_posAttr = m_program->attributeLocation("posAttr"); m_colAttr = m_program->attributeLocation("colAttr"); m_matrixUniform = m_program->uniformLocation("matrix"); }
void initShader(QOpenGLShaderProgram& _s, const char *_filename) { QString _vertSrc = ShaderCompiler::compile(":/shaders/" + QString(_filename) + ".vert"); QString _fragmentSrc = ShaderCompiler::compile(":/shaders/" + QString(_filename) + ".frag"); _s.addShaderFromSourceCode(QOpenGLShader::Vertex, _vertSrc); _s.addShaderFromSourceCode(QOpenGLShader::Fragment, _fragmentSrc); _s.link(); }
void load() { shader.addShaderFromSourceCode(QOpenGLShader::Vertex, shaderWithHeader(":/shaders/mvp.vert")); shader.addShaderFromSourceCode(QOpenGLShader::Fragment, shaderWithHeader(":/shaders/flat.frag")); texture = unique_ptr<QOpenGLTexture>( new QOpenGLTexture(QImage("../resources/sand.jpg").mirrored())); texture->setMinificationFilter(QOpenGLTexture::LinearMipMapLinear); texture->setMagnificationFilter(QOpenGLTexture::Linear); shader.link(); sphere.load(shader); }
QOpenGLShaderProgram* Painter::createBasicShaderProgram(const QString &vertexShaderFileName, const QString &fragmentShaderFileName) { QOpenGLShaderProgram * program = new QOpenGLShaderProgram(); m_shaders << FileAssociatedShader::getOrCreate( QOpenGLShader::Vertex, vertexShaderFileName, *program); m_shaders << FileAssociatedShader::getOrCreate( QOpenGLShader::Fragment, fragmentShaderFileName, *program); program->bindAttributeLocation("position", 0); program->link(); return program; }
QOpenGLShaderProgram* AbstractPainter::createBasicShaderProgram(const QString &vertexShaderFileName, const QString &fragmentShaderFileName) { QOpenGLShaderProgram * program = new QOpenGLShaderProgram(); program->create(); m_shaders << FileAssociatedShader::getOrCreate( QOpenGLShader::Vertex, vertexShaderFileName, *program); m_shaders << FileAssociatedShader::getOrCreate( QOpenGLShader::Fragment, fragmentShaderFileName, *program); program->link(); return program; }
void useShader(QOpenGLShaderProgram& _s, std::function<void(UniformHandler&)>f) { withCurrentContext([&](QOpenGLFunctions& _gl) { _s.bind(); { UniformHandler _handler(_gl, _s); f(_handler); // Destructor of handler is called here implicitly // by RAII to unbind all textures } _s.release(); }); }
void DVWindow::loadShader(QOpenGLShaderProgram& shader, const char* vshader, const char* fshader) { /* Load the shaders from the qrc. */ shader.addShaderFromSourceFile(QOpenGLShader::Vertex, vshader); QFile res(fshader); res.open(QIODevice::ReadOnly | QIODevice::Text); QString fshaderSrc = res.readAll(); if (!context()->isOpenGLES()) fshaderSrc.prepend("#version 130\n"); shader.addShaderFromSourceCode(QOpenGLShader::Fragment, fshaderSrc); /* Bind the attribute handles. */ shader.bindAttributeLocation("vertex", vertex); shader.bindAttributeLocation("uv", uv); shader.link(); /* Bind so we set the texture sampler uniform values. */ shader.bind(); /* Left image is TEXTURE0. */ shader.setUniformValue("textureL", 0); /* Right image is TEXTURE1. */ shader.setUniformValue("textureR", 1); }
/****************************************************************************** * Renders a 2d polyline in the viewport. ******************************************************************************/ void ViewportSceneRenderer::render2DPolyline(const Point2* points, int count, const ColorA& color, bool closed) { OVITO_STATIC_ASSERT(sizeof(points[0]) == 2*sizeof(GLfloat)); // Load OpenGL shader. QOpenGLShaderProgram* shader = loadShaderProgram("line", ":/core/glsl/lines/line.vs", ":/core/glsl/lines/line.fs"); if(!shader->bind()) throw Exception(tr("Failed to bind OpenGL shader.")); bool wasDepthTestEnabled = glIsEnabled(GL_DEPTH_TEST); glDisable(GL_DEPTH_TEST); GLint vc[4]; glGetIntegerv(GL_VIEWPORT, vc); QMatrix4x4 tm; tm.ortho(vc[0], vc[0] + vc[2], vc[1] + vc[3], vc[1], -1, 1); OVITO_CHECK_OPENGL(shader->setUniformValue("modelview_projection_matrix", tm)); QOpenGLBuffer vertexBuffer; if(glformat().majorVersion() >= 3) { if(!vertexBuffer.create()) throw Exception(tr("Failed to create OpenGL vertex buffer.")); if(!vertexBuffer.bind()) throw Exception(tr("Failed to bind OpenGL vertex buffer.")); vertexBuffer.allocate(points, 2 * sizeof(GLfloat) * count); OVITO_CHECK_OPENGL(shader->enableAttributeArray("position")); OVITO_CHECK_OPENGL(shader->setAttributeBuffer("position", GL_FLOAT, 0, 2)); vertexBuffer.release(); } else { OVITO_CHECK_OPENGL(glEnableClientState(GL_VERTEX_ARRAY)); OVITO_CHECK_OPENGL(glVertexPointer(2, GL_FLOAT, 0, points)); } if(glformat().majorVersion() >= 3) { OVITO_CHECK_OPENGL(shader->disableAttributeArray("color")); OVITO_CHECK_OPENGL(shader->setAttributeValue("color", color.r(), color.g(), color.b(), color.a())); } else { OVITO_CHECK_OPENGL(glColor4(color)); } OVITO_CHECK_OPENGL(glDrawArrays(closed ? GL_LINE_LOOP : GL_LINE_STRIP, 0, count)); if(glformat().majorVersion() >= 3) { shader->disableAttributeArray("position"); } else { OVITO_CHECK_OPENGL(glDisableClientState(GL_VERTEX_ARRAY)); } shader->release(); if(wasDepthTestEnabled) glEnable(GL_DEPTH_TEST); }
void OpenGLWidgetPrivate::render() { const qreal retinaScale = q->devicePixelRatio(); glViewport(0, 0, width() * retinaScale, height() * retinaScale); glClearColor(clearColor[0], clearColor[1], clearColor[2], 1.0f); glClear(GL_COLOR_BUFFER_BIT); m_program->bind(); QMatrix4x4 matrix; matrix.perspective(60.0f, 4.0f/3.0f, 0.1f, 100.0f); matrix.translate(0, 0, -2); const qreal angle = 100.0f * m_frame / 30; matrix.rotate(angle, m_rotAxis); m_program->setUniformValue(m_matrixUniform, matrix); GLfloat vertices[] = { 0.0f, 0.707f, -0.5f, -0.5f, 0.5f, -0.5f }; GLfloat colors[] = { 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f }; glVertexAttribPointer(m_posAttr, 2, GL_FLOAT, GL_FALSE, 0, vertices); glVertexAttribPointer(m_colAttr, 3, GL_FLOAT, GL_FALSE, 0, colors); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); glDrawArrays(GL_TRIANGLES, 0, 3); glDisableVertexAttribArray(1); glDisableVertexAttribArray(0); m_program->release(); ++m_frame; if (m_interval <= 0) q->update(); }
void LightSources::loadShader() { // Standardshader QOpenGLShaderProgram* standardShaderProg = new QOpenGLShaderProgram(); QOpenGLShader vertShader(QOpenGLShader::Vertex); vertShader.compileSourceFile(":/shader/lightsource.vert"); standardShaderProg->addShader(&vertShader); QOpenGLShader fragShader(QOpenGLShader::Fragment); fragShader.compileSourceFile(":/shader/lightsource.frag"); standardShaderProg->addShader(&fragShader); standardShaderProg->link(); // Sonnenshader this->shaderProgram = standardShaderProg; glEnable(GL_TEXTURE_2D); }
//! [5] void TriangleWindow::render() { const qreal retinaScale = devicePixelRatio(); glViewport(0, 0, width() * retinaScale, height() * retinaScale); glClear(GL_COLOR_BUFFER_BIT); m_program->bind(); QMatrix4x4 matrix; matrix.perspective(60.0f, 4.0f/3.0f, 0.1f, 100.0f); matrix.translate(0, 0, -2); matrix.rotate(100.0f * m_frame / screen()->refreshRate(), 0, 1, 0); m_program->setUniformValue(m_matrixUniform, matrix); GLfloat vertices[] = { 0.0f, 0.707f, -0.5f, -0.5f, 0.5f, -0.5f }; GLfloat colors[] = { 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f }; glVertexAttribPointer(m_posAttr, 2, GL_FLOAT, GL_FALSE, 0, vertices); glVertexAttribPointer(m_colAttr, 3, GL_FLOAT, GL_FALSE, 0, colors); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); glDrawArrays(GL_TRIANGLES, 0, 3); glDisableVertexAttribArray(1); glDisableVertexAttribArray(0); m_program->release(); ++m_frame; }
/****************************************************************************** * Renders the geometry as triangle mesh with normals. ******************************************************************************/ void OpenGLArrowPrimitive::renderWithNormals(ViewportSceneRenderer* renderer) { QOpenGLShaderProgram* shader = renderer->isPicking() ? _pickingShader : _shader; if(!shader->bind()) throw Exception(QStringLiteral("Failed to bind OpenGL shader.")); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); shader->setUniformValue("modelview_projection_matrix", (QMatrix4x4)(renderer->projParams().projectionMatrix * renderer->modelViewTM())); if(!renderer->isPicking()) shader->setUniformValue("normal_matrix", (QMatrix3x3)(renderer->modelViewTM().linear().inverse().transposed())); GLint pickingBaseID; if(renderer->isPicking()) { pickingBaseID = renderer->registerSubObjectIDs(elementCount()); renderer->activateVertexIDs(shader, _chunkSize * _verticesPerElement, true); } for(int chunkIndex = 0; chunkIndex < _verticesWithNormals.size(); chunkIndex++, pickingBaseID += _chunkSize) { int chunkStart = chunkIndex * _chunkSize; int chunkSize = std::min(_elementCount - chunkStart, _chunkSize); if(renderer->isPicking()) shader->setUniformValue("pickingBaseID", pickingBaseID); _verticesWithNormals[chunkIndex].bindPositions(renderer, shader, offsetof(VertexWithNormal, pos)); if(!renderer->isPicking()) { _verticesWithNormals[chunkIndex].bindNormals(renderer, shader, offsetof(VertexWithNormal, normal)); _verticesWithNormals[chunkIndex].bindColors(renderer, shader, 4, offsetof(VertexWithNormal, color)); } int stripPrimitivesPerElement = _stripPrimitiveVertexCounts.size() / _chunkSize; int stripVerticesPerElement = std::accumulate(_stripPrimitiveVertexCounts.begin(), _stripPrimitiveVertexCounts.begin() + stripPrimitivesPerElement, 0); OVITO_CHECK_OPENGL(shader->setUniformValue("verticesPerElement", (GLint)stripVerticesPerElement)); OVITO_CHECK_OPENGL(renderer->glMultiDrawArrays(GL_TRIANGLE_STRIP, _stripPrimitiveVertexStarts.data(), _stripPrimitiveVertexCounts.data(), stripPrimitivesPerElement * chunkSize)); int fanPrimitivesPerElement = _fanPrimitiveVertexCounts.size() / _chunkSize; int fanVerticesPerElement = std::accumulate(_fanPrimitiveVertexCounts.begin(), _fanPrimitiveVertexCounts.begin() + fanPrimitivesPerElement, 0); OVITO_CHECK_OPENGL(shader->setUniformValue("verticesPerElement", (GLint)fanVerticesPerElement)); OVITO_CHECK_OPENGL(renderer->glMultiDrawArrays(GL_TRIANGLE_FAN, _fanPrimitiveVertexStarts.data(), _fanPrimitiveVertexCounts.data(), fanPrimitivesPerElement * chunkSize)); _verticesWithNormals[chunkIndex].detachPositions(renderer, shader); if(!renderer->isPicking()) { _verticesWithNormals[chunkIndex].detachNormals(renderer, shader); _verticesWithNormals[chunkIndex].detachColors(renderer, shader); } } if(renderer->isPicking()) renderer->deactivateVertexIDs(shader, true); shader->release(); }
void Painter::renderScene(const Camera &camera) { m_envMap->paint(camera); /* Paint gems */ QOpenGLShaderProgram *gemProgram = (*m_shaderPrograms)[ShaderPrograms::GemProgram]; gemProgram->bind(); gemProgram->enableAttributeArray(0); gemProgram->enableAttributeArray(1); gemProgram->setUniformValue("envmap", 0); gemProgram->setUniformValue("gemStructureMap", 1); gemProgram->setUniformValue("rainbowMap", 2); gemProgram->setUniformValue("eye", camera.eye()); gemProgram->setUniformValue("viewProjection", camera.viewProjection()); m_gl->glActiveTexture(GL_TEXTURE0); m_gl->glBindTexture(GL_TEXTURE_CUBE_MAP, m_envMap->cubeMapTexture()); m_gl->glActiveTexture(GL_TEXTURE1); m_gl->glBindTexture(GL_TEXTURE_CUBE_MAP, m_gemStructureMap->cubeMapTexture()); m_gl->glActiveTexture(GL_TEXTURE2); m_gl->glBindTexture(GL_TEXTURE_CUBE_MAP, m_rainbowMap->cubeMapTexture()); QHash<ShaderPrograms, QOpenGLShaderProgram*> shaderPrograms; shaderPrograms.insert(ShaderPrograms::GemProgram, m_shaderPrograms->value(ShaderPrograms::GemProgram)); shaderPrograms.insert(ShaderPrograms::LighRayProgram, m_shaderPrograms->value(ShaderPrograms::LighRayProgram)); m_sceneRenderer->paint(*m_gl, camera.viewProjection(), shaderPrograms); m_gl->glActiveTexture(GL_TEXTURE0); m_gl->glBindTexture(GL_TEXTURE_CUBE_MAP, 0); m_gl->glActiveTexture(GL_TEXTURE1); m_gl->glBindTexture(GL_TEXTURE_CUBE_MAP, 0); m_gl->glActiveTexture(GL_TEXTURE2); m_gl->glBindTexture(GL_TEXTURE_CUBE_MAP, 0); m_gl->glBindTexture(GL_TEXTURE_2D, 0); gemProgram->disableAttributeArray(0); gemProgram->disableAttributeArray(1); gemProgram->release(); }
QOpenGLShaderProgram *generateShaderProgram(QObject *parent, QByteArray vsrc, QByteArray fsrc) { QOpenGLShaderProgram *program = new QOpenGLShaderProgram(parent); QOpenGLShader *vshader = new QOpenGLShader(QOpenGLShader::Vertex, program); vshader->compileSourceCode(vsrc); if (!vshader->compileSourceCode(vsrc)) qFatal("Error in vertex src:\n%s\n", vsrc.constData()); QOpenGLShader *fshader = new QOpenGLShader(QOpenGLShader::Fragment, program); if (!fshader->compileSourceCode(fsrc)) qFatal("Error in fragment src:\n%s\n", fsrc.constData()); program->addShader(vshader); program->addShader(fshader); if (!program->link()) qFatal("Error linking:\n%s\n%s\n", vsrc.constData(), fsrc.constData()); return program; }
void QQuickShapeRadialGradientShader::initialize() { QOpenGLShaderProgram *prog = program(); m_opacityLoc = prog->uniformLocation("opacity"); m_matrixLoc = prog->uniformLocation("matrix"); m_translationPointLoc = prog->uniformLocation("translationPoint"); m_focalToCenterLoc = prog->uniformLocation("focalToCenter"); m_centerRadiusLoc = prog->uniformLocation("centerRadius"); m_focalRadiusLoc = prog->uniformLocation("focalRadius"); }
void SeaNode::draw(std::stack<QMatrix4x4> &MVStack, QMatrix4x4 cameraMatrix, QMatrix4x4 projectionMatrix, QOpenGLShaderProgram *shader) { QOpenGLShaderProgram *sh = Shaders::waterGeometryProgram; MVStack.push(MVStack.top()); MVStack.top().translate(this->translation); //Convert the quat to a matrix, may be a performance leak. QMatrix4x4 tempRot; tempRot.rotate(this->rotation.normalized()); MVStack.top() *= tempRot; //If the node is a leaf, draw its contents if(leaf) { Shaders::bind(sh); glUniformMatrix4fv(sh->uniformLocation("modelViewMatrix"), 1, GL_FALSE, MVStack.top().constData()); glUniformMatrix4fv(sh->uniformLocation("cameraInverseMatrix"), 1, GL_FALSE, cameraMatrix.inverted().constData()); glUniformMatrix4fv(sh->uniformLocation("perspectiveMatrix"), 1, GL_FALSE, projectionMatrix.constData()); glUniformMatrix4fv(sh->uniformLocation("normalMatrix"), 1, GL_FALSE, MVStack.top().inverted().transposed().constData()); int r = (id & 0x000000FF) >> 0; int g = (id & 0x0000FF00) >> 8; int b = (id & 0x00FF0000) >> 16; glUniform4f(sh->uniformLocation("id"), r/255.0f, g/255.0f, b/255.0f, 1.0f); glUniform4fv(sh->uniformLocation("color"), 1, color); struct timeval start; gettimeofday(&start, NULL); float seconds = ((start.tv_sec % (int) periodicity) + start.tv_usec / 1000000.0) / (periodicity / 4); glActiveTexture(GL_TEXTURE5); glBindTexture(GL_TEXTURE_3D, noiseTexture); //glUniform1i(sh->uniformLocation("noiseTexture"), 5); glUniform1i(sh->uniformLocation("seaWidth"), seaWidth); glUniform1i(sh->uniformLocation("seaHeight"), seaHeight); glUniform1f(sh->uniformLocation("time"), seconds); this->primitive->draw(); Shaders::release(sh); } else {
void AssimpScene::draw( OpenGLFunctions & gl , QOpenGLShaderProgram & program , const GLenum mode) { if (!m_valid) return; if (!program.isLinked()) return; std::vector<AssimpMesh *>::const_iterator i = m_meshes.begin(); const std::vector<AssimpMesh *>::const_iterator iEnd = m_meshes.end(); program.bind(); program.setUniformValue("model", m_transform * m_normalize); for (; i != iEnd; ++i) { AssimpMesh * mesh(*i); program.setUniformValue("diffuse", mesh->material.diffuse); program.setUniformValue("ambient", mesh->material.ambient); program.setUniformValue("specular", mesh->material.specular); program.setUniformValue("emissive", mesh->material.emissive); program.setUniformValue("shininess", mesh->material.shininess); program.setUniformValue("texCount", mesh->material.texCount); if (mesh->material.texCount > 0) { program.setUniformValue("difftex", 0); gl.glActiveTexture(GL_TEXTURE0); gl.glBindTexture(GL_TEXTURE_2D, mesh->material.texture); } mesh->vao.bind(); gl.glDrawElements(mode, mesh->faces * 3, GL_UNSIGNED_INT, nullptr); mesh->vao.release(); if (mesh->material.texCount > 0) gl.glBindTexture(GL_TEXTURE_2D, 0); } program.release(); }
// Wireframe OpenGL drawing void Scene_polylines_item::drawEdges(CGAL::Three::Viewer_interface* viewer) const { if(!are_buffers_filled) { computeElements(); initializeBuffers(viewer); } vaos[Edges]->bind(); attribBuffers(viewer, PROGRAM_NO_SELECTION); QOpenGLShaderProgram *program = getShaderProgram(PROGRAM_NO_SELECTION); program->bind(); program->setAttributeValue("colors", this->color()); viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(nb_lines/4)); program->release(); vaos[Edges]->release(); if(d->draw_extremities) { Scene_group_item::drawEdges(viewer); } }
SeaNode::SeaNode(Primitive *p, std::string name) : SceneGraph(p, name) { seaWidth = 256; seaHeight = 256; periodicity = 512; //Create noise texture float frequency = 1.0 / pow(2.0, 5); noiseData = new GLfloat[seaWidth * seaHeight * (int) periodicity]; for(int z = 0; z < (int) periodicity; z++) { for(int y = 0; y < seaHeight; y++) { for(int x = 0; x < seaWidth; x++) { noiseData[z * (seaWidth * seaHeight) + y * seaWidth + x] = scaled_raw_noise_3d(0.0, 1.0, x * frequency, y * frequency, z * frequency); } } } glGenTextures(1, &noiseTexture); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_3D, noiseTexture); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_MIRRORED_REPEAT); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexImage3D(GL_TEXTURE_3D, 0, GL_R16, seaWidth, seaHeight, periodicity, 0, GL_RED, GL_FLOAT, (void*) noiseData); glBindTexture(GL_TEXTURE_3D, 0); QOpenGLShaderProgram *sh = Shaders::waterGeometryProgram; Shaders::bind(sh); glActiveTexture(GL_TEXTURE5); glBindTexture(GL_TEXTURE_3D, noiseTexture); glUniform1i(sh->uniformLocation("noiseTexture"), 5); Shaders::release(sh); }
QOpenGLShaderProgram* Viewer::declare_program(int name, const char* v_shader, const char* f_shader) const { // workaround constness issues in Qt Viewer* viewer = const_cast<Viewer*>(this); if(d->shader_programs[name]) { return d->shader_programs[name]; } else { QOpenGLShaderProgram *program = new QOpenGLShaderProgram(viewer); if(!program->addShaderFromSourceFile(QOpenGLShader::Vertex,v_shader)) { std::cerr<<"adding vertex shader FAILED"<<std::endl; } if(!program->addShaderFromSourceFile(QOpenGLShader::Fragment,f_shader)) { std::cerr<<"adding fragment shader FAILED"<<std::endl; } if(isOpenGL_4_3()) { if(strcmp(f_shader,":/cgal/Polyhedron_3/resources/shader_flat.f" ) == 0) { if(!program->addShaderFromSourceFile(QOpenGLShader::Geometry,":/cgal/Polyhedron_3/resources/shader_flat.g" )) { std::cerr<<"adding geometry shader FAILED"<<std::endl; } } if(strcmp(f_shader,":/cgal/Polyhedron_3/resources/solid_wireframe_shader.f" ) == 0) { if(!program->addShaderFromSourceFile(QOpenGLShader::Geometry,":/cgal/Polyhedron_3/resources/solid_wireframe_shader.g" )) { std::cerr<<"adding geometry shader FAILED"<<std::endl; } } } program->bindAttributeLocation("colors", 1); program->link(); d->shader_programs[name] = program; return program; } }
void csSurface::draw(QOpenGLShaderProgram& program) { if( _initRequired ) { initialize(); } if( _meshInfo.isEmpty() ) { return; } glDisable(GL_CULL_FACE); program.setUniformValue("cs_Model", _model); program.setUniformValue("cs_zMin", _meshInfo.zMin()); program.setUniformValue("cs_zInterval", _meshInfo.zInterval()); program.setUniformValue("cs_ColorMap", TMU_COLORMAP); _surface->bind(); const int vertexLoc = program.attributeLocation("cs_Vertex"); program.enableAttributeArray(vertexLoc); program.setAttributeBuffer(vertexLoc, GL_FLOAT, 0, 3); _colorTexture->bind(TMU_COLORMAP, QOpenGLTexture::ResetTextureUnit); _strip->bind(); const int numStrips = _meshInfo.rowCount() -1; const int numVertPerStrip = 2*_meshInfo.columnCount(); for(int y = 0; y < numStrips; y++) { const GLuint offset = sizeof(GLuint)*y*numVertPerStrip; const GLvoid *indices = (GLvoid*)offset; glDrawElements(GL_TRIANGLE_STRIP, numVertPerStrip, GL_UNSIGNED_INT, indices); } _strip->release(); _colorTexture->release(); program.disableAttributeArray(vertexLoc); _surface->release(); }