SDL Base Engine

#include <iostream>
#include <vector>
#include <math.h>
#include "SDL/SDL.h"
#include "SDL/SDL_gfxPrimitives.h"

#define WIDTH 640
#define HEIGHT 480

#define FPS 60
#define SPF 5

using namespace std;

struct Dimension
{
    public:
        double x;
        double y;

        Dimension();
        Dimension(double x);
        Dimension(double x, double y);

        double length();
        double distance(Dimension operend);
        double dotProduct(Dimension operend);

        Dimension operator +(Dimension operend);
        Dimension operator -(Dimension operend);
        Dimension operator *(Dimension operend);
        Dimension operator /(Dimension operend);

        bool operator ==(Dimension operend);
        bool operator !=(Dimension operend);
        bool operator >(Dimension operend);
        bool operator <(Dimension operend);
        bool operator >=(Dimension operend);
        bool operator <=(Dimension operend);
};

Dimension::Dimension()
{
    this->x = 0;
    this->y = 0;
}

Dimension::Dimension(double x)
{
    this->x = x;
    this->y = x;
}

Dimension::Dimension(double x, double y)
{
    this->x = x;
    this->y = y;
}

double Dimension::length()
{
    return sqrt(pow(x, 2) + pow(y, 2));
}

double Dimension::distance(Dimension operend)
{
    Dimension difference = operend - *this;
    return difference.length();
}

double Dimension::dotProduct(Dimension operend)
{
    return x * operend.x + y * operend.y;
}

Dimension Dimension::operator +(Dimension operend)
{
    x += operend.x;
    y += operend.y;
    return *this;
}

Dimension Dimension::operator -(Dimension operend)
{
    x -= operend.x;
    y -= operend.y;
    return *this;
}

Dimension Dimension::operator *(Dimension operend)
{
    x *= operend.x;
    y *= operend.y;
    return *this;
}

Dimension Dimension::operator /(Dimension operend)
{
    x /= operend.x;
    y /= operend.y;
    return *this;
}

bool Dimension::operator ==(Dimension operend)
{
    return x == operend.x && y == operend.y;
}

bool Dimension::operator !=(Dimension operend)
{
    return x != operend.x || y != operend.y;
}

bool Dimension::operator >(Dimension operend)
{
    return x > operend.x && y > operend.y;
}

bool Dimension::operator <(Dimension operend)
{
    return x < operend.x && y < operend.y;
}

bool Dimension::operator >=(Dimension operend)
{
    return (x > operend.x && y > operend.y) || ((*this) == operend);
}

bool Dimension::operator <=(Dimension operend)
{
    return (x < operend.x && y < operend.y) || ((*this) == operend);
}

class Entity
{
    public:
        Entity();
        ~Entity();

        void update();
        void render(SDL_Surface *surface);

        void keyDown(SDL_keysym key);
        void keyUp(SDL_keysym key);
        void mouseDown(unsigned short button, Dimension position);
        void mouseUp(unsigned short button, Dimension position);
        void mouseMotion(Dimension position, Dimension motion);

        Dimension getPosition();
        Dimension getSize();

        long getBackgroundColor();

        void setParent(Entity *parent);

    protected:
        long getTick();
        long getFrame();

        void addEntity(Entity *entity);
        void removeEntity(Entity *entity);
        void removeEntity(int entity);
        void clearEntities();

        void bringToFront(Entity *entity);
        void bringToFront();

        void remove();

        void setFocused(bool focused);
        bool isFocused();

        virtual void update2() = 0;
        virtual void render2(SDL_Surface *surface) = 0;

        virtual void onKeyDown(SDL_keysym key) {}
        virtual void onKeyUp(SDL_keysym key) {}
        virtual void onMouseDown(unsigned short button, Dimension position) {}
        virtual void onMouseUp(unsigned short button, Dimension position) {}
        virtual void onMouseMotion(Dimension position, Dimension motion) {}
        virtual void onClick(unsigned short button, Dimension position) {}
        virtual void onDrag(unsigned short button, Dimension position, Dimension motion) {}
        virtual void onFocus() {}
        virtual void onUnfocus() {}

        Entity *getEntityInBounds(Dimension bounds);

        Dimension position;
        Dimension size;

        long backgroundColor;

        Entity *getParent();

    private:
        vector<Entity *> contents;
        Entity *focus;

        bool mouse;
        unsigned short button;

        bool focused;

        long tick;
        long frame;

        Entity *parent;
};

Entity::Entity()
{
    contents = vector<Entity *>();
    focus = NULL;

    mouse = false;
    button = 0;

    focused = false;

    tick = 0;
    frame = 0;

    position = Dimension(0, 0);
    size = Dimension(0, 0);

    backgroundColor = 0x000000;

    parent = NULL;
}

Entity::~Entity()
{
    clearEntities();
}

void Entity::update()
{
    update2();
    tick++;

    vector<Entity *>::iterator it;
    for(it = contents.begin(); it < contents.end(); it++)
    {
        (*it)->update();
    }
}

void Entity::render(SDL_Surface *surface)
{
    SDL_Surface *surface2 = SDL_CreateRGBSurface(SDL_HWSURFACE, size.x, size.y, 32, 0, 0, 0, 0);

    render2(surface2);
    frame++;

    vector<Entity *>::iterator it;
    for(it = contents.begin(); it < contents.end(); it++)
    {
        (*it)->render(surface2);
    }

    SDL_Rect offset;
    offset.x = position.x;
    offset.y = position.y;

    SDL_BlitSurface(surface2, NULL, surface, &offset);
    SDL_FreeSurface(surface2);
}

void Entity::keyDown(SDL_keysym key)
{
    onKeyDown(key);

    if(focus != NULL)
    {
        focus->onKeyDown(key);
    }
}

void Entity::keyUp(SDL_keysym key)
{
    onKeyUp(key);

    if(focus != NULL)
    {
        focus->onKeyUp(key);
    }
}

void Entity::mouseDown(unsigned short button, Dimension position)
{
    mouse = true;
    this->button = button;
    onMouseDown(button, position);

    Entity *oldFocus = focus;
    focus = getEntityInBounds(position);

    if(focus != oldFocus)
    {
        if(focus != NULL)
        {
            focus->setFocused(true);
        }
        if(oldFocus != NULL)
        {
            oldFocus->setFocused(false);
        }
    }

    if(focus != NULL)
    {
        focus->onMouseDown(button, position);
    }
}

void Entity::mouseUp(unsigned short button, Dimension position)
{
    Entity *focus = getEntityInBounds(position);

    onMouseUp(button, position);
    if(mouse)
    {
        onClick(button, position);

        if(focus != NULL && focus == this->focus)
        {
            focus->onClick(button, position);
        }
    }
    mouse = false;

    if(focus != NULL)
    {
        focus->onMouseUp(button, position);
    }
}

void Entity::mouseMotion(Dimension position, Dimension motion)
{
    onMouseMotion(position, motion);
    if(mouse)
    {
        onDrag(button, position, motion);

        if(focus != NULL)
        {
            focus->onDrag(button, position, motion);
        }
    }

    Entity *focus = getEntityInBounds(position);

    if(focus != NULL)
    {
        focus->onMouseMotion(position, motion);
    }
}

Entity *Entity::getParent()
{
    return parent;
}

void Entity::setParent(Entity *parent)
{
    this->parent = parent;
}

Dimension Entity::getPosition()
{
    return position;
}

Dimension Entity::getSize()
{
    return size;
}

long Entity::getBackgroundColor()
{
    return backgroundColor;
}

long Entity::getTick()
{
    return tick;
}

long Entity::getFrame()
{
    return frame;
}

void Entity::addEntity(Entity *entity)
{
    contents.push_back(entity);
    entity->setParent(this);
}

void Entity::removeEntity(Entity *entity)
{
    vector<Entity *>::iterator it;
    for(it = contents.begin(); it < contents.end(); it++)
    {
        if(entity == *it)
        {
            contents.erase(it);
            break;
        }
    }
}

void Entity::removeEntity(int entity)
{
    contents.erase(contents.begin() + entity);
}

void Entity::clearEntities()
{
    contents.clear();
}

void Entity::bringToFront(Entity *entity)
{
    removeEntity(entity);
    addEntity(entity);
}

void Entity::bringToFront()
{
    if(parent != NULL)
    {
        parent->bringToFront(this);
    }
}

void Entity::remove()
{
    if(parent != NULL)
    {
        parent->removeEntity(this);
    }
}

void Entity::setFocused(bool focused)
{
    this->focused = focused;
    if(focused)
    {
        onFocus();
    }
    else
    {
        onUnfocus();
    }
}

bool Entity::isFocused()
{
    return focused;
}

Entity *Entity::getEntityInBounds(Dimension position)
{
    if(contents.size())
    {
        vector<Entity *>::iterator it;
        for(it = contents.end() - 1; it >= contents.begin(); it--)
        {
            Entity *entity = *it;
            if(position >= entity->getPosition() && position < entity->getPosition() + entity->getSize())
            {
                return entity;
            }
        }
    }

    return NULL;
}

class TestObject: public Entity
{
    public:
        TestObject(Dimension position, Dimension size);
        ~TestObject();

    protected:
        void update2();
        void render2(SDL_Surface *surface);

        void onDrag(unsigned short button, Dimension position, Dimension motion);
        void onFocus();
};

TestObject::TestObject(Dimension position, Dimension size)
{
    this->position = position;
    this->size = size;
}

TestObject::~TestObject()
{

}

void TestObject::update2()
{

}

void TestObject::render2(SDL_Surface *surface)
{
    SDL_FillRect(surface, NULL, isFocused() ? 0xFF0000 : 0x888888);
}

void TestObject::onFocus()
{
    bringToFront();
}

void TestObject::onDrag(unsigned short button, Dimension position, Dimension motion)
{
    this->position = this->position + motion;
}

class TestScreen: public Entity
{
    public:
        TestScreen();
        ~TestScreen();

    protected:
        void update2();
        void render2(SDL_Surface *surface);
};

TestScreen::TestScreen()
{
    size = Dimension(WIDTH, HEIGHT);

    addEntity(new TestObject(Dimension(5, 5), Dimension(20, 20)));
    addEntity(new TestObject(Dimension(45, 45), Dimension(20, 20)));
    addEntity(new TestObject(Dimension(85, 85), Dimension(20, 20)));
}

TestScreen::~TestScreen()
{

}

void TestScreen::update2()
{

}

void TestScreen::render2(SDL_Surface *surface)
{

}

class Engine
{
    public:
        static Engine *engine;

        Engine();
        ~Engine();

        void start();
        void stop();

        void setContent(Entity *content);

    private:
        bool running;

        long tick;
        long frame;

        Entity *content;

        SDL_Surface *surface;

        void events();
        void update();
        void render();
};

Engine *Engine::engine;

Engine::Engine()
{
    engine = this;

    running = false;

    tick = 0;
    frame = 0;

    content = NULL;

    SDL_Init(SDL_INIT_EVERYTHING);
    SDL_WM_SetCaption("Game Engine", 0);
    surface = SDL_SetVideoMode(WIDTH, HEIGHT, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
}

Engine::~Engine()
{
    stop();
    SDL_Quit();
}

void Engine::start()
{
    if(!running)
    {
        running = true;
        while(running)
        {
            int now = SDL_GetTicks();

            events();
            for(int i = 0; i < SPF; i++)
            {
                update();
                tick++;
            }
            render();
            frame++;

            int passed = SDL_GetTicks() - now;
            int wait = 1000 / FPS;
            int left = wait - passed;

            SDL_Delay(left);
        }
    }
}

void Engine::stop()
{
    running = false;
}

void Engine::setContent(Entity *content)
{
    this->content = content;
}

void Engine::events()
{
    if(content != NULL)
    {
        SDL_Event event;
        while(SDL_PollEvent(&event))
        {
            switch(event.type)
            {
                case SDL_KEYDOWN:
                    content->keyDown(event.key.keysym);
                    break;

                case SDL_KEYUP:
                    content->keyUp(event.key.keysym);
                    break;

                case SDL_MOUSEBUTTONDOWN:
                    content->mouseDown(event.button.button, Dimension(event.button.x, event.button.y));
                    break;

                case SDL_MOUSEBUTTONUP:
                    content->mouseUp(event.button.button, Dimension(event.button.x, event.button.y));
                    break;

                case SDL_MOUSEMOTION:
                    content->mouseMotion(Dimension(event.motion.x, event.motion.y), Dimension(event.motion.xrel, event.motion.yrel));
                    break;

                case SDL_QUIT:
                    stop();
                    break;
            }
        }
    }
}

void Engine::update()
{
    if(content != NULL)
    {
        content->update();
    }
}

void Engine::render()
{
    if(content != NULL)
    {
        SDL_FillRect(surface, NULL, content->getBackgroundColor());
        content->render(surface);
        SDL_Flip(surface);
    }
}

int main()
{
    Engine engine;

    engine.setContent(new TestScreen());
    engine.start();

    return 0;
}