void CaptureWinGLEngine::shader_YUV()
{
m_screenTextureCount = 3;
glGenTextures(m_screenTextureCount, m_screenTexture);
glActiveTexture(GL_TEXTURE0);
configureTexture(0);
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, m_frameWidth, m_frameHeight, 0,
GL_LUMINANCE, GL_UNSIGNED_BYTE, NULL);
checkError("YUV shader texture 0");
glActiveTexture(GL_TEXTURE1);
configureTexture(1);
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, m_frameWidth / 2, m_frameHeight / 2, 0,
GL_LUMINANCE, GL_UNSIGNED_BYTE, NULL);
checkError("YUV shader texture 1");
glActiveTexture(GL_TEXTURE2);
configureTexture(2);
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, m_frameWidth / 2, m_frameHeight / 2, 0,
GL_LUMINANCE, GL_UNSIGNED_BYTE, NULL);
checkError("YUV shader texture 2");
bool src_c = m_shaderProgram.addShaderFromSourceCode(
QGLShader::Fragment,
"uniform sampler2D ytex;"
"uniform sampler2D utex;"
"uniform sampler2D vtex;"
"void main()"
"{"
" vec2 xy = vec2(gl_TexCoord[0].xy);"
" float y = 1.1640625 * (texture2D(ytex, xy).r - 0.0625);"
" float u = texture2D(utex, xy).r - 0.5;"
" float v = texture2D(vtex, xy).r - 0.5;"
" float r = y + 1.59765625 * v;"
" float g = y - 0.390625 * u - 0.8125 *v;"
" float b = y + 2.015625 * u;"
" gl_FragColor = vec4(r, g, b, 1.0);"
"}"
);
if (!src_c)
fprintf(stderr, "OpenGL Error: YUV shader compilation failed.\n");
m_shaderProgram.bind();
}
void SmokeShader::setup()
{
createProgramWithShaders();
configureProgramWithShaders();
createTexture();
configureTexture();
MatrixTransform::setup();
}
void SmokeShader::render(const glm::mat4& matrix)
{
configureProgramWithShaders();
configureTexture();
MatrixTransform::render(matrix);
glUseProgram(0);
}
void CaptureWinGLEngine::shader_YUY2(__u32 format)
{
m_screenTextureCount = 1;
glGenTextures(m_screenTextureCount, m_screenTexture);
configureTexture(0);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_frameWidth / 2, m_frameHeight, 0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
checkError("YUY2 shader");
QString codeHead = QString("uniform sampler2D tex;"
"uniform float texl_w;"
"uniform float tex_w;"
"void main()"
"{"
" float y, u, v;"
" vec4 luma_chroma;"
" float pixelx = gl_TexCoord[0].x;"
" float pixely = gl_TexCoord[0].y;"
" float xcoord = floor(pixelx * tex_w);"
);
QString codeBody = shader_YUY2_invariant(format);
QString codeTail = QString(" float r = y + 1.5958 * v;"
" float g = y - 0.39173 * u - 0.81290 * v;"
" float b = y + 2.017 * u;"
" gl_FragColor = vec4(r, g, b, 1.0);"
"}"
);
bool src_ok = m_shaderProgram.addShaderFromSourceCode(
QGLShader::Fragment, QString("%1%2%3").arg(codeHead, codeBody, codeTail)
);
if (!src_ok)
fprintf(stderr, "OpenGL Error: YUY2 shader compilation failed.\n");
m_shaderProgram.bind();
}
void CaptureWinGLEngine::shader_BGR()
{
m_screenTextureCount = 1;
glGenTextures(m_screenTextureCount, m_screenTexture);
configureTexture(0);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, m_frameWidth, m_frameHeight, 0,
GL_RGB, GL_UNSIGNED_BYTE, NULL);
checkError("BGR shader");
bool src_c = m_shaderProgram.addShaderFromSourceCode(
QGLShader::Fragment,
"uniform sampler2D tex;"
"void main()"
"{"
" vec4 color = texture2D(tex, gl_TexCoord[0].xy);"
" gl_FragColor = vec4(color.b, color.g, color.r, 1.0);"
"}"
);
if (!src_c)
fprintf(stderr, "OpenGL Error: BGR shader compilation failed.\n");
m_shaderProgram.bind();
}
void CaptureWinGLEngine::changeShader()
{
m_formatChange = false;
clearShader();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, m_frameWidth, m_frameHeight, 0, 0, 1);
resizeGL(QGLWidget::width(), QGLWidget::height());
checkError("Render settings.\n");
switch (m_frameFormat) {
case V4L2_PIX_FMT_YUYV:
case V4L2_PIX_FMT_YVYU:
case V4L2_PIX_FMT_UYVY:
case V4L2_PIX_FMT_VYUY:
shader_YUY2(m_frameFormat);
break;
case V4L2_PIX_FMT_YUV420:
case V4L2_PIX_FMT_YVU420:
shader_YUV();
break;
case V4L2_PIX_FMT_RGB32:
m_screenTextureCount = 1;
glActiveTexture(GL_TEXTURE0);
glGenTextures(m_screenTextureCount, m_screenTexture);
configureTexture(0);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA4, m_frameWidth, m_frameHeight, 0,
GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, NULL);
checkError("RGB32 shader");
break;
case V4L2_PIX_FMT_BGR32:
m_screenTextureCount = 1;
glActiveTexture(GL_TEXTURE0);
glGenTextures(m_screenTextureCount, m_screenTexture);
configureTexture(0);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA4, m_frameWidth, m_frameHeight, 0,
GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, NULL);
checkError("BGR32 shader");
break;
case V4L2_PIX_FMT_RGB555:
m_screenTextureCount = 1;
glActiveTexture(GL_TEXTURE0);
glGenTextures(m_screenTextureCount, m_screenTexture);
configureTexture(0);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB5_A1, m_frameWidth, m_frameHeight, 0,
GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV, NULL);
checkError("RGB555 shader");
break;
case V4L2_PIX_FMT_RGB565:
m_screenTextureCount = 1;
glActiveTexture(GL_TEXTURE0);
glGenTextures(m_screenTextureCount, m_screenTexture);
configureTexture(0);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, m_frameWidth, m_frameHeight, 0,
GL_RGB, GL_UNSIGNED_SHORT_5_6_5, NULL);
checkError("RGB565 shader");
break;
case V4L2_PIX_FMT_BGR24:
shader_BGR();
break;
case V4L2_PIX_FMT_RGB24:
default:
m_screenTextureCount = 1;
glActiveTexture(GL_TEXTURE0);
glGenTextures(m_screenTextureCount, m_screenTexture);
configureTexture(0);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, m_frameWidth, m_frameHeight, 0,
GL_RGB, GL_UNSIGNED_BYTE, NULL);
checkError("Default shader");
break;
}
glClear(GL_COLOR_BUFFER_BIT);
}
void GLTexture::init() {
if (m_fbType == ENone)
Log(ETrace, "Uploading a texture : %s", toString().c_str());
else
Log(ETrace, "Creating a framebuffer : %s", toString().c_str());
if (m_samples > 1) {
int maxSamples = 1;
if (GLEW_ARB_texture_multisample)
glGetIntegerv(GL_MAX_SAMPLES_EXT, &maxSamples);
if (m_samples > maxSamples) {
Log(EWarn, "Attempted to create a multisample framebuffer "
"with an unsupported number of samples (requested=%i, supported=%i)",
m_samples, maxSamples);
m_samples = maxSamples;
}
}
lookupGLConstants();
/* Generate an identifier */
glGenTextures(1, &m_id);
/* Bind to the texture */
glBindTexture(m_glType, m_id);
/* Set the texture filtering / wrapping modes
(don't do this for multisample textures)*/
if (!((m_fbType & EColorBuffer) && m_samples > 1))
configureTexture(); /* Multisample textures don't have these parameters */
if (m_fbType == ENone) {
Assert(m_samples == 1);
refresh();
} else {
/* Create the FBO and bind it */
glGenFramebuffersEXT(1, &m_fboId);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fboId);
AssertEx(glIsFramebufferEXT(m_fboId), "Creating an FBO failed");
bool depthAsTexture = m_fbType & EDepthBuffer;
switch (m_fbType) {
case EColorAndDepthBuffer:
case EColorBuffer: {
if (m_type == ETexture2D) {
if (!depthAsTexture) {
glGenRenderbuffersEXT(1, &m_depthId);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_depthId);
if (m_samples == 1)
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT,
GL_DEPTH_COMPONENT32, m_size.x, m_size.y);
else
glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT,
m_samples, GL_DEPTH_COMPONENT32, m_size.x, m_size.y);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,
GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthId);
} else {
glGenTextures(1, &m_depthId);
glBindTexture(m_glType, m_depthId);
configureTexture();
glTexParameteri(m_glType, GL_TEXTURE_COMPARE_MODE, GL_NONE);
glTexParameteri(m_glType, GL_DEPTH_TEXTURE_MODE, GL_LUMINANCE);
if (m_samples == 1)
glTexImage2D(m_glType, 0, GL_DEPTH_COMPONENT32, m_size.x, m_size.y,
0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL);
else
glTexImage2DMultisample(m_glType,
m_samples, GL_DEPTH_COMPONENT32, m_size.x, m_size.y, GL_FALSE);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_DEPTH_ATTACHMENT, m_glType, m_depthId, 0);
glBindTexture(m_glType, m_id);
}
if (m_samples == 1)
glTexImage2D(m_glType, 0, m_internalFormat, m_size.x, m_size.y,
0, m_format, m_dataFormat, NULL);
else
glTexImage2DMultisample(m_glType,
m_samples, m_internalFormat, m_size.x, m_size.y, GL_FALSE);
if (isMipMapped())
glGenerateMipmapEXT(m_glType);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT, m_glType, m_id, 0);
} else if (m_type == ETextureCubeMap) {
Assert(m_size.x == m_size.y && math::isPowerOfTwo(m_size.x));
Assert(m_fbType == EColorBuffer);
Assert(m_samples == 1);
for (int i=0; i<6; i++)
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, m_internalFormat,
m_size.x, m_size.y, 0, m_format, m_dataFormat, NULL);
if (isMipMapped())
glGenerateMipmapEXT(m_glType);
if (depthAsTexture) {
/* Generate an identifier */
glGenTextures(1, &m_depthId);
glBindTexture(m_glType, m_depthId);
glTexParameteri(m_glType, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(m_glType, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
for (int i=0; i<6; i++)
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_DEPTH_COMPONENT32,
m_size.x, m_size.y, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL);
if (GLEW_EXT_geometry_shader4)
activateSide(-1);
else
activateSide(0);
} else {
glGenRenderbuffersEXT(1, &m_depthId);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_depthId);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT,
GL_DEPTH_COMPONENT32, m_size.x, m_size.y);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,
GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthId);
activateSide(0);
}
} else {
Log(EError, "Unsupported texture type!");
}
}
break;
case EDepthBuffer:
Assert(m_samples == 1);
if (m_depthMode == ECompare) {
glTexParameteri(m_glType, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
glTexParameteri(m_glType, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
}
if (m_type == ETexture2D) {
/* Allocate the texture memory */
glTexImage2D(m_glType, 0, m_internalFormat,
m_size.x, m_size.y, 0, GL_DEPTH_COMPONENT,
m_dataFormat, NULL);
/* Attach the texture as a depth target */
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_DEPTH_ATTACHMENT_EXT, m_glType, m_id, 0);
} else if (m_type == ETextureCubeMap) {
Assert(m_size.x == m_size.y && math::isPowerOfTwo(m_size.x));
for (int i=0; i<6; i++)
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, m_internalFormat,
m_size.x, m_size.y, 0, m_format, m_dataFormat, NULL);
if (GLEW_EXT_geometry_shader4)
activateSide(-1);
else
activateSide(0);
} else {
Log(EError, "Unsupported texture type!");
}
glDrawBuffer(GL_NONE);
glReadBuffer(GL_NONE);
break;
default:
Log(EError, "Invalid render buffer type!");
}
GLenum errorStatusID = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
std::string errorStatus;
switch (errorStatusID) {
case GL_FRAMEBUFFER_COMPLETE_EXT: break;
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:
errorStatus = "Incomplete attachment"; break;
case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
errorStatus = "Unsupported framebuffer format"; break;
case GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT:
errorStatus = "Incomplete framebuffer - duplicate attachment"; break;
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT:
errorStatus = "Incomplete framebuffer - missing attachment"; break;
case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:
errorStatus = "Incomplete framebuffer - invalid dimensions"; break;
case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT:
errorStatus = "Incomplete framebuffer - no draw buffer"; break;
case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT:
errorStatus = "Incomplete framebuffer - invalid formats"; break;
case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT:
errorStatus = "Incomplete framebuffer - no readbuffer"; break;
case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT:
errorStatus = "Incomplete multisample framebuffer"; break;
case GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS:
errorStatus = "Incomplete layer targets"; break;
default:
errorStatus = "Unknown error status"; break;
}
if (!errorStatus.empty())
Log(EError, "FBO Error 0x%x: %s!\nFramebuffer configuration: %s",
errorStatusID, errorStatus.c_str(), toString().c_str());
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, GL_NONE);
}
glBindTexture(m_glType, GL_NONE);
}
