random_racer/src/Console.cpp

Go to the documentation of this file.

#include <ctype.h> // isprint()
#include <stdio.h>
#include <stdlib.h>

#include <fstream>
#include <string>

#include "SDL.h"

#include <vrs/camera.h>
#include <vrs/font.h>
#include <vrs/opengl/lightmodelgl.h>
#include <vrs/opengl/shapematerialgl.h>
#include <vrs/opengl/transparencytechniquegl.h>
#include <vrs/polygonset.h>
#include <vrs/sg/behaviorcallback.h>
#include <vrs/sg/canvas.h>
#include <vrs/sg/key.h>
#include <vrs/sg/keyevent.h>
#include <vrs/sg/resizeevent.h>
#include <vrs/text.h>
#include <vrs/translation.h>

#include "ResourceManager.h"

#include "Console.h"

using namespace VRS;


namespace random_racer
{

// init the statics
SO<Console> Console::s_instance = NULL;
const float Console::c_marginX = 0.3;
const float Console::c_marginY = 0.6;
const float Console::c_pixelsPerChar = 11.0;
const unsigned int Console::c_animationDuration = 230;


Console::TextBuffer::TextBuffer(
    int p_maxLines, const Vector& p_startOffset, double p_lineHeight)
    : SceneThing()
{
    m_maxLines    = p_maxLines;
    m_startOffset = p_startOffset;
    m_lineHeight  = p_lineHeight;
}

void
Console::TextBuffer::addLine(SO<Text> p_newLine)
{
    // prepend the new line
    prepend( p_newLine );

    // remove the last line if needed
    if(objects() > m_maxLines)
        remove(m_maxLines);

    SO<Text> line;
    Vector   offset = m_startOffset;

    // recalculate positions for all texts
    for( int i = 0; i < objects(); i++ )
    {
        line = VRS_Cast(Text, object(i));
        line->setPosition(offset);
        offset[1] += m_lineHeight;
    }
}

void
Console::TextBuffer::addLine(const std::string& p_newLine)
{
    addLine(new Text(Console::get()->font(), p_newLine));
}

Console::Console()
{
    // a funky very big value which is the upper right
    // point (x and y) of the consoles background
    const float maxConsoleSize = 2300000.42;

    // the array containing the points for the console
    // background plane trianglestrip
    SO<NonPersistentArray<Vector> > points = new NonPersistentArray<Vector>();
    points->append(Vector(-c_marginX, -c_marginY, 0.0001));
    points->append(Vector(maxConsoleSize, -c_marginY, 0.0001));
    points->append(Vector(-c_marginX, maxConsoleSize, 0.0001));
    points->append(Vector(maxConsoleSize, maxConsoleSize, 0.0001));

    m_sceneThing = new SceneThing();
    // m_sceneThing->setNodeState(0);

    // create a first camera, the good one is created after the first resize
    m_cam = Camera::newNormalizedDeviceCoordsCamera();
    m_sceneThing->append(m_cam);

    // no lightmodel for the console
    m_sceneThing->append(new LightModelGL(false));

    // no longer needed because we assume a TransparencyTechniqueGL
    // in the main scene graph.
    // m_sceneThing->append(new TransparencyTechniqueGL());

    m_translation = new Translation();
    m_sceneThing->append(m_translation);

    // a blue color
    m_sceneThing->append(new ShapeMaterialGL(
                         Color(0.0, 0.25, 0.5, 0.54), Color(1.0)));
    m_sceneThing->append(new PolygonSet(
                         PolygonSet::TriangleStrip, points->newIterator()));
    // white
    m_sceneThing->append(new ShapeMaterialGL(Color(1.0), Color(1.0)));

    // get our console font
    m_font = ResourceManager::get()->loadFont("DejaVuSansMono.ttf",
                                              Font::POLYGON);

    m_currentLine = new Text(m_font);
    m_sceneThing->append(m_currentLine);

    m_textBuffer = new TextBuffer(42, Vector(0, 1.4, 0), 1.4);
    m_sceneThing->append(m_textBuffer);

    // initialize the history
    m_history.push_front("");
    m_histIter = m_history.begin();

    // init our canvas and the callback
    m_canvas = NULL;

    m_eventCallback = new BehaviorCallback;
    m_eventCallback->setCanvasCallback(
        new MethodCallback<Console>(this, &Console::handleEvents));

    m_startNewTabCompletition = true;

    m_animationInProgress = false;
}

SO<Console>
Console::get()
{
    if(s_instance == NULL)
        s_instance = new Console();

    return s_instance;
}

void
Console::handleKey(unsigned int p_key)
{
    std::string text = m_currentLine->getText();

    // backspace
    if((p_key == BackSpaceKey || p_key == DeleteKey) && !text.empty())
        m_currentLine->setText(text.substr(0, text.size()-1));

    // ctrl + u (delete line)
    else if(p_key == DeleteLineKey)
        m_currentLine->setText("");

    // enter / return
    else if(p_key == EnterKey || p_key == ReturnKey)
    {
        m_textBuffer->addLine(m_currentLine);
        m_sceneThing->remove(m_currentLine);

        m_currentLine = new Text(m_font);
        m_sceneThing->append(m_currentLine);

        dispatchCommand(text);
    }
    // up
    else if(p_key == UpKey)
        historyUp();

    // down
    else if(p_key == DownKey)
        historyDown();

    // tab
    else if(p_key == TabKey)
        tabCompleteForward();

    // shift + tab
    else if(p_key == ShiftTabKey)
        tabCompleteBackward();

    // "else"
    else if(isprint(p_key))
    {
        text += p_key;
        m_currentLine->setText(text);
    }

    // check if we should start a new tab completition cycle next time
    m_startNewTabCompletition = (p_key == TabKey||p_key == ShiftTabKey) ?
                                                                  false : true;
}

bool
Console::dispatchCommand(const std::string& p_line, bool p_batchMode)
{
    if(!p_batchMode && !p_line.empty())
    {
        // put line into the history
        m_histIter = m_history.begin();
        m_history.insert(++m_histIter, p_line);

        // .. and reset the iterator
        m_histIter = m_history.begin();
    }

    std::string cmd, args;
    unsigned int state = 0, r = 0;

    // try to parse the command line
    // (strip leading spaces and spaces between the
    //  command name and the arguments)
    for(unsigned int i = 0; i < p_line.size(); i++)
        if(state == 0 && p_line[i] != ' ')
        {
            r = i;
            state = 1;
        }
        else if(state == 1 && p_line[i] == ' ')
        {
            cmd = p_line.substr(r, i-r);
            state = 2;
        }
        else if(state == 2 && p_line[i] != ' ')
        {
            r = i;
            state = 3;
            break;
        }

    // catch some non default cases and set the
    // variables according to them
    if(state < 2 && cmd.empty())
        cmd  = p_line.substr(r, p_line.size()-r);
    else if(state == 3)
        args = p_line.substr(r, p_line.size()-r);


    if(!cmd.empty())
    {
        // if there is not command with that name try to find one that
        // starts with this string and if there is only one set this as
        // the command to execute (like in gdb).
        if(!m_registry.contains(cmd))
        {
            unsigned int found = 0;
            std::string fullCmd;
            SO<Iterator<std::string> > it = m_registry.newKeyIterator();

            for(unsigned int i = 0; i < it->size() && found <= 1; i++)
                if((it->get(i)).find(cmd) == 0)
                {
                    fullCmd = it->get(i);
                    found++;
                }

            if(found != 1)
            {
                if(!p_batchMode)
                    addLine("(command not found)");

                return false;
            }

            cmd = fullCmd;
        }

        // the following code tries to cast to a 2 argument
        // callback first and ifthis fails it tries to
        // cast to a callback without any arguments
        CallbackBase* c = (CallbackBase*)m_registry[cmd];

// 2 arguments
if(dynamic_cast<Callback2<const std::string&,const std::string&>*>(c) != NULL)
    ((Callback2<const std::string&,const std::string&>*)c)->callback(cmd, args);

        // 1 argument
        else if(dynamic_cast<Callback1<const std::string&>*>(c) != NULL)
            ((Callback1<const std::string&>*)c)->callback(args);

        // no args
        else if(dynamic_cast<Callback*>(c) != NULL)
            ((Callback*)c)->callback();

        else
        {
            if(!p_batchMode)
                addLine("(invalid callback)");

            return false;
        }
    }
    // check if the last command is not m_history.end() or if it was empty
    // and if so, dispatch it in batch-mode again.
    else if(!p_batchMode &&
            ++m_histIter != m_history.end() &&
            !(*m_histIter).empty())
        return dispatchCommand(*(m_histIter--), true);

    else
    {
        if(!p_batchMode)
            addLine("(empty line)");

        return false;
    }

    return true;
}

void
Console::historyUp(bool p_realyUp)
{
    // history is empty
    if(m_histIter == m_history.end())
        return;

    // up pressed
    if(p_realyUp)
    {
        // this is the end
        if(++m_histIter == m_history.end())
            m_histIter--;
    }
    // down pressed and this is not the beginning
    else if(m_histIter != m_history.begin())
            m_histIter--;

    m_currentLine->setText(*m_histIter);
}

void
Console::setCanvas(SO<Canvas> p_canvas)
{
    if(p_canvas == m_canvas)
        return;

    if(m_canvas != NULL)
    {
        m_eventCallback->deactivate();
        m_canvas->remove(m_eventCallback);
    }

    m_canvas = p_canvas;

    if(p_canvas == NULL)
        return;

    m_canvas->append(m_eventCallback);
    m_eventCallback->activate();
}

void
Console::handleEvents()
{
    KeyEvent* event = VRS_Cast(KeyEvent, m_eventCallback->currentCanvasEvent());

    if(event != NULL)
        keyEvent(event);

    else
    {
        ResizeEvent* event = VRS_Cast(ResizeEvent,
                                      m_eventCallback->currentCanvasEvent());
        if(event != NULL)
            resizeEvent(event);
    }

    m_canvas->postForRedisplay();
}

void
Console::resizeEvent(SO<ResizeEvent> p_event)
{
    double x1, x2, y1, y2, ratio;
    ratio = double(p_event->width()) / double(p_event->height());

    y2 = double(p_event->height())/2.0/c_pixelsPerChar;
    y1 = -y2;
    x1 = -c_marginX;
    x2 = (double(p_event->height())/c_pixelsPerChar)*ratio;

    m_sceneThing->remove(m_cam);
    m_cam = Camera::newNormalizedDeviceCoordsCamera(x1, x2, y1, y2);
    m_sceneThing->prepend(m_cam);
}

void
Console::keyEvent(SO<KeyEvent> p_event)
{
    if(p_event->pressed())
    {
        if(p_event->keyCode() == '<' || p_event->keyCode() == '^')
            toggleVisibility();

        else if(isVisible())
            handleKey(p_event->keyCode());
    }
}

void
Console::attach(SO<Canvas> p_canvas)
{
    if(! p_canvas->contains(sceneThing()))
        p_canvas->append(sceneThing());

    setCanvas(p_canvas);
}

void
Console::detach()
{
    if(m_canvas->contains(sceneThing()))
        m_canvas->remove(sceneThing());

    setCanvas(NULL);
}

// this 2 macros are used in the next method for makeing it
// easier to read and maintain
#define iterateBackCyclic(BEGIN, END, ITERATOR) \
    { if(ITERATOR-- == BEGIN) { ITERATOR = END; ITERATOR--; } }

#define iterateForwardCyclic(BEGIN, END, ITERATOR) \
    { if(++ITERATOR == END) ITERATOR = BEGIN; }

void
Console::tabCompleteForward(bool p_forward)
{
    if(m_startNewTabCompletition)
    {
        m_currentTabWord = m_currentLine->getText();

        m_tabList.clear();

        SO<Iterator<std::string> > it = m_registry.newKeyIterator();
        int pos;

        // find all commands that start with the current word after
        // which someone pressed tab
        for(unsigned int i = 0; i < it->size(); i++)
        {
            pos = (it->get(i)).find(m_currentTabWord);

            if(pos == 0)
                m_tabList.push_back(it->get(i));
        }

        m_tabList.sort();

        if(p_forward)
        {
            m_tabIter = m_tabList.begin();
            m_lastTabWasForward = true;
        }
        else
        {
            m_tabIter = m_tabList.end();
            m_lastTabWasForward = false;

            if(m_tabIter != m_tabList.begin())
                m_tabIter--;
        }
    }

    // check for empty container
    if(m_tabIter == m_tabList.begin() && m_tabIter == m_tabList.end())
        return;


    if(p_forward)
    {
        // if the last tab was a backwards tab then compensate this by
        // iterating forwards twice
        if(!m_lastTabWasForward)
        {
            iterateForwardCyclic(m_tabList.begin(), m_tabList.end(), m_tabIter);
            iterateForwardCyclic(m_tabList.begin(), m_tabList.end(), m_tabIter);
        }

        m_currentLine->setText(*m_tabIter + " ");

        iterateForwardCyclic(m_tabList.begin(), m_tabList.end(), m_tabIter);
        m_lastTabWasForward = true;
    }
    else
    {
        if(m_lastTabWasForward)
        {
            iterateBackCyclic(m_tabList.begin(), m_tabList.end(), m_tabIter);
            iterateBackCyclic(m_tabList.begin(), m_tabList.end(), m_tabIter);
        }

        m_currentLine->setText(*m_tabIter + " ");

        iterateBackCyclic(m_tabList.begin(), m_tabList.end(), m_tabIter);
        m_lastTabWasForward = false;
    }
}

#undef iterateBackCyclic
#undef iterateForwardCyclic

void
Console::autoexec()
{
    std::fstream stream(ResourceManager::get()->getPathOfFile(
                            "autoexec.txt").c_str(), std::ios_base::in);

    if(!stream.is_open())
        return;

    char lineBuf[255];

    while(stream.good())
    {
        stream.getline(lineBuf, sizeof(lineBuf));

        // ignore empty lines and the ones staring with a #
        if(lineBuf[0] != 0 && lineBuf[0] != '#')
            dispatchCommand(lineBuf, true);
    }

    stream.close();
}

bool
Console::toggleVisibility()
{
    if(isVisible())
    {
        hide();
        return false;
    }
    else
    {
        show();
        return true;
    }
}

bool
Console::isVisible()
{
    return(!m_animationInProgress && m_sceneThing->getNodeState() != 0);
}

void
Console::startAnimation()
{
    m_lastTick = SDL_GetTicks();

    m_animationInProgress = true;

    startTimer(23);
}

void
Console::hide()
{
    if(m_animationInProgress || m_sceneThing->getNodeState() == 0)
        return;


    m_animationDistance = double(m_canvas->getHeight())/2.0/c_pixelsPerChar;
    m_distancePerTick = m_animationDistance / double(c_animationDuration);

    startAnimation();
}

void
Console::show()
{
    if(m_animationInProgress || m_sceneThing->getNodeState() != 0)
        return;


    m_sceneThing->setNodeState(
        SceneNode::EvaluationOn|SceneNode::TraversalOn);

    m_animationDistance = double(m_canvas->getHeight())/2.0/c_pixelsPerChar;
    m_translation->setTranslate(Vector(0.0, m_animationDistance, 0.0));
    m_distancePerTick = -m_animationDistance / double(c_animationDuration);

    startAnimation();
}

void
Console::timerTick()
{
    unsigned int currentTick = SDL_GetTicks();

    // std::cout << "@" << (currentTick - m_lastTick) << std::endl;

    // do not update anything if no time elapsed
    if(currentTick == m_lastTick)
        return;

    Vector tr = m_translation->getTranslate();
    tr[1] += (m_distancePerTick * (currentTick - m_lastTick));


    // catch a finished animation
    if(tr[1] < 0 || tr[1] > m_animationDistance)
    {
        // std::cout << "STOP " << tr[1] << std::endl;

        m_animationInProgress = false;

        // this was a show
        if(m_distancePerTick < 0)
            m_translation->setTranslate(Vector(0,0,0));

        // this was a hide
        else
            m_sceneThing->setNodeState(0);


        stopTimer();
    }
    else
    {
        m_translation->setTranslate(tr);
        m_lastTick = currentTick;
    }
}

} // namespace random_racer

---