---

graphics.cpp

Go to the documentation of this file.

#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <string.h>
#include <iostream>

#include "application.h"
#include "graphics.h"
#include "util.h"

Graphics::Graphics(string title, int w, int h, bool opengl)
{
#ifdef DEBUG
        cerr << "Window title: " << title << " (" << w << ", " << h << ")" << endl;
#endif
        if(w < 320)
                width = 320;
        else
                width = w;

        if(h < 240)
                height = 240;
        else
                height = h;

        int flags = SDL_HWSURFACE | SDL_DOUBLEBUF;
        if (opengl)
                flags |= SDL_OPENGL;
                
        hwSurface = new Surface;
        
        SDL_InitSubSystem(SDL_INIT_VIDEO);

        if (opengl)
                PreOpenGLInit();

        hwSurface->surface = SDL_SetVideoMode(width, height, 16, flags);

        hwSurface->w = hwSurface->surface->w;
        hwSurface->h = hwSurface->surface->h;

        SDL_WM_SetCaption (title.c_str(), title.c_str());

        if (opengl)
                PostOpenGLInit();
}

Graphics::~Graphics()
{
        SDL_FreeSurface(hwSurface->surface);
        delete hwSurface;
        
        SDL_QuitSubSystem(SDL_INIT_VIDEO);
}

void Graphics::PreOpenGLInit()
{
        SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
        SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 6);
        SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
        SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);

        SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, SDL_DOUBLEBUF);
}
        
                
void Graphics::PostOpenGLInit()
{
        GLint maxtexsize;
        glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxtexsize);

        cout << "Maximum texture size is " << maxtexsize << 'x' << maxtexsize << endl;

        glDisable(GL_DEPTH_TEST);
        glDisable(GL_CULL_FACE);

        glViewport (0, 0, hwSurface->w, hwSurface->h);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        glOrtho (0, hwSurface->w, hwSurface->h, 0, -10.0, 10.0);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        glTranslatef(0.0f, 0.0f, 0.0f);

        glEnable (GL_BLEND);
        glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glEnable (GL_TEXTURE_2D);
        
        return;
}

                                                        
void
Graphics::update(int x, int y, int w, int h)
{
        if (hwSurface->surface->flags & SDL_OPENGL)
                return;
        
        if(hwSurface && hwSurface->surface) {
                // If the x coord is offscreen, adjust
                if(x < 0) {
                        w += x;
                        x = 0;
                }

                // If the x coord is offscreen to the right, return
                if(x >= width) 
                        return;

                // If the y coord is offscreen...
                if(y < 0) {
                        h += y;
                        y = 0;
                }

                if(y >= height) 
                        return;

                // If the width goes offscreen, clip it.
                if((x+w) >= width) 
                        w = (width - x);

                // Same for height
                if((y+h) >= height) 
                        h = (height - y);

                // If the total width/height is <= 0, don't draw
                if(w <= 0 || h <= 0) 
                        return;

                SDL_UpdateRect(hwSurface->surface, x, y, w, h); 
        }
}

void Graphics::update(Rect &r)
{
        // -9999 is a special value for rects
        if(r.x == r.y && r.y == -9999) 
                return;
        
        update(r.x, r.y, r.w, r.h);
}

void Graphics::blitGLtexture (Surface *src, int srx, int sry, int srw, int srh,
                int drx, int dry, int drw, int drh)
{
        float width = (float)src->w / (float)src->ts;
        float height = (float)src->h / (float)src->ts;

        glBindTexture (GL_TEXTURE_2D, src->tex);
        glBegin(GL_QUADS);
        glTexCoord2f (0, 0);            glVertex2i (drx, dry);
        glTexCoord2f (width, 0);        glVertex2i (drx + srw, dry);
        glTexCoord2f (width, height);   glVertex2i (drx + srw, dry + srh);
        glTexCoord2f (0, height);       glVertex2i (drx, dry + srh);
        glEnd();
}


// The following function blits src (0,0)-(src->w,src->h) onto
// the video framebuffer with clipping.
// This function assumes dest and src valid pointers.
void Graphics::blitclip(Surface *dest, int drx, int dry, int drw, int drh,
                     Surface *src,  int srx, int sry, int srw, int srh)
{
        if (dest && dest->surface && (dest->surface->flags & SDL_OPENGL)) {
                blitGLtexture(src, srx, sry, srw, srh, drx, dry, drw, drh);
                return;
        }

        // If we end up drawing off screen to the right or bottom
        if ( (drx + drw) >= dest->w ) {
                int offs = (drx + drw) - dest->w;       // count how far off
                drw -= offs;                            // reduce draw
                srw -= offs;
        }

        // Same as above if statement for Y values
        if ( (dry + drh) >= dest->h ) {
                int offs = (dry + drh) - dest->h;
                drh -= offs;
                srh -= offs;
        }

        if ( drx < 0 ) {
                int offs = -drx;        // store how far left
                drx = 0;                // draw at 0
                drw -= offs;            // reduce width by offset
                if (drw <= 0)           // if width is still <= 0, return
                        return;

                srx += offs;            // draw more to the right.
                srw -= offs;            // reduce width.
        }

        if ( dry < 0 ) {                // see above comments.
                int offs = -dry;
                dry = 0;
                drh -= offs;
                if (drh <= 0)
                        return;

                sry += offs;
                srh -= offs;
        }

        if ( (srx >= src->w) || (sry >= src->h) )
                return;

        // If we end up shrinking width and height to below/= 0
        if ( (srw <= 0) || (srh <= 0) || (drw <= 0) || (drh <= 0) )
                return;

        Rect srcrect = Util_BuildRect(srx, sry, srw, srh);
        Rect dstrect = Util_BuildRect(drx, dry, drw, drh);

        SDL_LowerBlit(src->surface, &srcrect, dest->surface, &dstrect);
}

void 
Graphics::blit(Surface *src, int dx, int dy)
{
        blit(hwSurface, dx, dy, src);
        return;
}

void 
Graphics::blit(Surface *target, int tx, int ty, Surface *src)
{
        // If either tx or ty are offscreen, or src or hwSurface is null,
        // return.
        if (!target || !src || tx >= (signed int)target->w || ty >= (signed int)target->h) 
                return;
        

        blitclip (target,  tx,  ty, src->w, src->h,
                     src,   0,   0, src->w, src->h);
}

void 
Graphics::blit(Surface *target, Rect &t, Surface *src, Rect &s)
{
        if(t.x == t.y && t.y == -9999)
                return;
        
        if(target && src) {
                blitclip (target, t.x, t.y, t.w, t.h,
                          src,    s.x, s.y, s.w, s.h);
        }
}

Surface *
Graphics::newSurface(int w, int h)
{
        if(w < 1 || h < 1) return (Surface *) NULL;

        Surface *n = new Surface;
        n->surface = SDL_CreateRGBSurface (SDL_SWSURFACE, w, h, 32,
                hwSurface->surface->format->Rmask,
                hwSurface->surface->format->Gmask,
                hwSurface->surface->format->Bmask,
                hwSurface->surface->format->Amask);

        if(n) {
                n->w = w;
                n->h = h;
                return n;
        }
        
        cout << SDL_GetError() << endl;

        return (Surface *) NULL;
}

Surface *
Graphics::CreateSurfaceFrom(Surface *s)
{
        if (!s)
                return (Surface *) NULL;
        
        Surface *n = new Surface;
        n->surface = SDL_CreateRGBSurfaceFrom(s->surface->pixels, s->surface->w,
                                s->surface->h, s->surface->format->BitsPerPixel, 
                                s->surface->pitch, s->surface->format->Rmask,
                                s->surface->format->Gmask, s->surface->format->Bmask,
                                s->surface->format->Amask);

        if(n) {
                n->w = n->surface->w;
                n->h = n->surface->h;
                return n;
        }

        cout << __LINE__ << ": " << SDL_GetError() << endl;
        return (Surface *) NULL;
}

Surface *
Graphics::CreateSurfaceFrom(Surface *s, int nw, int nh)
{
        if (!s)
                return (Surface *) NULL;

        Surface *n = new Surface;
        n->surface = SDL_CreateRGBSurface(s->surface->flags, nw, nh,
                                s->surface->format->BitsPerPixel,
                                s->surface->format->Rmask,
                                s->surface->format->Gmask,
                                s->surface->format->Bmask,
                                s->surface->format->Amask);
        if(n) {
                n->w = n->surface->w;
                n->h = n->surface->h;
                return n;
        }

        cout << __LINE__ << ": " << SDL_GetError() << endl;
        return (Surface *) NULL;
}

void Graphics::deleteSurface(Surface *n)
{
        SDL_FreeSurface(n->surface);
        delete n;
}

void Graphics::fillSurface(Surface *n, int color)
{
        SDL_FillRect(n->surface, NULL, color);
}

int Graphics::color(int r, int g, int b, Surface * n)
{
        if(n) {
                return SDL_MapRGB(n->surface->format, r, g, b);
        } else {
                return SDL_MapRGB(hwSurface->surface->format, r, g, b);
        }
}

Surface *
Graphics::loadImage(const char *fname)
{
        if(!fname) return (Surface *)NULL;

        Surface *n = new Surface;
        n->surface = IMG_Load(fname);
        if (!n) cout << SDL_GetError() << endl;
        n->w = n->surface->w;
        n->h = n->surface->h;
        return n;
}

Surface *
Graphics::loadImage(string fname) 
{ 
        return Graphics::loadImage(fname.c_str()); 
}

Surface *
Graphics::freeImage(Surface *surf)
{
        if(surf) {
                SDL_FreeSurface (surf->surface);
                delete surf;
        }
        return NULL;
}

Surface *Graphics::displayFormat(Surface *surf, bool alpha)
{
        if (alpha) {
                Surface *n = new Surface;
                n->surface = SDL_DisplayFormatAlpha(surf->surface);
                n->w = surf->w;
                n->h = surf->h;
                return n;
        }
        
        Surface *n = new Surface;
        n->surface = SDL_DisplayFormat(surf->surface);
        n->w = surf->w;
        n->h = surf->h;
        return n;
}

bool Graphics::lockMouse(bool lock)
{
        return (SDL_WM_GrabInput( (lock) ? SDL_GRAB_ON : SDL_GRAB_OFF ) == SDL_GRAB_ON);
}

void Graphics::flip()
{
        if (!hwSurface || !hwSurface->surface)
                return;
        
        if (hwSurface->surface->flags & SDL_OPENGL) {
                GLint err = glGetError();
                if (err != GL_NO_ERROR) {
                        cerr << "OpenGL error " << err << endl;
                        err = glGetError();
                }
        
                SDL_GL_SwapBuffers();
                glClear (GL_COLOR_BUFFER_BIT);
        } else {
                SDL_Flip(hwSurface->surface);
        }
}

void Graphics::TexturizeSurface (Surface *s)
{
        int size = Util_FindBestSurfaceSize (s->w, s->h);

        Surface temp;

        SDL_SetAlpha (s->surface, 0, 0);
        
        temp.surface = SDL_AllocSurface (SDL_SWSURFACE, size, size, 32, 
                                0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000);
        
        SDL_BlitSurface (s->surface, NULL, temp.surface, NULL);
        SDL_FreeSurface (s->surface);
        s->surface = (SDL_Surface *) NULL;

        glGenTextures (1, &(s->tex));
        glBindTexture(GL_TEXTURE_2D, s->tex);
        glPixelStorei(GL_UNPACK_ROW_LENGTH, temp.surface->pitch / temp.surface->format->BytesPerPixel);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, temp.surface->w, temp.surface->h, 0, GL_RGBA,
                        GL_UNSIGNED_BYTE, temp.surface->pixels);
        glFlush();

        SDL_FreeSurface (temp.surface);

        s->tx = s->ty = 0;
        s->ts = size;
}

void Graphics::UntexturizeSurface (Surface *s)
{
        if (!s || !(s->tex >= 0))
                return;

        glDeleteTextures(1, &s->tex);
}

void Graphics::RotateZ (float degrees)
{
        glLoadIdentity();
        glTranslatef (getWidth()/2, getHeight()/2, 0);
        glRotatef (degrees, 0.0, 0.0, 1.0);
        glTranslatef (getWidth()/-2, getHeight()/-2, 0);
}

---