void QGLView::initializeVertexBuffer(ModelType type, const void *bufferData, int bufferLength)
{
QOpenGLBuffer *glBuffer = new QOpenGLBuffer(QOpenGLBuffer::VertexBuffer);
glBuffer->create();
glBuffer->setUsagePattern(QOpenGLBuffer::StaticDraw);
glBuffer->bind();
glBuffer->allocate(bufferData, bufferLength);
glBuffer->release();
m_vertexBufferMap.insert(type, glBuffer);
}
/******************************************************************************
* 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);
}
QOpenGLBuffer* GLImageProcessor::buildQuadTextured() const
{
QOpenGLBuffer* lpvbo = new QOpenGLBuffer();
typedef struct
{
float xyz[3];
float uv[2];
} VertexUV;
VertexUV Vertices[] =
{
{ { -1.0f, -1.0f, 0.0f }, { 0.0f, 0.0f } },
{ { -1.0f, 1.0f, 0.0f }, { 0.0f, 1.0f } },
{ { 1.0f, 1.0f, 0.0f }, { 1.0f, 1.0f } },
{ { 1.0f, -1.0f, 0.0f }, { 1.0f, 0.0f } }
};
const size_t BufferSize = sizeof(Vertices);
const size_t VertexSize = sizeof(Vertices[0]);
const size_t UVOffset = sizeof(Vertices[0].xyz);
// Setup our vertex buffer object.
lpvbo->create();
lpvbo->bind();
lpvbo->allocate(Vertices, BufferSize);
lpvbo->bind();
QOpenGLFunctions *f = QOpenGLContext::currentContext()->functions();
f->glEnableVertexAttribArray(0);
f->glEnableVertexAttribArray(1);
f->glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, VertexSize, 0);
f->glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, VertexSize, reinterpret_cast<void *>(UVOffset));
lpvbo->release();
return lpvbo;
}
void OpenGLVideoPrivate::bindAttributes(VideoShader* shader, const QRectF &t, const QRectF &r)
{
const bool tex_rect = shader->textureTarget() == GL_TEXTURE_RECTANGLE;
// also check size change for normalizedROI computation if roi is not normalized
const bool roi_changed = valiad_tex_width != material->validTextureWidth() || roi != r || video_size != material->frameSize();
const int tc = shader->textureLocationCount();
if (roi_changed) {
roi = r;
valiad_tex_width = material->validTextureWidth();
video_size = material->frameSize();
}
if (tex_target != shader->textureTarget()) {
tex_target = shader->textureTarget();
update_geo = true;
}
QRectF& target_rect = rect;
if (target.isValid()) {
if (roi_changed || target != t) {
target = t;
update_geo = true;
}
} else {
if (roi_changed) {
update_geo = true;
}
}
if (!update_geo)
goto end;
//qDebug("updating geometry...");
geometry.setRect(target_rect, material->mapToTexture(0, roi));
if (tex_rect) {
geometry.setTextureCount(tc);
for (int i = 1; i < tc; ++i) {
// tc can > planes, but that will compute chroma plane
geometry.setTextureRect(material->mapToTexture(i, roi), i);
}
}
update_geo = false;
if (!try_vbo)
goto end;
{ //VAO scope BEGIN
#if QT_VAO
if (try_vao) {
//qDebug("updating vao...");
if (!vao.isCreated()) {
if (!vao.create()) {
try_vao = false;
qDebug("VAO is not supported");
}
}
}
QOpenGLVertexArrayObject::Binder vao_bind(&vao);
Q_UNUSED(vao_bind);
#endif
if (!vbo.isCreated()) {
if (!vbo.create()) {
try_vbo = false; // not supported by OpenGL
try_vao = false; // also disable VAO. destroy?
qWarning("VBO is not supported");
goto end;
}
}
//qDebug("updating vbo...");
vbo.bind(); //check here
vbo.allocate(geometry.data(), geometry.size());
#if QT_VAO
if (try_vao) {
shader->program()->setAttributeBuffer(0, GL_FLOAT, 0, geometry.tupleSize(), geometry.stride());
shader->program()->setAttributeBuffer(1, GL_FLOAT, geometry.tupleSize()*sizeof(float), geometry.tupleSize(), geometry.stride());
if (tex_rect) {
for (int i = 1; i < tc; ++i) {
shader->program()->setAttributeBuffer(i + 1, GL_FLOAT, i*geometry.textureSize() + geometry.tupleSize()*sizeof(float), geometry.tupleSize(), geometry.stride());
}
}
char const *const *attr = shader->attributeNames();
for (int i = 0; attr[i]; ++i) {
shader->program()->enableAttributeArray(i); //TODO: in setActiveShader
}
}
#endif
vbo.release();
} //VAO scope END
end:
#if QT_VAO
if (try_vao && vao.isCreated()) {
vao.bind();
return;
}
#endif
if (try_vbo && vbo.isCreated()) {
vbo.bind();
shader->program()->setAttributeBuffer(0, GL_FLOAT, 0, geometry.tupleSize(), geometry.stride());
shader->program()->setAttributeBuffer(1, GL_FLOAT, geometry.tupleSize()*sizeof(float), geometry.tupleSize(), geometry.stride());
if (tex_rect) {
for (int i = 1; i < tc; ++i) {
shader->program()->setAttributeBuffer(i + 1, GL_FLOAT, i*geometry.textureSize() + geometry.tupleSize()*sizeof(float), geometry.tupleSize(), geometry.stride());
}
}
} else {
shader->program()->setAttributeArray(0, GL_FLOAT, geometry.data(0), geometry.tupleSize(), geometry.stride());
shader->program()->setAttributeArray(1, GL_FLOAT, geometry.data(1), geometry.tupleSize(), geometry.stride());
if (tex_rect) {
for (int i = 1; i < tc; ++i) {
shader->program()->setAttributeArray(i + 1, GL_FLOAT, geometry.data(1), i*geometry.textureSize() + geometry.tupleSize(), geometry.stride());
}
}
}
char const *const *attr = shader->attributeNames();
for (int i = 0; attr[i]; ++i) {
shader->program()->enableAttributeArray(i); //TODO: in setActiveShader
}
}