---

background.cpp

Go to the documentation of this file.

#include <iostream>
#include <string>
#include "graphics.h"
#include "util.h"
#include "background.h"
#include <iostream>

using namespace std;

Background::Background (Graphics &G) : staticImage (NULL), GD(G)
{
        xOffset = 0;
        yOffset = 0;
        needRedraw = false;     // Nothing to draw..
        staticBackground = false;
}


// Load background class using a static image
Background::Background (string img, Graphics &G) : GD(G)
{
        SetStatic(img);

        SetPosition (0, 0);
}

Background::~Background()
{
        if (staticImage)
                Graphics::freeImage(staticImage);
}

// Utility functions to actually set up a static image
// background.
void Background::SetStatic (string img)
{
        SetStatic (Graphics::loadImage (img));
}

void Background::SetStatic (Surface *surf)
{
        const int xmul = 2;
        const int ymul = 2;

        if (surf) {
                const int SURFW = surf->w * xmul;
                const int SURFH = surf->h * ymul;

                // make a 3x3 screen of surf
                staticImage = Graphics::CreateSurfaceFrom (surf, SURFW, SURFH);
                for (int y = 0; y < ymul; y++) {
                        for (int x = 0; x < xmul; x++) {
                                Graphics::blit (staticImage, x * surf->w, y * surf->h, surf);
                        }
                }

                Graphics::TexturizeSurface (staticImage);
                staticBackground = true;
                needRedraw = true;

                xMax = (float)(SURFW - GD.getWidth());
                yMax = (float)(SURFH - GD.getHeight());
        }
}

        

// Functions to draw the background onto the surface
// if needed.
bool Background::Draw ()
{
        Rect D = Util_BuildRect (-xOffset, -yOffset, GD.getWidth(), GD.getHeight());
        Rect S = Util_BuildRect (0, 0, staticImage->w, staticImage->h);
        
        DrawRect (GD.getMainSurface(),  D, S);
        
//      return Draw (GD.getMainSurface());
        return true;
}

bool Background::Draw (Surface *surf)
{
        Rect S;

        if (staticBackground && needRedraw) {
                S = Util_BuildRect (0, 0, surf->w, surf->h);
                DrawRect (surf, S);
                
                needRedraw = false;
                return true;
        } else 

        return false;
}


// Needed to replace sprites on the screen
// Rects here are in screen coordinates
void Background::DrawRect (Rect &R)
{
        DrawRect (GD.getMainSurface(), R);      
}

// This function assumes that xOffset and yOffset are valid
// values: i.e. the distance between xOffset and staticImage->w is a full surf->w
void Background::DrawRect (Surface *surf, Rect &R)
{
        Rect Src, Dest = R;

        Src.x = R.x + (int)(xOffset + 0.5);
        Src.y = R.y + (int)(yOffset + 0.5);
        Src.w = R.w;
        Src.h = R.h;
        
        DrawRect (surf, Dest, Src);
}

void Background::DrawRect (Surface *dest, Rect &D, Rect &S)
{
        Graphics::blit (dest, D, staticImage, S);
}

// Sets the location in the world.
bool Background::SetPosition (float x, float y)
{
        if (x >= xMax || y >= yMax || x < 0 || y < 0) {
                cout << "Invalid values for Background::SetPosition (" << x << ", " << y << ")" << endl;
                return false;
        }

        if (x != xOffset || y != yOffset)
                needRedraw = true;

        xOffset = x;
        yOffset = y;
        return needRedraw;
}

---