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();
}
