random_racer/src/CenterScreenDisplay.cpp

Go to the documentation of this file.

#include <iostream>

#include <vrs/camera.h>
#include <vrs/colorattribute.h>
#include <vrs/font.h>
#include <vrs/opengl/lightmodelgl.h>
#include <vrs/opengl/shapematerialgl.h>
#include <vrs/scaling.h>
#include <vrs/sg/behaviorcallback.h>
#include <vrs/sg/canvas.h>
#include <vrs/sg/resizeevent.h>
#include <vrs/sg/scenething.h>
#include <vrs/text.h>

#include "ResourceManager.h"

#include "CenterScreenDisplay.h"

using namespace VRS;


namespace random_racer
{

const float CenterScreenDisplay::c_pixelsPerChar = 15.0;


CenterScreenDisplay::CenterScreenDisplay(SO<Canvas> p_canvas)
{
    m_thing = new SceneThing();

    m_cam = Camera::newNormalizedDeviceCoordsCamera();
    m_thing->append(m_cam);

    m_thing->append(new LightModelGL(false));

    m_material = new ShapeMaterialGL(Color(1.0, 1.0, 1.0, 1.0));

    m_thing->append(m_material);

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

    m_line1 = new Text(m_font);
    m_line2 = new Text(m_font);

    m_line1->setAlignmentH(Text::CENTER_H);
    m_line2->setAlignmentH(Text::CENTER_H);

    m_line2->setPosition(Vector(0.0, -1.65, 0.0));

    m_thing->append(m_line1);
    m_thing->append(m_line2);

    m_thing->setNodeState(0);

    p_canvas->append(m_thing);


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

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

CenterScreenDisplay::~CenterScreenDisplay()
{
}

void
CenterScreenDisplay::timerTick()
{
    // std::cout << "TICK (new " << m_newTimer << ")" << std::endl;

    if(m_newTimer)
    {
        m_newTimer = false;

        stopTimer();
        startTimer(50);
    }

    Color c = m_material->getPerVertexColor();

    c[3] -= 0.01;


    if(c[3] <= 0)
    {
        m_thing->setNodeState(0);

        // std::cout << "STOP" << std::endl;

        stopTimer();
    }
    else
        m_material->setPerVertexColor(c);
}

void
CenterScreenDisplay::handleResizeEvents()
{
    ResizeEvent* event = VRS_Cast(ResizeEvent,
                                      m_eventCallback->currentCanvasEvent());
    if(event != NULL)
    {
        double x1, x2, y1, y2, ratio;
        ratio = double(event->width()) / double(event->height());

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

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

void
CenterScreenDisplay::showText(
    unsigned int p_msecs,
    const std::string& p_line1,
    const std::string& p_line2)
{
    m_newTimer = true;

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

    m_material->setPerVertexColor(Color(1.0, 1.0, 1.0, 1.0));

    m_line1->setText(p_line1);
    m_line2->setText(p_line2);
    
    if(m_line2->getText().empty())
        m_line1->setAlignmentV(Text::CENTER_V);

    else
        m_line1->setAlignmentV(Text::BOTTOM);


    startTimer(p_msecs);
}

} // namespace random_racer

---