bool MythRenderOpenGL2::InitFeatures(void)
{
m_exts_supported = kGLFeatNone;
static bool glslshaders = true;
static bool check = true;
if (check)
{
check = false;
glslshaders = !getenv("OPENGL_NOGLSL");
if (!glslshaders)
LOG(VB_GENERAL, LOG_INFO, LOC + "Disabling GLSL.");
}
// These should all be present for a valid OpenGL2.0/ES installation
if (m_glShaderSource && m_glCreateShader &&
m_glCompileShader && m_glGetShaderiv &&
m_glGetShaderInfoLog && m_glDeleteShader &&
m_glCreateProgram &&
m_glAttachShader && m_glLinkProgram &&
m_glUseProgram && m_glGetProgramInfoLog &&
m_glDetachShader && m_glGetProgramiv &&
m_glDeleteShader && m_glGetUniformLocation &&
m_glUniform4f && m_glUniformMatrix4fv &&
m_glVertexAttribPointer &&
m_glEnableVertexAttribArray &&
m_glDisableVertexAttribArray &&
m_glBindAttribLocation &&
m_glVertexAttrib4f && glslshaders)
{
LOG(VB_GENERAL, LOG_INFO, LOC + "GLSL supported");
m_exts_supported += kGLSL;
}
MythRenderOpenGL::InitFeatures();
// After rect texture support
if (m_exts_supported & kGLSL)
{
DeleteDefaultShaders();
CreateDefaultShaders();
}
return true;
}
void Fort14::LoadGL()
{
CreateDefaultShaders();
if (!glLoaded)
{
const size_t VertexBufferSize = 4*sizeof(GLfloat)*numNodes;
glGenVertexArrays(1, &VAOId);
glGenBuffers(1, &VBOId);
glGenBuffers(1, &IBOId);
glBindVertexArray(VAOId);
// Send Vertex Data
glBindBuffer(GL_ARRAY_BUFFER, VBOId);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 4*sizeof(GLfloat), 0);
glBufferData(GL_ARRAY_BUFFER, VertexBufferSize, NULL, GL_STATIC_DRAW);
GLfloat* glNodeData = (GLfloat *)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
if (glNodeData)
{
for (unsigned int i=0; i<numNodes; i++)
{
glNodeData[4*i+0] = (GLfloat)nodes[i].normX;
glNodeData[4*i+1] = (GLfloat)nodes[i].normY;
glNodeData[4*i+2] = (GLfloat)nodes[i].z;
glNodeData[4*i+3] = (GLfloat)1.0;
}
} else {
glLoaded = false;
return;
}
if (glUnmapBuffer(GL_ARRAY_BUFFER) == GL_FALSE)
{
glLoaded = false;
DEBUG("ERROR: Unmapping vertex buffer for fort.14");
return;
}
// Send Index Data
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBOId);
const size_t IndexBufferSize = 3*sizeof(GLuint)*numElements; // + sizeof(GLuint)*boundaryNodes.size();
glBufferData(GL_ELEMENT_ARRAY_BUFFER, IndexBufferSize, NULL, GL_STATIC_DRAW);
GLuint* glElementData = (GLuint *)glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY);
if (glElementData)
{
for (unsigned int i=0; i<numElements; i++)
{
glElementData[3*i+0] = (GLuint)elements[i].n1->nodeNumber-1;
glElementData[3*i+1] = (GLuint)elements[i].n2->nodeNumber-1;
glElementData[3*i+2] = (GLuint)elements[i].n3->nodeNumber-1;
}
// for (unsigned int i=0; i<boundaryNodes.size(); i++)
// {
// glElementData[3*numElements+i] = boundaryNodes[i]-1;
// }
} else {
glLoaded = false;
return;
}
if (glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER) == GL_FALSE)
{
glLoaded = false;
DEBUG("ERROR: Unmapping index buffer for fort.14");
return;
}
glBindVertexArray(0);
GLenum errorCheck = glGetError();
if (errorCheck == GL_NO_ERROR)
{
if (VAOId && VBOId && IBOId)
{
glLoaded = true;
emit DataLoadedToGPU(VBOId);
}
} else {
const GLubyte *errString = gluErrorString(errorCheck);
DEBUG("OpenGL Error: " << errString);
glLoaded = false;
}
}
}
bool MythRenderOpenGL2ES::InitFeatures(void)
{
m_exts_supported = kGLFeatNone;
GLint maxtexsz = 0;
GLint maxunits = 0;
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxtexsz);
glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxunits);
m_max_units = maxunits;
m_max_tex_size = (maxtexsz) ? maxtexsz : 512;
if (!(m_glCreateShader && m_glShaderSource && m_glCompileShader &&
m_glAttachShader && m_glGetShaderiv && m_glGetShaderInfoLog &&
m_glDetachShader && m_glDeleteShader && m_glDeleteProgram &&
m_glCreateProgram && m_glLinkProgram && m_glUseProgram &&
m_glGetProgramInfoLog && m_glGetProgramiv && m_glGetUniformLocation &&
m_glUniform1i && m_glUniformMatrix4fv && m_glVertexAttribPointer &&
m_glEnableVertexAttribArray && m_glDisableVertexAttribArray &&
m_glBindAttribLocation && m_glVertexAttrib4f && m_glGenBuffers &&
m_glBindBuffer && m_glDeleteBuffers && m_glBufferData &&
m_glActiveTexture))
{
LOG(VB_GENERAL, LOG_ERR,
"OpenGL2ES Error: Failed to find basic functionality.");
return false;
}
LOG(VB_GENERAL, LOG_INFO, "OpenGL2ES: Found default functionality.");
static bool glslshaders = !getenv("OPENGL_NOGLSL");
GLboolean b;
glGetBooleanv(GL_SHADER_COMPILER, &b);
if (!b)
{
LOG(VB_GENERAL, LOG_INFO, "OpenGL2ES: GLSL not supported.");
glslshaders = false;
}
else if (!glslshaders)
LOG(VB_GENERAL, LOG_NOTICE, "OpenGL2ES: Disabling GLSL.");
static bool framebuffers = !getenv("OPENGL_NOFBO");
if (!framebuffers)
LOG(VB_GENERAL, LOG_NOTICE, "OpenGL2ES: Disabling FrameBuffer Objects.");
static bool vertexbuffers = !getenv("OPENGL_NOVBO");
if (!vertexbuffers)
LOG(VB_GENERAL, LOG_NOTICE, "OpenGL2ES: Disabling VertexBuffer Objects.");
m_extensions = (const char*) glGetString(GL_EXTENSIONS);
LOG(VB_GENERAL, LOG_DEBUG, QString("OpenGL2ES: len=%1: extensions: %2")
.arg(m_extensions.length())
.arg(m_extensions));
m_exts_supported += (glslshaders ? kGLSL : 0) |
(vertexbuffers ? kGLExtVBO : 0) | kGLVertexArray |
kGLMultiTex;
m_default_texture_type = GL_TEXTURE_2D;
// GL_OES_framebuffer_object
if (m_glGenFramebuffers && m_glBindFramebuffer &&
m_glFramebufferTexture2D && m_glCheckFramebufferStatus &&
m_glDeleteFramebuffers && framebuffers)
{
m_exts_supported += kGLExtFBufObj;
LOG(VB_GENERAL, LOG_INFO,
"OpenGL2ES: Framebuffer Objects available.");
}
bool pixelbuffers = !getenv("OPENGL_NOPBO");
bool buffer_procs = m_glMapBuffer && m_glBindBuffer &&
m_glGenBuffers && m_glDeleteBuffers &&
m_glBufferData && m_glUnmapBuffer;
if(m_extensions.contains("GL_ARB_pixel_buffer_object")
&& buffer_procs && pixelbuffers)
{
m_exts_supported += kGLExtPBufObj;
LOG(VB_GENERAL, LOG_INFO,
"OpenGL2ES: Pixelbuffer Objects available.");
}
// GL_OES_mapbuffer
if (m_extensions.contains("GL_OES_mapbuffer") &&
m_glMapBuffer && m_glUnmapBuffer)
{
// NB these functions don't support GL_PIXEL_UNPACK_BUFFER
// so kGLExtPBufObj is not enabled
LOG(VB_GENERAL, LOG_INFO, "OpenGL2ES: OES mapbuffer available.");
}
// GL_EXT_texture_norm16 for GL_RGBA16 support
if (m_extensions.contains("GL_EXT_texture_norm16"))
{
static bool rgba16 = !getenv("OPENGL_NORGBA16");
if (rgba16)
m_exts_supported += kGLExtRGBA16;
else
LOG(VB_GENERAL, LOG_INFO, "OpenGL2ES: Disabling RGBA16 textures");
}
m_exts_used = m_exts_supported;
static bool debugged = false;
if (!debugged)
{
debugged = true;
LOG(VB_GENERAL, LOG_INFO, LOC + QString("Vendor : %1")
.arg((const char*) glGetString(GL_VENDOR)));
LOG(VB_GENERAL, LOG_INFO, LOC + QString("Renderer: %1")
.arg((const char*) glGetString(GL_RENDERER)));
LOG(VB_GENERAL, LOG_INFO, LOC + QString("Version : %1")
.arg((const char*) glGetString(GL_VERSION)));
LOG(VB_GENERAL, LOG_INFO, LOC + QString("Max texture size: %1 x %2")
.arg(m_max_tex_size).arg(m_max_tex_size));
LOG(VB_GENERAL, LOG_INFO, LOC + QString("Max texture units: %1")
.arg(m_max_units));
LOG(VB_GENERAL, LOG_INFO, LOC + QString("Direct rendering: %1")
.arg(IsDirectRendering() ? "Yes" : "No"));
LOG(VB_GENERAL, LOG_INFO, LOC + QString("Extensions Supported: %1")
.arg(m_exts_supported, 0, 16));
}
if (m_exts_supported & kGLSL)
{
DeleteDefaultShaders();
CreateDefaultShaders();
}
return true;
}
