/* Creates the RGBA and luma textures with some default parameters
* @param raspitex_state A pointer to the GL preview state.
* @return Zero if successful.
*/
int raspitexutil_create_textures(RASPITEX_STATE *raspitex_state)
{
GLCHK(glGenTextures(1, &raspitex_state->texture));
GLCHK(glGenTextures(1, &raspitex_state->y_texture));
GLCHK(glGenTextures(1, &raspitex_state->u_texture));
GLCHK(glGenTextures(1, &raspitex_state->v_texture));
return 0;
}
void crop_rotate::init(PapayaMemory* mem)
{
// Initialize crop line mesh
Mesh* mesh = &mem->meshes[PapayaMesh_CropOutline];
mesh->is_line_loop = true;
mesh->index_count = 4;
GLCHK( glGenBuffers(1, &mesh->vbo_handle) );
GLCHK( glBindBuffer(GL_ARRAY_BUFFER, mesh->vbo_handle) );
GLCHK( glBufferData(GL_ARRAY_BUFFER, sizeof(ImDrawVert) * mesh->index_count,
0, GL_DYNAMIC_DRAW) );
}
static
void reshape (int w, int h)
{
width = w;
height = h;
GLCHK(glMatrixMode(GL_PROJECTION));
GLCHK(glLoadIdentity());
gluPerspective(30., 16./9., 1., 40.);
GLCHK(glMatrixMode(GL_MODELVIEW));
}
static void motion_video1(RASPITEX_STATE *raspitex_state) {
GLCHK(glUseProgram(motion_shader.program));
GLCHK(glUniform1i(motion_shader.uniform_locations[0], 0));
GLCHK(glUniform1i(motion_shader.uniform_locations[1], 1));
// Bind video texture
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_EXTERNAL_OES, raspitex_state->texture);
// Bind score texture
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, guiBuffer.id);
GLCHK(glEnableVertexAttribArray(motion_shader.attribute_locations[0]));
GLCHK(glVertexAttribPointer(motion_shader.attribute_locations[0], 2, GL_FLOAT, GL_FALSE, 0, varray));
GLCHK(glDrawArrays(GL_TRIANGLES, 0, 6));
GLCHK(glDisableVertexAttribArray(motion_shader.attribute_locations[0]));
GLCHK(glBindTexture(GL_TEXTURE_2D, 0));
glActiveTexture(GL_TEXTURE0);
}
static int square_redraw(RASPITEX_STATE *state)
{
/* Bind the OES texture which is used to render the camera preview */
GLCHK(glBindTexture(GL_TEXTURE_EXTERNAL_OES, state->texture));
glLoadIdentity();
glRotatef(angle, 0.0, 0.0, 1.0);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, vertices);
glDisableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, tex_coords);
GLCHK(glDrawArrays(GL_TRIANGLES, 0, vcos_countof(tex_coords) / 2));
return 0;
}
void GLWidget::resizeGL(int width, int height)
{
ratio = float(width)/height;
resizeFBOs();
GLCHK( glViewport(0, 0, width, height) );
}
/**
* Creates an OpenGL ES 1.X context.
* @param raspitex_state A pointer to the GL preview state.
* @return Zero if successful.
*/
int raspitexutil_gl_init_1_0(RASPITEX_STATE *raspitex_state)
{
int rc;
const EGLint* attribs = raspitex_state->egl_config_attribs;
const EGLint default_attribs[] =
{
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_DEPTH_SIZE, 16,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES_BIT,
EGL_NONE
};
const EGLint context_attribs[] =
{
EGL_CONTEXT_CLIENT_VERSION, 1,
EGL_NONE
};
if (! attribs)
attribs = default_attribs;
rc = raspitexutil_gl_common(raspitex_state, attribs, context_attribs);
if (rc != 0)
goto end;
GLCHK(glEnable(GL_TEXTURE_EXTERNAL_OES));
rc = raspitexutil_create_textures(raspitex_state);
end:
return rc;
}
bool checkOpenGL(){
QGLWidget *glWidget = new QGLWidget;
QGLContext* glContext = (QGLContext *) glWidget->context();
GLCHK( glContext->makeCurrent() );
qDebug() << "Running the " + QString(AWESOME_BUMP_VERSION);
qDebug() << "Checking OpenGL version...";
qDebug() << "Widget OpenGL: " << glContext->format().majorVersion() << "." << glContext->format().minorVersion() ;
qDebug() << "Context valid: " << glContext->isValid() ;
qDebug() << "OpenGL information: " ;
qDebug() << "VENDOR: " << (const char*)glGetString(GL_VENDOR) ;
qDebug() << "RENDERER: " << (const char*)glGetString(GL_RENDERER) ;
qDebug() << "VERSION: " << (const char*)glGetString(GL_VERSION) ;
qDebug() << "GLSL VERSION: " << (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION) ;
float version = glContext->format().majorVersion() + 0.1 * glContext->format().minorVersion();
delete glWidget;
qDebug() << "Version:" << version;
// check openGL version
if( version < 4.0 )
{
qDebug() << "Error: AwesomeBump does not support openGL versions lower than 4.0 :(" ;
return false;
}
return true;
}
void pm_framestart()
{
#if GL_PSP_statistics
GLCHK(glEnableStatsPSP(GL_STATS_TIMING_PSP));
#else
start = now();
#endif
}
/**
* Advances the texture and EGL image to the next MMAL buffer.
*
* @param display The EGL display.
* @param target The EGL image target e.g. EGL_IMAGE_BRCM_MULTIMEDIA
* @param mm_buf The EGL client buffer (mmal opaque buffer) that is used to
* create the EGL Image for the preview texture.
* @param egl_image Pointer to the EGL image to update with mm_buf.
* @param texture Pointer to the texture to update from EGL image.
* @return Zero if successful.
*/
int raspitexutil_do_update_texture(EGLDisplay display, EGLenum target,
EGLClientBuffer mm_buf, GLuint *texture, EGLImageKHR *egl_image)
{
vcos_log_trace("%s: mm_buf %u", VCOS_FUNCTION, (unsigned) mm_buf);
GLCHK(glBindTexture(GL_TEXTURE_EXTERNAL_OES, *texture));
if (*egl_image != EGL_NO_IMAGE_KHR)
{
/* Discard the EGL image for the preview frame */
eglDestroyImageKHR(display, *egl_image);
*egl_image = EGL_NO_IMAGE_KHR;
}
*egl_image = eglCreateImageKHR(display, EGL_NO_CONTEXT, target, mm_buf, NULL);
GLCHK(glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, *egl_image));
return 0;
}
void GLWidget::bakeEnviromentalMaps(){
if(bDiffuseMapBaked) return;
bDiffuseMapBaked = true;
// ---------------------------------------------------------
// Drawing env - one pass method
// ---------------------------------------------------------
env_program->bind();
m_prefiltered_env_map->bindFBO();
glViewport(0,0,512,512);
objectMatrix.setToIdentity();
objectMatrix.scale(1.0);
objectMatrix.rotate(90.0,1,0,0);
modelViewMatrix = viewMatrix * objectMatrix;
NormalMatrix = modelViewMatrix.normalMatrix();
GLCHK( env_program->setUniformValue("ModelViewMatrix" , modelViewMatrix) );
GLCHK( env_program->setUniformValue("NormalMatrix" , NormalMatrix) );
GLCHK( env_program->setUniformValue("ModelMatrix" , objectMatrix) );
GLCHK( env_program->setUniformValue("ProjectionMatrix" , projectionMatrix) );
GLCHK( glActiveTexture(GL_TEXTURE0) );
GLCHK( m_env_map->bind());
GLCHK( env_mesh->drawMesh(true) );
glBindFramebuffer (GL_FRAMEBUFFER, 0);
glViewport(0, 0, width(), height()) ;
}
static int blur_redraw(RASPITEX_STATE *state) {
// Start with a clear screen
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Bind the OES texture which is used to render the camera preview
glBindTexture(GL_TEXTURE_EXTERNAL_OES, state->texture);
GLCHK(glUseProgram(blur_shader.program));
GLCHK(glEnableVertexAttribArray(blur_shader.attribute_locations[0]));
GLfloat varray[] = {
-1.0f, -1.0f,
1.0f, 1.0f,
1.0f, -1.0f,
-1.0f, 1.0f,
1.0f, 1.0f,
-1.0f, -1.0f,
};
GLCHK(glVertexAttribPointer(blur_shader.attribute_locations[0], 2, GL_FLOAT, GL_FALSE, 0, varray));
GLCHK(glDrawArrays(GL_TRIANGLES, 0, 6));
GLCHK(glDisableVertexAttribArray(blur_shader.attribute_locations[0]));
GLCHK(glUseProgram(0));
return 0;
}
static int motion_redraw(RASPITEX_STATE *raspitex_state) {
// Start with a clear screen
//glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
RedrawGui();
/*
GLCHK(glUseProgram(motion_shader.program));
GLCHK(glUniform1i(motion_shader.uniform_locations[0], 0));
// Bind the OES texture which is used to render the camera preview
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_EXTERNAL_OES, raspitex_state->texture);
// Bind score texture
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, guiBuffer.id);
GLCHK(glEnableVertexAttribArray(motion_shader.attribute_locations[0]));
GLCHK(glVertexAttribPointer(motion_shader.attribute_locations[0], 2, GL_FLOAT, GL_FALSE, 0, varray));
GLCHK(glDrawArrays(GL_TRIANGLES, 0, 6));
GLCHK(glDisableVertexAttribArray(motion_shader.attribute_locations[0]));
GLCHK(glBindTexture(GL_TEXTURE_2D, 0));
glActiveTexture(GL_TEXTURE0);
GLCHK(glUseProgram(0));
*/
motion_video1(raspitex_state);
GLCHK(glEnable(GL_BLEND));
GLCHK(glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
RedrawTextures();
GLCHK(glDisable(GL_BLEND));
update_fps();
return 0;
}
static
void reshape (int w, int h)
{
GLCHK(glViewport(0, 0, w, h));
GLCHK(glMatrixMode(GL_PROJECTION));
GLCHK(glLoadIdentity());
GLCHK(glOrtho(-2*16.f/9.f, 2*16.f/9.f, -2, 2, -2, 2));
GLCHK(glMatrixMode(GL_MODELVIEW));
GLCHK(glLoadIdentity());
}
void GLWidget::applyNormalFilter(GLuint input_tex){
GLCHK( glViewport(0,0,width(),height()) );
GLCHK( glUniformSubroutinesuiv( GL_FRAGMENT_SHADER, 1, &subroutines["mode_normal_filter"]) );
GLCHK( filters_program->setUniformValue("quad_scale", QVector2D(1.0,1.0)) );
GLCHK( filters_program->setUniformValue("quad_pos" , QVector2D(0.0,0.0)) );
GLCHK( glActiveTexture(GL_TEXTURE0) );
GLCHK( glBindTexture(GL_TEXTURE_2D, input_tex) );
GLCHK( quad_mesh->drawMesh(true) );
}
bool checkOpenGL(){
QGLWidget *glWidget = new QGLWidget;
QGLContext* glContext = (QGLContext *) glWidget->context();
GLCHK( glContext->makeCurrent() );
qDebug() << "Running the " + QString(AWESOME_BUMP_VERSION);
qDebug() << "Checking OpenGL version...";
qDebug() << "Widget OpenGL:" << QString("%1.%2").arg(glContext->format().majorVersion()).arg(glContext->format().minorVersion());
qDebug() << "Context valid:" << glContext->isValid() ;
qDebug() << "OpenGL information:" ;
qDebug() << "VENDOR:" << (const char*)glGetString(GL_VENDOR) ;
qDebug() << "RENDERER:" << (const char*)glGetString(GL_RENDERER) ;
qDebug() << "VERSION:" << (const char*)glGetString(GL_VERSION) ;
qDebug() << "GLSL VERSION:" << (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION) ;
float version = glContext->format().majorVersion() + 0.1 * glContext->format().minorVersion();
Performance3DSettings::openGLVersion = version;
#ifdef USE_OPENGL_330
Performance3DSettings::openGLVersion = 3.3;
#endif
delete glWidget;
qDebug() << "Version:" << version;
#ifdef USE_OPENGL_330
// check openGL version
if( version < 3.3 )
{
qDebug() << "Error: This version of AwesomeBump does not support openGL versions lower than 3.3 :(" ;
return false;
}
#else
// check openGL version
if( version < 4.0 )
{
qDebug() << "Error: AwesomeBump does not support openGL versions lower than 4.0 :(" ;
return false;
}
#endif
return true;
}
int main(int argc, char* argv[])
{
psp_log("main starting\n");
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
glutInitWindowSize(480, 272);
glutCreateWindow( __FILE__ );
glutKeyboardFunc(keydown);
glutKeyboardUpFunc(keyup);
glutJoystickFunc(joystick, 0);
glutReshapeFunc(reshape);
glutDisplayFunc(display);
GLCHK(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 4, 4, 0, GL_RGB, GL_UNSIGNED_BYTE, texture));
glutMainLoop();
return 0;
}
void GLWidget::copyTexToFBO(GLuint input_tex,QGLFramebufferObject* dst){
dst->bind();
GLCHK( glViewport(0,0,dst->width(),dst->height()) );
GLCHK( glUniformSubroutinesuiv( GL_FRAGMENT_SHADER, 1, &subroutines["mode_normal_filter"]) );
GLCHK( filters_program->setUniformValue("quad_scale", QVector2D(1.0,1.0)) );
GLCHK( filters_program->setUniformValue("quad_pos" , QVector2D(0.0,0.0)) );
GLCHK( glActiveTexture(GL_TEXTURE0) );
GLCHK( glBindTexture(GL_TEXTURE_2D, input_tex) );
quad_mesh->drawMesh(true);
dst->bindDefault();
}
bool checkOpenGL(){
QGLWidget *glWidget = new QGLWidget;
QGLContext* glContext = (QGLContext *) glWidget->context();
GLCHK( glContext->makeCurrent() );
int glMajorVersion, glMinorVersion;
glMajorVersion = glContext->format().majorVersion();
glMinorVersion = glContext->format().minorVersion();
qDebug() << "Running the " + QString(AWESOME_BUMP_VERSION);
qDebug() << "Checking OpenGL version...";
qDebug() << "Widget OpenGL:" << QString("%1.%2").arg(glMajorVersion).arg(glMinorVersion);
qDebug() << "Context valid:" << glContext->isValid() ;
qDebug() << "OpenGL information:" ;
qDebug() << "VENDOR:" << (const char*)glGetString(GL_VENDOR) ;
qDebug() << "RENDERER:" << (const char*)glGetString(GL_RENDERER) ;
qDebug() << "VERSION:" << (const char*)glGetString(GL_VERSION) ;
qDebug() << "GLSL VERSION:" << (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION) ;
Display3DSettings::openGLVersion = GL_MAJOR + (GL_MINOR * 0.1);
delete glWidget;
qDebug() << QString("Version: %1.%2").arg(glMajorVersion).arg(glMinorVersion);
// check openGL version
if( glMajorVersion < GL_MAJOR || (glMajorVersion == GL_MAJOR && glMinorVersion < GL_MINOR))
{
qDebug() << QString("Error: This version of AwesomeBump does not support openGL versions lower than %1.%2 :(").arg(GL_MAJOR).arg(GL_MINOR) ;
return false;
}
return true;
}
static void set_lights()
{
int i;
if (!lights_changed)
return;
lights_changed = 0;
for(i = 0; i < 4; i++) {
GLCHK(glLightfv(GL_LIGHT0+i, GL_DIFFUSE, lights[i].diffuse));
GLCHK(glLightfv(GL_LIGHT0+i, GL_SPECULAR, lights[i].specular));
GLCHK(glLightfv(GL_LIGHT0+i, GL_AMBIENT, lights[i].ambient));
GLCHK(glLightf(GL_LIGHT0+i, GL_SPOT_EXPONENT, exponent));
GLCHK(glLightf(GL_LIGHT0+i, GL_SPOT_CUTOFF, cutoff));
if (i < nlights)
GLCHK(glEnable(GL_LIGHT0+i));
else
GLCHK(glDisable(GL_LIGHT0+i));
}
}
static
void display (void)
{
GLCHK(glShadeModel(GL_SMOOTH));
GLCHK(glClear(GL_COLOR_BUFFER_BIT));
GLCHK(glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE));
//GLCHK(glEnable(GL_BLEND));
GLCHK(glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
GLCHK(glMatrixMode(GL_TEXTURE));
GLCHK(glLoadIdentity());
if (texmat) {
//GLCHK(glScalef(.5,.5,1));
if (projmat) {
static const float m[] = {
#if 0
.5, .5, 0, 0,
-.5, .5, 0, 0,
0, 0, 1, 0,
-.5, -1, 0, 1,
#else
#if 0
0.651613, 0.000000, 0.000000, 0.000000,
-0.433013, -0.758819, -0.866026, -0.866026,
-0.250000, 0.314313, -0.500000, -0.500000,
0.5000000, 0.500000, 3.000000, 3.000000,
#else
0.651613, 0.000000, 0.000000, 0.000000,
-0.433013, -0.758819, 0, -0.866026,
-0.250000, 0.314313, 0, -0.500000,
0.5000000, 0.500000, 0, 3.000000,
#endif
#endif
};
glLoadMatrixf(m);
} else {
static const float m[] = {
.5, 0, 0, 0,
0, .5, 0, 0,
0, 0, 0, 0,
0, 0, 0, 1,
};
glLoadMatrixf(m);
}
}
if (clamp) {
GLCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
GLCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
} else {
GLCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT));
GLCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT));
}
if (smooth) {
GLCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
GLCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
} else {
GLCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST));
GLCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST));
}
GLCHK(glEnable(GL_TEXTURE_2D));
glBegin(GL_TRIANGLE_FAN);
#if 1
glTexCoord2f(0,0);
glVertex2f(-2,-2);
glTexCoord2f(2,0);
glVertex2f(2,-2);
glTexCoord2f(2,2);
glVertex2f(2,2);
glTexCoord2f(0,2);
glVertex2f(-2,2);
#else
glTexCoord2f(-2,-2);
glVertex2f(-2,-2);
glTexCoord2f(2,-2);
glVertex2f(2,-2);
glTexCoord2f(2,2);
glVertex2f(2,2);
glTexCoord2f(-2,2);
glVertex2f(-2,2);
#endif
glEnd();
glutSwapBuffers();
glutPostRedisplay();
}
static
void joystick (unsigned int buttonMask, int x, int y, int z)
{
GLCHK(glClearColor(x * 1.0f/2000.0f + 0.5f, y * 1.0f/2000.0f + 0.5f, 1.0f, 1.0f));
}
static void drawscene(float angle)
{
int i;
GLCHK(glDisable(GL_TEXTURE_2D));
GLCHK(glEnable(GL_BLEND));
//GLCHK(glEnable(GL_CULL_FACE));
GLCHK(glEnable(GL_DEPTH_TEST));
GLCHK(glDisable(GL_LIGHTING));
GLCHK(glShadeModel(render & R_FLAT ? GL_FLAT : GL_SMOOTH));
GLCHK(glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
for(i = 0; i < nlights; i++) {
GLfloat pos[] = { 1, 0, 0, 1 };
GLfloat vec[] = {-1, 0, 0 };
GLCHK(glPushMatrix());
GLCHK(glRotatef(angle + 90*i, 0,0,1));
GLCHK(glRotatef(-40, 0,1,0));
GLCHK(glTranslatef(.9,.9,0));
GLCHK(glLightfv(GL_LIGHT0 + i, GL_POSITION, pos));
GLCHK(glLightfv(GL_LIGHT0 + i, GL_SPOT_DIRECTION, vec));
GLCHK(glColor4fv(lights[i].specular));
glBegin(GL_LINE_STRIP);
glVertex3fv(pos);
glColor4f(0,0,0,0);
glVertex3f(pos[0]+vec[0],
pos[1]+vec[1],
pos[2]+vec[2]);
glEnd();
GLCHK(glPopMatrix());
}
GLCHK(glScalef(3,3,1));
GLCHK(glDisable(GL_BLEND));
/* axes */
glBegin(GL_LINES);
glColor3f(1,0,0);
glVertex3f(0,0,0);
glVertex3f(1,0,0);
glColor3f(0,1,0);
glVertex3f(0,0,0);
glVertex3f(0,1,0);
glColor3f(1,1,0);
glVertex3f(0,0,0);
glVertex3f(0,0,1);
glEnd();
if (render & R_TEX)
GLCHK(glEnable(GL_TEXTURE_2D));
GLCHK(glEnable(GL_LIGHTING));
#if GL_PSP_bezier_patch
if ((primidx / 3) == 0) {
if (0) {
GLCHK(glDrawBezierArraysPSP(prims[primidx%3], MESHX, MESHY, 0));
} else {
idx_t idx[MESHX*MESHY];
int x, y, i;
i = 0;
for(y = 0; y < MESHY-3; y++)
for(x = 0; x < MESHX; x++)
idx[i++] = y*MESHX+x;
GLCHK(glDrawBezierElementsPSP(prims[primidx%3],
MESHX, MESHY-3, IDX_TYPE, idx));
/* need to overlap a row */
i = 0;
for(y = MESHY-4; y < MESHY; y++)
for(x = 0; x < MESHX; x++)
idx[i++] = y*MESHX+x;
GLCHK(glDrawBezierElementsPSP(prims[primidx%3],
MESHX, 4, IDX_TYPE, idx));
}
} else {
if (0) {
GLCHK(glDrawSplineArraysPSP(prims[primidx%3],
MESHX, MESHY,
GL_PATCH_OUTER_INNER_PSP,
GL_PATCH_INNER_INNER_PSP,
0));
} else {
idx_t idx[MESHX*MESHY];
int x, y, i;
i = 0;
for(y = 0; y < MESHY-3; y++)
for(x = 0; x < MESHX; x++)
idx[i++] = y*MESHX+x;
GLCHK(glDrawSplineElementsPSP(prims[primidx%3],
MESHX, MESHY-3,
GL_PATCH_OUTER_OUTER_PSP,
GL_PATCH_INNER_OUTER_PSP,
IDX_TYPE, idx));
/* need to overlap 3 rows */
i = 0;
for(y = MESHY-6; y < MESHY; y++)
for(x = 0; x < MESHX; x++)
idx[i++] = y*MESHX+x;
GLCHK(glDrawSplineElementsPSP(prims[primidx%3],
MESHX, 6,
GL_PATCH_OUTER_OUTER_PSP,
GL_PATCH_OUTER_INNER_PSP,
IDX_TYPE, idx));
}
}
#else
glBegin(GL_QUADS);
for(i = 0; i < MESHY-1; i++) {
int j;
for(j = 0; j < MESHX-1; j++) {
glArrayElement(i*MESHX + j);
glArrayElement(i*MESHX + j+1);
glArrayElement((i+1)*MESHX + j+1);
glArrayElement((i+1)*MESHX + j);
}
}
GLCHK(glEnd());
#endif
GLCHK(glDisable(GL_LIGHTING));
GLCHK(glDisable(GL_TEXTURE_2D));
GLCHK(glShadeModel(GL_SMOOTH));
GLCHK(glEnable(GL_BLEND));
GLCHK(glColor4f(.2,.2,.2,.2));
GLCHK(glBlendFunc(GL_ONE, GL_ONE));
if (render & R_HULL) {
/* draw hull */
for(i = 0; i < MESHY; i++)
GLCHK(glDrawArrays(GL_LINE_STRIP, i*MESHX, MESHX));
for(i = 0; i < MESHX; i++) {
idx_t idx[MESHY];
int j;
for(j = 0; j < MESHY; j++)
idx[j] = i + j*MESHX;
GLCHK(glDrawElements(GL_LINE_STRIP, MESHY, IDX_TYPE, idx));
}
}
if (render & R_NORM) {
/* draw normals */
glBegin(GL_LINES);
for(i = 0; i < MESHX*MESHY; i++) {
glVertex3fv(&mesh[i].x);
glVertex3f(mesh[i].x + mesh[i].nx * .1,
mesh[i].y + mesh[i].ny * .1,
mesh[i].z + mesh[i].nz * .1);
}
glEnd();
}
}
static
void display (void)
{
static GLfloat angle;
angle += delta;
pm_framestart();
GLCHK(glMatrixMode(GL_MODELVIEW));
GLCHK(glLoadIdentity());
if (d_exponent != 0) {
exponent += d_exponent;
if (exponent >= 128)
exponent = 128;
if (exponent < 1)
exponent = 1;
lights_changed = 1;
}
if (d_cutoff != 0) {
cutoff += d_cutoff;
if (cutoff > 90)
cutoff = 90;
if (cutoff < 2)
cutoff = 2;
lights_changed = 1;
}
set_lights();
static const float len = 6;
float se = sinf(elevation * M_PI / 180);
float ce = cosf(elevation * M_PI / 180);
float sb = sinf(bearing * M_PI / 180);
float cb = cosf(bearing * M_PI / 180);
float x = ce * cb * len;
float y = ce * sb * len;
float z = se * len;
GLCHK(glEnable(GL_SCISSOR_TEST));
glLoadIdentity();
gluLookAt(0, 0, len, 0,0,.5, 0,1,0);
GLCHK(glScissor(0,0, width/2, height/2));
GLCHK(glViewport(0,0, width/2, height/2));
GLCHK(glClearColor(.2,.2,.3,1));
GLCHK(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT));
drawscene(angle);
glLoadIdentity();
gluLookAt(-len, 0, .5, 0,0,.5, 0,0,1);
GLCHK(glScissor(width/2,0, width/2, height/2));
GLCHK(glViewport(width/2,0, width/2, height/2));
GLCHK(glClearColor(.3,.2,.2,1));
GLCHK(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT));
drawscene(angle);
glLoadIdentity();
gluLookAt(x,y,z, 0,0,.5, 0,0,1);
GLCHK(glScissor(width/2,height/2, width/2, height/2));
GLCHK(glViewport(width/2,height/2, width/2, height/2));
GLCHK(glClearColor(.2,.2,.2,1));
GLCHK(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT));
drawscene(angle);
glLoadIdentity();
gluLookAt(0, -len, .5, 0,0,.5, 0,0,1);
GLCHK(glScissor(0,height/2, width/2, height/2));
GLCHK(glViewport(0,height/2, width/2, height/2));
GLCHK(glClearColor(.2,.3,.2,1));
GLCHK(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT));
drawscene(angle);
GLCHK(glScissor(0, 0, width, height));
GLCHK(glViewport(0, 0, width, height));
pm_frameend();
if (shot) {
shot = 0;
screenshot("viewports");
}
glutSwapBuffers();
glutPostRedisplay();
}
int main(int argc, char* argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowSize(480, 272);
glutCreateWindow( __FILE__ );
#if !SYS
glutJoystickFunc(joystick, 0);
#else
glutPassiveMotionFunc(motion);
#endif
glutKeyboardFunc(keydown);
glutKeyboardUpFunc(keyup);
glutSpecialFunc(special_down);
glutSpecialUpFunc(special_up);
glutReshapeFunc(reshape);
glutDisplayFunc(display);
GLCHK(glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE));
GLCHK(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 64, 64, 0,
GL_RGBA, GL_UNSIGNED_BYTE, firefox_start));
GLCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
GLCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
genmesh();
GLCHK(glEnableClientState(GL_VERTEX_ARRAY));
GLCHK(glVertexPointer(3, GL_FLOAT, sizeof(struct vertex), &mesh[0].x));
GLCHK(glEnableClientState(GL_TEXTURE_COORD_ARRAY));
GLCHK(glTexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), &mesh[0].s));
GLCHK(glEnableClientState(GL_NORMAL_ARRAY));
GLCHK(glNormalPointer(GL_FLOAT, sizeof(struct vertex), &mesh[0].nx));
{
GLfloat ambient[] = { .3,.3,.3,1 };
GLCHK(glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient));
GLCHK(glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR));
}
{
GLfloat diff[] = { 1,1,1,1 };
GLfloat spec[] = { 1,1,1,1 };
GLfloat ambient[] = { .4,.4,.4,1 };
GLCHK(glMaterialfv(GL_FRONT, GL_DIFFUSE, diff));
GLCHK(glMaterialfv(GL_FRONT, GL_AMBIENT, ambient));
GLCHK(glMaterialfv(GL_FRONT, GL_SPECULAR, spec));
GLCHK(glMateriali(GL_FRONT, GL_SHININESS, 40));
}
GLCHK(glLockArraysEXT(0, MESHX*MESHY));
GLCHK(glEnable(GL_DEPTH_TEST));
GLCHK(glClearColor(0,0,.5,1));
GLCHK(glEnable(GL_NORMALIZE));
#if GL_PSP_bezier_patch
GLCHK(glPatchSubdivisionPSP(8,8));
//GLCHK(glPatchSubdivisionPSP(16,16));
//GLCHK(glPatchSubdivisionPSP(64,64));
#endif
// GLCHK(glPolygonOffset(1,0));
// GLCHK(glEnable(GL_POLYGON_OFFSET_FILL));
glutMainLoop();
return 0;
}
void GLWidget::paintGL()
{
glReadBuffer(GL_BACK);
// ---------------------------------------------------------
// Drawing env
// ---------------------------------------------------------
bakeEnviromentalMaps();
colorFBO->bindDefault();
GLCHK( glViewport(0, 0, width(), height()) );
if(cameraInterpolation < 1.0){
double w = cameraInterpolation;
camera.position = camera.position*(1-w) + newCamera.position * w;
cameraInterpolation += 0.01;
}
// setting the camera viewpoint
viewMatrix = camera.updateCamera();
colorFBO->bind();
GLCHK( glDisable(GL_CULL_FACE) );
projectionMatrix.setToIdentity();
projectionMatrix.perspective(zoom,ratio,0.1,350.0);
// set to which FBO result will be drawn
GLuint attachments[4] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2 , GL_COLOR_ATTACHMENT3 };
glDrawBuffers(4, attachments);
GLCHK( glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) );
// ---------------------------------------------------------
// Drawing skybox
// ---------------------------------------------------------
skybox_program->bind();
objectMatrix.setToIdentity();
if(skybox_mesh->isLoaded()){
objectMatrix.translate(camera.position);
objectMatrix.scale(150.0);
}
modelViewMatrix = viewMatrix * objectMatrix;
NormalMatrix = modelViewMatrix.normalMatrix();
glDisable(GL_DEPTH_TEST); // disable depth
GLCHK( skybox_program->setUniformValue("ModelViewMatrix" , modelViewMatrix) );
GLCHK( skybox_program->setUniformValue("NormalMatrix" , NormalMatrix) );
GLCHK( skybox_program->setUniformValue("ModelMatrix" , objectMatrix) );
GLCHK( skybox_program->setUniformValue("ProjectionMatrix" , projectionMatrix) );
GLCHK( glActiveTexture(GL_TEXTURE0) );
GLCHK( m_env_map->bind());
GLCHK( skybox_mesh->drawMesh(true) );
// ---------------------------------------------------------
// Drawing model
// ---------------------------------------------------------
QOpenGLShaderProgram* program_ptrs[2] = {program,line_program};
GLCHK( glEnable(GL_CULL_FACE) );
GLCHK( glEnable(GL_DEPTH_TEST) );
GLCHK( glCullFace(GL_FRONT) );
glDisable(GL_POLYGON_OFFSET_LINE);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
for(int pindex = 0 ; pindex < 2 ; pindex ++){
QOpenGLShaderProgram* program_ptr = program_ptrs[pindex];
GLCHK( program_ptr->bind() );
GLCHK( program_ptr->setUniformValue("ProjectionMatrix", projectionMatrix) );
objectMatrix.setToIdentity();
if( fboIdPtrs[0] != NULL){
float fboRatio = float((*(fboIdPtrs[0]))->width())/(*(fboIdPtrs[0]))->height();
objectMatrix.scale(fboRatio,1,fboRatio);
}
if(mesh->isLoaded()){
objectMatrix.scale(0.5/mesh->radius);
objectMatrix.translate(-mesh->centre_of_mass);
}
modelViewMatrix = viewMatrix*objectMatrix;
NormalMatrix = modelViewMatrix.normalMatrix();
float mesh_scale = 0.5/mesh->radius;
GLCHK( program_ptr->setUniformValue("ModelViewMatrix" , modelViewMatrix) );
GLCHK( program_ptr->setUniformValue("NormalMatrix" , NormalMatrix) );
GLCHK( program_ptr->setUniformValue("ModelMatrix" , objectMatrix) );
GLCHK( program_ptr->setUniformValue("meshScale" , mesh_scale) );
GLCHK( program_ptr->setUniformValue("lightPos" , lightPosition) );
GLCHK( program_ptr->setUniformValue("lightDirection" , lightDirection.direction) );
GLCHK( program_ptr->setUniformValue("cameraPos" , camera.get_position()) );
GLCHK( program_ptr->setUniformValue("gui_depthScale" , depthScale) );
GLCHK( program_ptr->setUniformValue("gui_uvScale" , uvScale) );
GLCHK( program_ptr->setUniformValue("gui_uvScaleOffset" , uvOffset) );
GLCHK( program_ptr->setUniformValue("gui_bSpecular" , bToggleSpecularView) );
GLCHK( program_ptr->setUniformValue("gui_bDiffuse" , bToggleDiffuseView) );
GLCHK( program_ptr->setUniformValue("gui_bOcclusion" , bToggleOcclusionView) );
GLCHK( program_ptr->setUniformValue("gui_bHeight" , bToggleHeightView) );
GLCHK( program_ptr->setUniformValue("gui_bNormal" , bToggleNormalView) );
GLCHK( program_ptr->setUniformValue("gui_bRoughness" , bToggleRoughnessView) );
GLCHK( program_ptr->setUniformValue("gui_bMetallic" , bToggleMetallicView) );
GLCHK( program_ptr->setUniformValue("gui_shading_type" , shadingType) );
GLCHK( program_ptr->setUniformValue("gui_shading_model" , shadingModel) );
GLCHK( program_ptr->setUniformValue("gui_SpecularIntensity" , specularIntensity) );
GLCHK( program_ptr->setUniformValue("gui_DiffuseIntensity" , diffuseIntensity) );
GLCHK( program_ptr->setUniformValue("gui_LightPower" , lightPower) );
GLCHK( program_ptr->setUniformValue("gui_LightRadius" , lightRadius) );
// number of mipmaps
GLCHK( program_ptr->setUniformValue("num_mipmaps" , m_env_map->numMipmaps ) );
// 3D settings
GLCHK( program_ptr->setUniformValue("gui_bUseCullFace" , performanceSettings.bUseCullFace) );
GLCHK( program_ptr->setUniformValue("gui_bUseSimplePBR" , performanceSettings.bUseSimplePBR) );
GLCHK( program_ptr->setUniformValue("gui_noTessSub" , performanceSettings.noTessSubdivision) );
GLCHK( program_ptr->setUniformValue("gui_noPBRRays" , performanceSettings.noPBRRays) );
if(performanceSettings.bShowTriangleEdges && pindex == 0){
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
glEnable( GL_POLYGON_OFFSET_FILL );
glPolygonOffset( 1.0f, 1.0f );
GLCHK( program_ptr->setUniformValue("gui_bShowTriangleEdges", true) );
GLCHK( program_ptr->setUniformValue("gui_bMaterialsPreviewEnabled" , true) );
}else{
if(performanceSettings.bShowTriangleEdges){
glDisable( GL_POLYGON_OFFSET_FILL );
glEnable( GL_POLYGON_OFFSET_LINE );
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glPolygonOffset( -2.0f, -2.0f );
glLineWidth(1.0f);
}
GLCHK( program_ptr->setUniformValue("gui_bShowTriangleEdges", performanceSettings.bShowTriangleEdges) );
// Material preview: M key : when triangles are disabled
if(!performanceSettings.bShowTriangleEdges)
GLCHK( program_ptr->setUniformValue("gui_bMaterialsPreviewEnabled" , bool(keyPressed == KEY_SHOW_MATERIALS)) );
}
if( fboIdPtrs[0] != NULL){
int tindeks = 0;
for(tindeks = 0 ; tindeks < MAX_TEXTURES_TYPE ; tindeks++){
GLCHK( glActiveTexture(GL_TEXTURE0+tindeks) );
GLCHK( glBindTexture(GL_TEXTURE_2D, (*(fboIdPtrs[tindeks]))->texture()) );
}
GLCHK( glActiveTexture(GL_TEXTURE0 + tindeks ) );
GLCHK(m_prefiltered_env_map->bind());
tindeks++;
GLCHK( glActiveTexture(GL_TEXTURE0 + tindeks) );
GLCHK( m_env_map->bind());
GLCHK( mesh->drawMesh() );
// set default active texture
glActiveTexture(GL_TEXTURE0);
}
if(!performanceSettings.bShowTriangleEdges) break;
}// end of loop over triangles
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glDisable( GL_POLYGON_OFFSET_LINE );
// return to standard settings
GLCHK( glDisable(GL_CULL_FACE) );
GLCHK( glDisable(GL_DEPTH_TEST) );
// set to which FBO result will be drawn
GLuint attachments2[1] = { GL_COLOR_ATTACHMENT0 };
glDrawBuffers(1, attachments2);
colorFBO->bindDefault();
GLCHK( glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) );
GLCHK( filters_program->bind() );
// do post processing if materials are not shown
if( keyPressed != KEY_SHOW_MATERIALS ){
// -----------------------------------------------------------
// Post processing:
// 1. Bloom (can be disabled/enabled by gui)
// -----------------------------------------------------------
// enable of disable bloom effect
if(performanceSettings.bBloomEffect){
applyGlowFilter(outputFBO->fbo);
copyTexToFBO(outputFBO->fbo->texture(),colorFBO->fbo);
//applyNormalFilter(outputFBO->fbo->texture());
}// end of if bloom effect
// -----------------------------------------------------------
// Post processing:
// 2. DOF (can be disabled/enabled by gui)
// -----------------------------------------------------------
if(performanceSettings.bDofEffect){
applyDofFilter(colorFBO->fbo->texture(),auxFBO->fbo,outputFBO->fbo);
copyTexToFBO(outputFBO->fbo->texture(),colorFBO->fbo);
}
applyNormalFilter(colorFBO->fbo->texture());
}else{ // end of if SHOW MATERIALS TEXTURE DISABLED
GLCHK( applyNormalFilter(colorFBO->fbo->texture()));
}
GLCHK( filters_program->release() );
emit renderGL();
}
void GLWidget::initializeGL()
{
initializeOpenGLFunctions();
glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
makeCurrent();
qglClearColor(QColor::fromCmykF(0.79, 0.79, 0.79, 0.0).dark());
glEnable(GL_DEPTH_TEST);
glEnable(GL_MULTISAMPLE);
glEnable(GL_DEPTH_TEST);
qDebug() << "Loading quad (vertex shader)";
QOpenGLShader *vshader = new QOpenGLShader(QOpenGLShader::Vertex, this);
vshader->compileSourceFile(":/resources/plane.vert");
if (!vshader->log().isEmpty()) qDebug() << vshader->log();
else qDebug() << "done";
qDebug() << "Loading quad (fragment shader)";
QOpenGLShader *fshader = new QOpenGLShader(QOpenGLShader::Fragment, this);
fshader->compileSourceFile(":/resources/plane.frag");
if (!fshader->log().isEmpty()) qDebug() << fshader->log();
else qDebug() << "done";
qDebug() << "Loading quad (tessellation control shader)";
QOpenGLShader *tcshader = new QOpenGLShader(QOpenGLShader::TessellationControl, this);
tcshader->compileSourceFile(":/resources/plane.tcs.vert");
if (!tcshader->log().isEmpty()) qDebug() << tcshader->log();
else qDebug() << "done";
qDebug() << "Loading quad (tessellation evaluation shader)";
QOpenGLShader *teshader = new QOpenGLShader(QOpenGLShader::TessellationEvaluation, this);
teshader->compileSourceFile(":/resources/plane.tes.vert");
if (!teshader->log().isEmpty()) qDebug() << teshader->log();
else qDebug() << "done";
qDebug() << "Loading quad (geometry shader)";
QOpenGLShader *gshader = new QOpenGLShader(QOpenGLShader::Geometry, this);
QFile gFile(":/resources/plane.geom");
gFile.open(QFile::ReadOnly);
qDebug() << gFile.isOpen() << " File";
QTextStream in(&gFile);
QString preambule = "#version 400 core\n"
"layout(triangle_strip, max_vertices = 3) out;\n" ;
QString shaderCode = in.readAll();
gshader->compileSourceCode(preambule+shaderCode);
//gshader->compileSourceFile(in.readAll());
if (!gshader->log().isEmpty()) qDebug() << gshader->log();
else qDebug() << "done";
program = new QOpenGLShaderProgram(this);
program->addShader(vshader);
program->addShader(fshader);
program->addShader(tcshader);
program->addShader(teshader);
program->addShader(gshader);
program->bindAttributeLocation("FragColor",0);
program->bindAttributeLocation("FragNormal",1);
program->bindAttributeLocation("FragGlowColor",2);
program->bindAttributeLocation("FragPosition",3);
GLCHK(program->link());
GLCHK(program->bind());
program->setUniformValue("texDiffuse" , 0);
program->setUniformValue("texNormal" , 1);
program->setUniformValue("texSpecular" , 2);
program->setUniformValue("texHeight" , 3);
program->setUniformValue("texSSAO" , 4);
program->setUniformValue("texRoughness", 5);
program->setUniformValue("texMetallic", 6);
program->setUniformValue("texMaterial", 7);
program->setUniformValue("texDiffuseEnvMap", 8);
program->setUniformValue("texEnvMap" , 9);
// lines shader
qDebug() << "Compiling lines program...";
preambule = QString("#version 400 core\n")+
"layout(line_strip, max_vertices = 3) out;\n" ;
gshader->compileSourceCode(preambule+shaderCode);
line_program = new QOpenGLShaderProgram(this);
line_program->addShader(vshader);
line_program->addShader(fshader);
line_program->addShader(tcshader);
line_program->addShader(teshader);
line_program->addShader(gshader);
line_program->bindAttributeLocation("FragColor",0);
line_program->bindAttributeLocation("FragNormal",1);
line_program->bindAttributeLocation("FragGlowColor",2);
line_program->bindAttributeLocation("FragPosition",3);
GLCHK(line_program->link());
GLCHK(line_program->bind());
line_program->setUniformValue("texDiffuse" , 0);
line_program->setUniformValue("texNormal" , 1);
line_program->setUniformValue("texSpecular" , 2);
line_program->setUniformValue("texHeight" , 3);
line_program->setUniformValue("texSSAO" , 4);
line_program->setUniformValue("texRoughness", 5);
line_program->setUniformValue("texMetallic", 6);
line_program->setUniformValue("texMaterial", 7);
line_program->setUniformValue("texDiffuseEnvMap", 8);
line_program->setUniformValue("texEnvMap" , 9);
delete vshader;
delete fshader;
delete tcshader;
delete teshader;
delete gshader;
// loading sky box shader
qDebug() << "Loading skybox shader (vertex shader)";
vshader = new QOpenGLShader(QOpenGLShader::Vertex, this);
vshader->compileSourceFile(":/resources/skybox.vert.glsl");
if (!vshader->log().isEmpty()) qDebug() << vshader->log();
else qDebug() << "done";
qDebug() << "Loading skybox shader (fragment shader)";
fshader = new QOpenGLShader(QOpenGLShader::Fragment, this);
fshader->compileSourceFile(":/resources/skybox.frag.glsl");
if (!fshader->log().isEmpty()) qDebug() << fshader->log();
else qDebug() << "done";
skybox_program = new QOpenGLShaderProgram(this);
skybox_program->addShader(vshader);
skybox_program->addShader(fshader);
skybox_program->bindAttributeLocation("FragColor",0);
skybox_program->bindAttributeLocation("FragNormal",1);
skybox_program->bindAttributeLocation("FragGlowColor",2);
skybox_program->bindAttributeLocation("FragPosition",3);
GLCHK(skybox_program->link());
GLCHK(skybox_program->bind());
skybox_program->setUniformValue("texEnv" , 0);
// loading enviromental shader
qDebug() << "Loading enviromental shader (vertex shader)";
vshader = new QOpenGLShader(QOpenGLShader::Vertex, this);
vshader->compileSourceFile(":/resources/env.vert");
if (!vshader->log().isEmpty()) qDebug() << vshader->log();
else qDebug() << "done";
qDebug() << "Loading enviromental shader (geometry shader)";
gshader = new QOpenGLShader(QOpenGLShader::Geometry, this);
gshader->compileSourceFile(":/resources/env.geom");
if (!gshader->log().isEmpty()) qDebug() << gshader->log();
else qDebug() << "done";
qDebug() << "Loading enviromental shader (fragment shader)";
fshader = new QOpenGLShader(QOpenGLShader::Fragment, this);
fshader->compileSourceFile(":/resources/env.frag");
if (!fshader->log().isEmpty()) qDebug() << fshader->log();
else qDebug() << "done";
env_program = new QOpenGLShaderProgram(this);
env_program->addShader(vshader);
env_program->addShader(gshader);
env_program->addShader(fshader);
GLCHK(env_program->link());
GLCHK(env_program->bind());
env_program->setUniformValue("texEnv" , 0);
delete vshader;
delete fshader;
delete gshader;
// -------------------------------------------------
// Loading post processing filters
// -------------------------------------------------
qDebug() << "Loading post-processing shader (vertex shader)";
vshader = new QOpenGLShader(QOpenGLShader::Vertex, this);
vshader->compileSourceFile(":/resources/filters_3d.vert");
if (!vshader->log().isEmpty()) qDebug() << vshader->log();
else qDebug() << "done";
qDebug() << "Loading post-processing shader (fragment shader)";
fshader = new QOpenGLShader(QOpenGLShader::Fragment, this);
fshader->compileSourceFile(":/resources/filters_3d.frag");
if (!fshader->log().isEmpty()) qDebug() << fshader->log();
else qDebug() << "done";
filters_program = new QOpenGLShaderProgram(this);
filters_program->addShader(vshader);
filters_program->addShader(fshader);
filters_program->bindAttributeLocation("positionIn", 0);
GLCHK( filters_program->link() );
GLCHK( filters_program->bind() );
GLCHK( filters_program->setUniformValue("layerA" , 0) );
GLCHK( filters_program->setUniformValue("layerB" , 1) );
GLCHK( filters_program->setUniformValue("layerC" , 2) );
GLCHK( filters_program->setUniformValue("layerD" , 3) );
GLCHK( filters_program->setUniformValue("layerE" , 4) );
GLCHK( filters_program->setUniformValue("layerF" , 5) );
GLCHK( filters_program->setUniformValue("layerG" , 6) );
GLCHK( subroutines["mode_normal_filter"] = glGetSubroutineIndex(filters_program->programId(),GL_FRAGMENT_SHADER,"mode_normal_filter") );
GLCHK( subroutines["mode_gauss_filter"] = glGetSubroutineIndex(filters_program->programId(),GL_FRAGMENT_SHADER,"mode_gauss_filter") );
GLCHK( subroutines["mode_bloom_filter"] = glGetSubroutineIndex(filters_program->programId(),GL_FRAGMENT_SHADER,"mode_bloom_filter") );
GLCHK( subroutines["mode_dof_filter"] = glGetSubroutineIndex(filters_program->programId(),GL_FRAGMENT_SHADER,"mode_dof_filter") );
GLCHK( filters_program->release());
delete vshader;
delete fshader;
camera.position.setZ( -0 );
camera.toggleFreeCamera(false);
newCamera.toggleFreeCamera(false);
lightDirection.position.setZ(0);
lightDirection.toggleFreeCamera(false);
lightDirection.radius = 1;
mesh = new Mesh("Core/3D/","Cube.obj");
skybox_mesh = new Mesh("Core/3D/","sky_cube.obj");
env_mesh = new Mesh("Core/3D/","sky_cube_env.obj");
quad_mesh = new Mesh("Core/3D/","quad.obj");
m_prefiltered_env_map = new GLTextureCube(512);
resizeFBOs();
emit readyGL();
}
void GLWidget::applyGlowFilter(QGLFramebufferObject* outputFBO){
applyGaussFilter(colorFBO->getAttachedTexture(1),glowInputColor[0]->fbo,glowOutputColor[0]->fbo);
applyGaussFilter(glowOutputColor[0]->fbo->texture(),glowInputColor[0]->fbo,glowOutputColor[0]->fbo);
applyGaussFilter(glowOutputColor[0]->fbo->texture(),glowInputColor[1]->fbo,glowOutputColor[1]->fbo);
applyGaussFilter(glowOutputColor[1]->fbo->texture(),glowInputColor[1]->fbo,glowOutputColor[1]->fbo);
applyGaussFilter(glowOutputColor[1]->fbo->texture(),glowInputColor[2]->fbo,glowOutputColor[2]->fbo);
applyGaussFilter(glowOutputColor[2]->fbo->texture(),glowInputColor[2]->fbo,glowOutputColor[2]->fbo);
applyGaussFilter(glowOutputColor[2]->fbo->texture(),glowInputColor[3]->fbo,glowOutputColor[3]->fbo);
outputFBO->bind();
GLCHK( glViewport(0,0,outputFBO->width(),outputFBO->height()) );
GLCHK( glUniformSubroutinesuiv( GL_FRAGMENT_SHADER, 1, &subroutines["mode_bloom_filter"]) );
GLCHK( filters_program->setUniformValue("quad_scale", QVector2D(1.0,1.0)) );
GLCHK( filters_program->setUniformValue("quad_pos" , QVector2D(0.0,0.0)) );
GLCHK( glActiveTexture(GL_TEXTURE0) );
GLCHK( glBindTexture(GL_TEXTURE_2D, colorFBO->fbo->texture()) );
GLCHK( glActiveTexture(GL_TEXTURE1) );
GLCHK( glBindTexture(GL_TEXTURE_2D, glowOutputColor[0]->fbo->texture()) );
GLCHK( glActiveTexture(GL_TEXTURE2) );
GLCHK( glBindTexture(GL_TEXTURE_2D, glowOutputColor[1]->fbo->texture()) );
GLCHK( glActiveTexture(GL_TEXTURE3) );
GLCHK( glBindTexture(GL_TEXTURE_2D, glowOutputColor[2]->fbo->texture()) );
GLCHK( glActiveTexture(GL_TEXTURE4) );
GLCHK( glBindTexture(GL_TEXTURE_2D, glowOutputColor[3]->fbo->texture()) );
quad_mesh->drawMesh(true);
GLCHK( glActiveTexture(GL_TEXTURE0) );
outputFBO->bindDefault();
}
void GLWidget::applyDofFilter(GLuint input_tex,
QGLFramebufferObject* auxFBO,
QGLFramebufferObject* outputFBO){
//applyGaussFilter(input_tex,auxFBO,outputFBO,15.0);
GLCHK( glViewport(0,0,outputFBO->width(),outputFBO->height()) );
GLCHK( glUniformSubroutinesuiv( GL_FRAGMENT_SHADER, 1, &subroutines["mode_dof_filter"]) );
GLCHK( filters_program->setUniformValue("quad_scale", QVector2D(1.0,1.0)) );
GLCHK( filters_program->setUniformValue("quad_pos" , QVector2D(0.0,0.0)) );
GLCHK( glActiveTexture(GL_TEXTURE0) );
GLCHK( glBindTexture(GL_TEXTURE_2D, input_tex) );
GLCHK( glActiveTexture(GL_TEXTURE1) );
GLCHK( glBindTexture(GL_TEXTURE_2D, colorFBO->getAttachedTexture(2)) );
GLCHK( glActiveTexture(GL_TEXTURE2) );
GLCHK( glBindTexture(GL_TEXTURE_2D, auxFBO->texture()) );
outputFBO->bind();
quad_mesh->drawMesh(true);
outputFBO->bindDefault();
GLCHK( glActiveTexture(GL_TEXTURE0) );
}
void GLWidget::applyGaussFilter( GLuint input_tex,
QGLFramebufferObject* auxFBO,
QGLFramebufferObject* outputFBO, float radius){
GLCHK( glViewport(0,0,outputFBO->width(),outputFBO->height()) );
GLCHK( glUniformSubroutinesuiv( GL_FRAGMENT_SHADER, 1, &subroutines["mode_gauss_filter"]) );
GLCHK( filters_program->setUniformValue("quad_scale", QVector2D(1.0,1.0)) );
GLCHK( filters_program->setUniformValue("quad_pos" , QVector2D(0.0,0.0)) );
GLCHK( filters_program->setUniformValue("gui_gauss_w" , (float)radius ));
GLCHK( filters_program->setUniformValue("gui_gauss_radius" , (float)radius ));
GLCHK( filters_program->setUniformValue("gui_gauss_mode" , 0 ));
GLCHK( glActiveTexture(GL_TEXTURE0) );
GLCHK( glBindTexture(GL_TEXTURE_2D, input_tex) );
auxFBO->bind();
quad_mesh->drawMesh(true);
auxFBO->bindDefault();
outputFBO->bind();
GLCHK( glViewport(0,0,outputFBO->width(),outputFBO->height()) );
GLCHK( filters_program->setUniformValue("gui_gauss_mode" , 1 ));
GLCHK( glBindTexture(GL_TEXTURE_2D, auxFBO->texture()) );
quad_mesh->drawMesh(true);
outputFBO->bindDefault();
}
