random_racer/src/Presenter.cpp

Go to the documentation of this file.

#include <sstream>

#include <vrs/box.h>
#include <vrs/camera.h>
#include <vrs/opengl/imagetexture2dgl.h>
#include <vrs/opengl/texenvgl.h>
#include <vrs/scaling.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/sg/scenething.h>
#include <vrs/translation.h>
#include <vrs/vector.h>

#include "ResourceManager.h"
#include "Console.h"
#include "Presenter.h"

using namespace VRS;


namespace random_racer
{

const float Presenter::c_maxScaling = 0.6;
const float Presenter::c_startTrans = 0.65;
const float Presenter::c_hideTrans  = 3;

Presenter::Presenter(SO<Canvas> p_canvas)
{
    m_start = false;
    m_hide = false;
    m_show = false;
    m_switch = false;
    m_animation = false;
    m_full = false;
    m_isFull = false;
    m_first = true;
    
    m_slideCount = 1;
    
    m_canvas = p_canvas;
    m_thing = new SceneThing();
    
    m_cam = Camera::newNormalizedDeviceCoordsCamera();
    m_thing->append(m_cam);
    
    m_scaling = new Scaling(Vector(0.01,0.01,0));
    m_thing->append(m_scaling);
    
    m_translation = new Translation(Vector(0,0,0));
    m_thing->append(m_translation);
        
    m_thing->append(new TexEnvGL(TexEnvGL::Replace));
     
    m_texture = ResourceManager::get()->loadTexture2D(
            "pre/pre1.jpg", true, false);
        
    m_thing->append(m_texture);
    
    m_box = new Box(Vector(-1,-1,-1), Vector(1,1,1));
    m_thing->append(m_box);
        
    m_thing->setNodeState(0);
    
    m_canvas->append(m_thing);

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

Presenter::~Presenter()
{
}

void
Presenter::resizeEvent(SO<ResizeEvent> p_event)
{
}

void
Presenter::keyEvent(SO<KeyEvent> p_event)
{
    if(p_event->pressed())
    {
        if(p_event->keyCode() == 'p' && 
           !Console::get()->isVisible() && 
           !m_isFull)
            toggleVisibility();
        
        else if(p_event->keyCode() == 'n' && isVisible() && m_isFull)
        {
            m_slideCount++;
            switchSlide();
        }
        else if(p_event->keyCode() == 'm' && isVisible() && m_isFull)
        {
            m_slideCount--;
            switchSlide();
        }
        else if(p_event->keyCode() == 'f' && 
                isVisible() && 
                !Console::get()->isVisible())
            fullscreen();
    }
}

void
Presenter::toggleVisibility()
{
    if(isVisible())
        hide();
    else
        show();
}

bool
Presenter::isVisible()
{
    return(m_thing->getNodeState() != 0 && !m_animation);
}

void
Presenter::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 
Presenter::startAnimation()
{
    m_animation = true;
    
    startTimer(20);
}

void 
Presenter::startPresentation()
{
    m_start = true;
    
    m_thing->setNodeState(
        SceneNode::EvaluationOn|SceneNode::TraversalOn);
    
    Console::get()->hide();
    
    startAnimation();
    
    m_canvas->append(m_eventCallback);
    m_eventCallback->activate();
}

void
Presenter::show()
{
    m_thing->setNodeState(
        SceneNode::EvaluationOn|SceneNode::TraversalOn);
    
    m_show = true;
    
    startAnimation();
}

void
Presenter::hide()
{
    m_hide = true;
    
    startAnimation();
}

void
Presenter::switchSlide()
{
    
    m_switch = true;
    
    if(m_slideCount > 14 || m_slideCount <= 0)
        m_slideCount = 1;

    startAnimation();
}

void
Presenter::fullscreen()
{
    m_full = true;
    
    m_isFull = !m_isFull;
    
    startAnimation();
}

void
Presenter::switchTexture(unsigned int p_image)
{
    std::stringstream ss;
    std::string str;
    ss << p_image;
    ss >> str;

    m_texture2 = ResourceManager::get()->loadTexture2D(
            "pre/pre"+ str +".jpg", true, false);
        
    m_thing->replace(m_texture, m_texture2);
    m_texture = m_texture2;
    m_texture2 = NULL;
}

void
Presenter::timerTick()
{
    if(m_start)
    {
        Vector scaleTemp = m_scaling->getScale();
    
        if(scaleTemp[0] >= c_maxScaling)
        {
            Vector transTemp = m_translation->getTranslate();
                    
            transTemp[0]+=0.01;
            transTemp[1]+=0.01;
                    
            if(transTemp[0] >= c_startTrans)
            {
                m_start = false;
                m_animation = false;
                stopTimer();
            }
            else
                m_translation->setTranslate(transTemp);
        }
        else
        {
            scaleTemp[0]+=0.01;
            scaleTemp[1]+=0.01;
        
            m_scaling->setScale(scaleTemp);
        }
    }
    else if(m_hide)
    {
        Vector transTemp = m_translation->getTranslate();
        
        transTemp[0]+=0.05;
    
        if(transTemp[0] >= c_hideTrans)
        {
            m_hide = false;
            m_animation = false;
            m_thing->setNodeState(0);
            stopTimer();
        }
        else
            m_translation->setTranslate(transTemp);
    }
    else if(m_show)
    {
        Vector transTemp = m_translation->getTranslate();
        
        transTemp[0]-=0.05;
    
        if(transTemp[0] <= c_startTrans)
        {
            m_show = false;
            m_animation = false;
            stopTimer();
        }
        else
            m_translation->setTranslate(transTemp);
    }
    else if(m_switch)
    {   
        Vector transTemp = m_translation->getTranslate();
        
        if(transTemp[1] >= 3 || !m_first)
        {            
            if(m_first)
            {
                switchTexture(m_slideCount);
            
                m_first = false;
            }
            Vector tranTemp = m_translation->getTranslate();
            
            if(tranTemp[1] < 0)
            {
                m_first = true;
                m_switch = false;
                m_animation = false;
                stopTimer();
            }
            else
            {
                tranTemp[1]-=0.1;
                
                m_translation->setTranslate(tranTemp);
            }
        }
        else
        {
            transTemp[1]+=0.1;
            m_translation->setTranslate(transTemp);
        }
    }
    else if(m_full)
    {
                
        if(m_isFull)
        {
            Vector transTemp = m_translation->getTranslate();
            
            if(transTemp[0] < 0)
            {
                Vector scaleTemp = m_scaling->getScale();

                if(scaleTemp[0] >= 1.0)
                {
                    m_animation = false;
                    m_full = false;
                    stopTimer();
                }
                else
                {
                    scaleTemp[0]+=0.01;
                    scaleTemp[1]+=0.01;

                    m_scaling->setScale(scaleTemp);
                }
            }
            else
            {
                transTemp[0]-=0.01;
                transTemp[1]-=0.01;
                m_translation->setTranslate(transTemp);
            }
        }
        else
        {
            Vector scaleTemp = m_scaling->getScale();

            
            if(scaleTemp[0] <= c_maxScaling)
            {
                Vector transTemp = m_translation->getTranslate();

                transTemp[0]+=0.01;
                transTemp[1]+=0.01;

                if(transTemp[0] >= 0.7)
                {
                    m_full = false;
                    m_animation = false;
                    stopTimer();
                }
                else
                    m_translation->setTranslate(transTemp);
            }
            else
            {
                scaleTemp[0]-=0.01;
                scaleTemp[1]-=0.01;

                m_scaling->setScale(scaleTemp);
            }
        }
    }
}

} // namespace random_racer

---