graphic.cpp

Go to the documentation of this file.

// PTF - Psychological Test Framework
// http://ptf.sourceforge.net
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Library General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

#include <ptf/environment/graphic.hpp>
#include <ptf/core/ptfcore.hpp>
#include <SDL_image.h>
#include <math.h>
#include <stdexcept>

Graphic::Graphic() {
    windowOpen = false;
}

Graphic::~Graphic() {
    // clean up textures
    for (int i = 0; i < (int)textures.size(); i++) {
        glDeleteTextures(1, &textures[i]);
    }
}

bool Graphic::createWindow(int w, int h, bool fullscreen) {
    PtfCore::getSingleton().getMessageLog() 
            << MESSAGE("Initializing graphic system and opening window.\n");
    // initialize SDL graphics
    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
        PtfCore::getSingleton().getMessageLog()
                << ERROR("Graphic initialization failed: ") << SDL_GetError() << "\n";
        throw std::runtime_error("Graphic initialization failed.");
    }
    // query current video settings
    if (SDL_GetVideoInfo() == 0) {
        PtfCore::getSingleton().getMessageLog()
                << ERROR("Video query failed: ") << SDL_GetError() << "\n";
        throw std::runtime_error("Video query failed.");
    }
    // set bits per pixel
    width  = w;
    height = h;
    if (fullscreen) {
        bpp = 32;
        SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
        SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
        SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
    }
    else {
        bpp = SDL_GetVideoInfo()->vfmt->BitsPerPixel;
    }
    // set values for red, green, blue, depth buffer and double buffering
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
    // set flags
    int flags;
    if(fullscreen) flags = SDL_OPENGL | SDL_FULLSCREEN;
    else flags = SDL_OPENGL | SDL_RESIZABLE;
    // set video mode
    if ((display = SDL_SetVideoMode(width, height, bpp, flags)) == 0) {
        PtfCore::getSingleton().getMessageLog()
                << ERROR("  Video mode setup failed: ") << SDL_GetError() << "\n";
        throw std::runtime_error("Video mode setup failed.");
    }
    // call OpenGL init
    initOpenGL();
    // set windowOpen and return
    windowOpen = true;
    // don't show mouse cursor
    SDL_ShowCursor(SDL_DISABLE);
    // set window title
    SDL_WM_SetCaption("PTF - Psychological Test Framework", "PTF");
    return true;
}

void Graphic::initOpenGL() {
    // disable unneeded things
    glDisable(GL_CULL_FACE);
    glDisable(GL_DEPTH_TEST);
    glDisable(GL_LIGHTING);
    // select shade model
    glShadeModel(GL_SMOOTH);
    // setup viewport
    glViewport(0, 0, width, height);
    // set clear color to black
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    // set orthographic perspective
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    double wneg = -width  / 2.0;
    double wpos = -wneg   - 1.0;
    double hneg = -height / 2.0;
    double hpos = -hneg   - 1.0;
    gluOrtho2D(wneg, wpos, hneg, hpos);
    // set modelview matrix
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

void Graphic::setBGColor(float r, float g, float b) {
    glClearColor(r, g, b, 1.0f);
}

void Graphic::drawFixationCross(){
    Point pc1; pc1.x =   0; pc1.y =  10;
    Point pc2; pc2.x =   0; pc2.y = -10;
    Point pc3; pc3.x = -10; pc3.y =   0;
    Point pc4; pc4.x =  10; pc4.y =   0; 
    clear();
    setFGColor(0.8f, 0.8f, 0.8f);
    drawLine(pc1, pc2);
    drawLine(pc3, pc4);
}

void Graphic::drawFixationCross(int w, int h){
    int a = w/2;
    int b = h/2;
    Point pc1; pc1.x =  0; pc1.y =  a;
    Point pc2; pc2.x =  0; pc2.y = -a;
    Point pc3; pc3.x = -b; pc3.y =  0;
    Point pc4; pc4.x =  b; pc4.y =  0; 
    clear();
    setFGColor(0.8f, 0.8f, 0.8f);
    drawLine(pc1, pc2);
    drawLine(pc3, pc4);
}

void Graphic::setFGColor(float r, float g, float b) {
    glColor3f(r, g, b);
}

void Graphic::drawLine(Point p1, Point p2) {
    glBegin(GL_LINES);
    glVertex2f(p1.x, p1.y);
    glVertex2f(p2.x, p2.y);
    glEnd();
}

void Graphic::drawTriangle(Point p1, Point p2, Point p3) {
    glBegin(GL_TRIANGLES);
    glVertex2f(p1.x, p1.y);
    glVertex2f(p2.x, p2.y);
    glVertex2f(p3.x, p3.y);
    glEnd();
}

void Graphic::drawRectangle(Point p1, Point p2, Point p3, Point p4) {
    glBegin(GL_QUADS);
    glVertex2f(p1.x, p1.y);
    glVertex2f(p2.x, p2.y);
    glVertex2f(p3.x, p3.y);
    glVertex2f(p4.x, p4.y);
    glEnd();
}

void Graphic::drawUnfilledCircle(Point p, float radius){
    float x, y, r;
    glBegin(GL_LINE_STRIP);
    for(int i = 0; i <= 360; i++) {
        r = M_PI * i / 180.0f;
        x = radius * cos(r);
        y = radius * sin(r);
        glVertex2f(p.x + x, p.y + y);
    }
    glEnd();
}

void Graphic::drawCircle(Point p, float radius){
    float x, y, r;
    glBegin(GL_TRIANGLE_FAN);
    glVertex2f(p.x, p.y);
    for(int i = 0; i <= 360; i++) {
        r = M_PI * i / 180.0f;
        x = radius * cos(r);
        y = radius * sin(r);
        glVertex2f(p.x + x, p.y + y);
    }
    glEnd();
}

void Graphic::clear() {
    glClear(GL_COLOR_BUFFER_BIT);
}

void Graphic::swap() {
  SDL_GL_SwapBuffers();
}

int Graphic::addTexture(char* fname) {
    // some variables for a 32bit RGBA surface
    int bits = 32;
    #if SDL_BYTEORDER == SDL_BIG_ENDIAN
        int rmask = 0xff000000;
        int gmask = 0x00ff0000;
        int bmask = 0x0000ff00;
        int amask = 0x000000ff;
    #else
        int rmask = 0x000000ff;
        int gmask = 0x0000ff00;
        int bmask = 0x00ff0000;
        int amask = 0xff000000;
    #endif
    // load image from file
    SDL_Surface* texFile = IMG_Load(fname);
    if (texFile == 0) {
        PtfCore::getSingleton().getMessageLog()
                << ERROR("  Failed to load a texture (") << fname << ").\n";
        throw std::runtime_error("Failed to load a texture.");
    }
    // create new surface
    SDL_Surface* texRes = SDL_CreateRGBSurface(SDL_SWSURFACE, 
        texFile->w, texFile->h, bits, rmask, gmask, bmask, amask);
    // blit surface
    SDL_BlitSurface(texFile, &texFile->clip_rect, texRes, &texRes->clip_rect);
    // create OpenGL texture
    GLuint tex;
    glGenTextures(1, &tex);
    glBindTexture(GL_TEXTURE_2D, tex);
    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    gluBuild2DMipmaps(GL_TEXTURE_2D, 3, texRes->w, texRes->h, 
        GL_RGBA, GL_UNSIGNED_BYTE, texRes->pixels);
    glMatrixMode(GL_TEXTURE);
    // rotate texture matrix
    glLoadIdentity();
    glRotatef(90.0f, 0.0f, 0.0f, 1.0f);
    glMatrixMode(GL_MODELVIEW);
    glFlush();
    // clean up
    SDL_FreeSurface(texFile);
    SDL_FreeSurface(texRes);
    // add texture handle
    textures.push_back(tex);
    // work around - without it OpenGL will display no texture the first
    // time used
    PointTex pq1; pq1.x = -1; pq1.y = -1; pq1.u = 1.0f; pq1.v = 0.0f;
    PointTex pq2; pq2.x =  1; pq2.y = -1; pq2.u = 0.0f; pq2.v = 0.0f;
    PointTex pq3; pq3.x =  1; pq3.y =  1; pq3.u = 0.0f; pq3.v = 1.0f;
    PointTex pq4; pq4.x = -1; pq4.y =  1; pq4.u = 1.0f; pq4.v = 1.0f;
    drawTexturedRectangle(pq1, pq2, pq3, pq4, (int)textures.size() - 1);
    clear();
    // return index
    return (int)textures.size() - 1;    
}

void Graphic::drawTexturedRectangle(PointTex p1, PointTex p2, PointTex p3, PointTex p4, int tex) {
    if (tex >= (int)textures.size() || tex < 0) {
        PtfCore::getSingleton().getMessageLog()
                << ERROR("  Texture doesn't exist (number ") << tex << ").\n";
        throw std::runtime_error("Texture doesn't exist.");
    }
    glBindTexture(GL_TEXTURE_2D, textures[tex]);
    glEnable(GL_TEXTURE_2D);
    glBegin(GL_QUADS);
    glVertex2f(p1.x, p1.y); glTexCoord2f(p1.u, p1.v);
    glVertex2f(p2.x, p2.y); glTexCoord2f(p2.u, p2.v);
    glVertex2f(p3.x, p3.y); glTexCoord2f(p3.u, p3.v);
    glVertex2f(p4.x, p4.y); glTexCoord2f(p4.u, p4.v);
    glEnd();
    glDisable(GL_TEXTURE_2D);
}

---