void OpenGLEngine::Enable (Shader const* shader, GLuint program)
{
EnableUniformBuffers (shader, program);
EnableTextures (shader, program);
EnableTextureArrays (shader, program);
EnableSamplers (shader, program);
}
void MythRenderOpenGL1::DrawBitmapPriv(uint *textures, uint texture_count,
const QRectF *src, const QRectF *dst,
uint prog)
{
if (prog && !m_programs.contains(prog))
prog = 0;
uint first = textures[0];
EnableShaderObject(prog);
SetBlend(false);
SetColor(255, 255, 255, 255);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
EnableTextures(first);
uint active_tex = 0;
for (uint i = 0; i < texture_count; i++)
{
if (m_textures.contains(textures[i]))
{
ActiveTexture(GL_TEXTURE0 + active_tex++);
glBindTexture(m_textures[textures[i]].m_type, textures[i]);
}
}
UpdateTextureVertices(first, src, dst);
glVertexPointer(2, GL_FLOAT, 0, m_textures[first].m_vertex_data);
glTexCoordPointer(2, GL_FLOAT, 0, m_textures[first].m_vertex_data + TEX_OFFSET);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
ActiveTexture(GL_TEXTURE0);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
}
void MythRenderOpenGL2::DrawBitmapPriv(uint *textures, uint texture_count,
const QRectF *src, const QRectF *dst,
uint prog)
{
if (prog && !m_shader_objects.contains(prog))
prog = 0;
if (prog == 0)
prog = m_shaders[kShaderDefault];
uint first = textures[0];
EnableShaderObject(prog);
SetShaderParams(prog, &m_projection[0][0], "u_projection");
SetShaderParams(prog, &m_transforms.top().m[0][0], "u_transform");
SetBlend(false);
EnableTextures(first);
uint active_tex = 0;
for (uint i = 0; i < texture_count; i++)
{
if (m_textures.contains(textures[i]))
{
ActiveTexture(GL_TEXTURE0 + active_tex++);
glBindTexture(m_textures[textures[i]].m_type, textures[i]);
}
}
m_glBindBuffer(GL_ARRAY_BUFFER, m_textures[first].m_vbo);
UpdateTextureVertices(first, src, dst);
m_glBufferData(GL_ARRAY_BUFFER, kVertexSize, NULL, GL_STREAM_DRAW);
void* target = m_glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
if (target)
memcpy(target, m_textures[first].m_vertex_data, kVertexSize);
m_glUnmapBuffer(GL_ARRAY_BUFFER);
m_glEnableVertexAttribArray(VERTEX_INDEX);
m_glEnableVertexAttribArray(TEXTURE_INDEX);
m_glVertexAttribPointer(VERTEX_INDEX, VERTEX_SIZE, GL_FLOAT, GL_FALSE,
VERTEX_SIZE * sizeof(GLfloat),
(const void *) kVertexOffset);
m_glVertexAttrib4f(COLOR_INDEX, 1.0, 1.0, 1.0, 1.0);
m_glVertexAttribPointer(TEXTURE_INDEX, TEXTURE_SIZE, GL_FLOAT, GL_FALSE,
TEXTURE_SIZE * sizeof(GLfloat),
(const void *) kTextureOffset);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
m_glDisableVertexAttribArray(TEXTURE_INDEX);
m_glDisableVertexAttribArray(VERTEX_INDEX);
m_glBindBuffer(GL_ARRAY_BUFFER, 0);
}
uint MythRenderOpenGL1::CreateHelperTexture(void)
{
if (!m_glTexImage1D)
{
LOG(VB_GENERAL, LOG_WARNING, LOC + "glTexImage1D not available.");
return 0;
}
makeCurrent();
uint width = m_max_tex_size;
uint tmp_tex = CreateTexture(QSize(width, 1), false,
GL_TEXTURE_1D, GL_FLOAT, GL_RGBA,
GL_RGBA16, GL_NEAREST, GL_REPEAT);
if (!tmp_tex)
{
DeleteTexture(tmp_tex);
return 0;
}
float *buf = NULL;
buf = new float[m_textures[tmp_tex].m_data_size];
float *ref = buf;
for (uint i = 0; i < width; i++)
{
float x = (((float)i) + 0.5f) / (float)width;
StoreBicubicWeights(x, ref);
ref += 4;
}
StoreBicubicWeights(0, buf);
StoreBicubicWeights(1, &buf[(width - 1) << 2]);
EnableTextures(tmp_tex);
glBindTexture(m_textures[tmp_tex].m_type, tmp_tex);
m_glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA16, width, 0, GL_RGBA, GL_FLOAT, buf);
LOG(VB_PLAYBACK, LOG_INFO, LOC +
QString("Created bicubic helper texture (%1 samples)") .arg(width));
delete [] buf;
doneCurrent();
return tmp_tex;
}
void MythRenderOpenGL2::DrawBitmapPriv(uint tex, const QRect *src,
const QRect *dst, uint prog, int alpha,
int red, int green, int blue)
{
if (prog && !m_shader_objects.contains(prog))
prog = 0;
if (prog == 0)
prog = m_shaders[kShaderDefault];
EnableShaderObject(prog);
SetShaderParams(prog, &m_projection[0][0], "u_projection");
SetShaderParams(prog, &m_transforms.top().m[0][0], "u_transform");
SetBlend(true);
EnableTextures(tex);
glBindTexture(m_textures[tex].m_type, tex);
m_glBindBuffer(GL_ARRAY_BUFFER, m_textures[tex].m_vbo);
UpdateTextureVertices(tex, src, dst);
m_glBufferData(GL_ARRAY_BUFFER, kVertexSize, NULL, GL_STREAM_DRAW);
void* target = m_glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
if (target)
memcpy(target, m_textures[tex].m_vertex_data, kVertexSize);
m_glUnmapBuffer(GL_ARRAY_BUFFER);
m_glEnableVertexAttribArray(VERTEX_INDEX);
m_glEnableVertexAttribArray(TEXTURE_INDEX);
m_glVertexAttribPointer(VERTEX_INDEX, VERTEX_SIZE, GL_FLOAT, GL_FALSE,
VERTEX_SIZE * sizeof(GLfloat),
(const void *) kVertexOffset);
m_glVertexAttrib4f(COLOR_INDEX, red / 255.0, green / 255.0, blue / 255.0, alpha / 255.0);
m_glVertexAttribPointer(TEXTURE_INDEX, TEXTURE_SIZE, GL_FLOAT, GL_FALSE,
TEXTURE_SIZE * sizeof(GLfloat),
(const void *) kTextureOffset);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
m_glDisableVertexAttribArray(TEXTURE_INDEX);
m_glDisableVertexAttribArray(VERTEX_INDEX);
m_glBindBuffer(GL_ARRAY_BUFFER, 0);
}
void MythRenderOpenGL1::DrawBitmapPriv(uint tex, const QRect *src,
const QRect *dst, uint prog, int alpha,
int red, int green, int blue)
{
if (prog && !m_programs.contains(prog))
prog = 0;
EnableShaderObject(prog);
SetBlend(true);
SetColor(red, green, blue, alpha);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
EnableTextures(tex);
glBindTexture(m_textures[tex].m_type, tex);
UpdateTextureVertices(tex, src, dst);
glVertexPointer(2, GL_FLOAT, 0, m_textures[tex].m_vertex_data);
glTexCoordPointer(2, GL_FLOAT, 0, m_textures[tex].m_vertex_data + TEX_OFFSET);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
}
void RAS_VAOpenGLRasterizer::IndexPrimitivesMulti(RAS_MeshSlot& ms)
{
static const GLsizei stride = sizeof(RAS_TexVert);
bool wireframe = m_drawingmode <= KX_WIREFRAME;
RAS_MeshSlot::iterator it;
GLenum drawmode;
if (ms.m_pDerivedMesh) {
// cannot be handled here, pass to RAS_OpenGLRasterizer
RAS_OpenGLRasterizer::IndexPrimitivesInternal(ms, true);
return;
}
if(!wireframe)
EnableTextures(true);
// use glDrawElements to draw each vertexarray
for(ms.begin(it); !ms.end(it); ms.next(it)) {
if(it.totindex == 0)
continue;
// drawing mode
if(it.array->m_type == RAS_DisplayArray::TRIANGLE)
drawmode = GL_TRIANGLES;
else if(it.array->m_type == RAS_DisplayArray::QUAD)
drawmode = GL_QUADS;
else
drawmode = GL_LINES;
// colors
if (drawmode != GL_LINES && !wireframe) {
if (ms.m_bObjectColor) {
const MT_Vector4& rgba = ms.m_RGBAcolor;
glDisableClientState(GL_COLOR_ARRAY);
glColor4d(rgba[0], rgba[1], rgba[2], rgba[3]);
}
else {
glColor4f(0.0f, 0.0f, 0.0f, 1.0f);
glEnableClientState(GL_COLOR_ARRAY);
}
}
else
glColor4f(0.0f, 0.0f, 0.0f, 1.0f);
glVertexPointer(3, GL_FLOAT, stride, it.vertex->getXYZ());
glNormalPointer(GL_FLOAT, stride, it.vertex->getNormal());
if(!wireframe) {
TexCoordPtr(it.vertex);
if(glIsEnabled(GL_COLOR_ARRAY))
glColorPointer(4, GL_UNSIGNED_BYTE, stride, it.vertex->getRGBA());
}
// here the actual drawing takes places
glDrawElements(drawmode, it.totindex, GL_UNSIGNED_SHORT, it.index);
}
if(!wireframe) {
glDisableClientState(GL_COLOR_ARRAY);
EnableTextures(false);
}
}
