anaglym/anaglym.cc

#include "ag.h"
#include "Video.h"
#include "anaglym.h"
#include <lua.hpp>
#include <stdlib.h>                 /* exit() */
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <iostream>
#include <string>
#include <GL/gl.h>
#include <GL/glu.h>
using namespace std;

static void usage();

Engine * g_engine;

SDL_Event Engine::userEvent;

static void usage()
{
    cerr << "Usage: anaglym [options] program.lua[c]" << endl;
    exit(42);
}

int main(int argc, char * argv[])
{
    const char * program = NULL;
    for (int i = 1; i < argc; i++)
    {
        if (argv[i][0] != '-')
        {
            if (program == NULL)
            {
                program = argv[i];
            }
            else
            {
                cerr << "Warning: argument " << argv[i] << " ignored!" << endl;
            }
        }
        else
        {
            cerr << "Warning: Unrecognized option '" << argv[i]+1
                 << "'" << endl;
        }
    }

    if (program == NULL)
    {
        usage();
    }

    g_engine = new Engine();
    if (g_engine->load(program))
        g_engine->run();
    delete g_engine;

    return 0;
}

Engine::Engine()
{
    m_video = new Video();
    m_next_object_index = 1;
    m_eye[0] = 0;
    m_eye[1] = -1;
    m_eye[2] = 0;
    m_center[0] = 0;
    m_center[1] = 0;
    m_center[2] = 0;
    m_up[0] = 0;
    m_up[1] = 0;
    m_up[2] = 1;
    m_drawing = false;

    /* setup redraw SDL event structure */
    userEvent.type = SDL_USEREVENT;
    userEvent.user.code = 0;
#if 0
    /* start in windowed mode for debugging */
    m_video->start(0, 0, false, false);
#else
    m_video->start();
#endif
}

Engine::~Engine()
{
    m_video->stop();
    lua_close(m_luaState);
    for (std::map<int, Object *>::iterator it = m_objects.begin();
         it != m_objects.end();
         it++)
    {
        delete it->second;
    }
    delete m_video;
}

bool Engine::load(const char * program)
{
    m_program_path = program;
    size_t pos = m_program_path.find_last_of("/\\");
    m_program_path = (pos != string::npos)
                        ? m_program_path.substr(0, pos)
                        : ".";

    m_luaState = lua_open();

    registerLibraries();

    int s = luaL_loadfile(m_luaState, program);

    if (s == 0)
    {
        // execute Lua program
        s = lua_pcall(m_luaState, 0, LUA_MULTRET, 0);
    }
    else
    {
        cerr << "Warning: problem loading '" << program << "'" << endl;
        return false;
    }

    if (s != 0)
    {
        reportErrors(s);
        return false;
    }

    return true;
}

void Engine::reportErrors(int status)
{
    if (status != 0)
    {
        cerr << "Engine: Error: " << lua_tostring(m_luaState, -1) << endl;
        lua_pop(m_luaState, 1); // remove error message
    }
}

void Engine::registerLibraries()
{
    /* Load the Lua string library */
    lua_pushcfunction(m_luaState, luaopen_string);
    lua_pcall(m_luaState, 0, 0, 0);

    /* Load the Lua math library */
    lua_pushcfunction(m_luaState, luaopen_math);
    lua_pcall(m_luaState, 0, 0, 0);

    /* Load the Lua table library */
    lua_pushcfunction(m_luaState, luaopen_table);
    lua_pcall(m_luaState, 0, 0, 0);

    ag::register_functions(m_luaState);
}

string Engine::locateResource(const string & shortname)
{
    string try_path;

    try_path = m_program_path + "/" + shortname;
    if (fileExists(try_path))
        return try_path;

    return "";
}

bool Engine::fileExists(const string & path)
{
    struct stat st;
    if (stat(path.c_str(), &st) == 0)
    {
        return S_ISREG(st.st_mode) && (st.st_size > 0);
    }
    return false;
}

int Engine::addObject(WFObj * obj, bool is_static)
{
    int id = m_next_object_index;
    Object * o = createObject(is_static, obj->render());
    m_objects[id] = o;
    m_next_object_index++;
    return id;
}

Engine::Object * Engine::getObject(int id)
{
    return m_objects.find(id) != m_objects.end() ? m_objects[id] : NULL;
}

int Engine::startFrame(lua_State * L)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(m_eye[0], m_eye[1], m_eye[2],
              m_center[0], m_center[1], m_center[2],
              m_up[0], m_up[1], m_up[2]);
    return 0;
}

int Engine::endFrame(lua_State * L)
{
    SDL_GL_SwapBuffers();
    return 0;
}

int Engine::setCamera(lua_State * L)
{
    int argc = lua_gettop(L);

    vector<double> args;
    for (int i = 1; i <= argc; i++)
    {
        int type = lua_type(L, i);
        if (type == LUA_TNUMBER || type == LUA_TSTRING)
            args.push_back(lua_tonumber(L, i));
        else
            args.push_back(0);
    }

    if (argc >= 3)
    {
        m_eye[0] = args[0];
        m_eye[1] = args[1];
        m_eye[2] = args[2];
    }
    if (argc >= 6)
    {
        m_center[0] = args[3];
        m_center[1] = args[4];
        m_center[2] = args[5];
    }
    if (argc >= 9)
    {
        m_up[0] = args[6];
        m_up[1] = args[7];
        m_up[2] = args[8];
    }

    return 0;
}

/* called by SDL when the update timer expires */
Uint32 Engine::updateCallback(Uint32 interval, void * param)
{
    Engine * engine = (Engine *) param;
    return engine->updateCallback(interval);
}

/* member update function to be called by our registered
 * SDL callback non-member function */
Uint32 Engine::updateCallback(Uint32 interval)
{
    if (!m_drawing)
    {
        SDL_PushEvent(&userEvent);
    }
    return interval;
}

void Engine::run()
{
    /* register a screen redrawing SDL event */
    SDL_AddTimer(25, &updateCallback, this);

    SDL_Event event;
    while (SDL_WaitEvent(&event))
    {
        switch (event.type)
        {
            case SDL_KEYDOWN:
                switch (event.key.keysym.sym)
                {
                    case SDLK_ESCAPE:
                        goto RET;
                        break;
                }
                break;
            case SDL_QUIT:
                goto RET;
                break;
            case SDL_USEREVENT:
                if (event.user.code == 0)
                {
                    update();
                }
                break;
        }
    }
RET:
    ;
}

void Engine::update()
{
    m_drawing = true;
    lua_getfield(m_luaState, LUA_GLOBALSINDEX, "update");
    if (lua_type(m_luaState, -1) == LUA_TFUNCTION)
    {
        /* call the update function - pops the function ref from the stack */
        int s = lua_pcall(m_luaState, 0, LUA_MULTRET, 0);
        reportErrors(s);
    }
    else
    {
        lua_pop(m_luaState, 1);
    }
    m_drawing = false;
}

void Engine::doPhysics()
{
    static Uint32 last_updated = 0;
    Uint32 current_ticks = SDL_GetTicks();
    if (last_updated > 0)
    {
        Uint32 msec_steps = current_ticks - last_updated;
        for (int i = 0; i < msec_steps; i++)
            m_world.step();
    }
    last_updated = current_ticks;
}

void Engine::Object::draw()
{
    const dReal * pos = m_ode_object->getPosition();
    const dReal * rot = m_ode_object->getRotation();
    bool transform = (pos != NULL && rot != NULL);

    if (transform)
        OdeWorld::pushTransform(pos, rot);

    glCallList(m_display_list);

    if (transform)
        glPopMatrix();
}