OwnCursor.cpp

Go to the documentation of this file.

#include "Application.hpp"

OwnCursor::OwnCursor(Application* app)
    : m_app(app)
    , m_tex_arrow(app->getTextures().get("hand.gif"))
    , m_tex_hand(app->getTextures().get("arrow.gif"))
    , m_lastMeasure(0)
    , m_lastSpF(0)
    , m_active_hand(true)
    , m_scale_linear(true)
    , m_scale(1.0f)
    , m_minScale(0.4f)
    , m_maxScale(1.2f)
    , m_blink(true)
    , m_cushion_factor(0.8f)
{
}

void OwnCursor::toggleImage()
{
     m_active_hand = !m_active_hand;
}

void OwnCursor::toggleScaleFunction()
{
     m_scale_linear = !m_scale_linear;
}

void OwnCursor::updateCushionFactor(float value)
{
    if((m_cushion_factor > 0.4 && value < 0) || (m_cushion_factor < 2 && value > 0)) m_cushion_factor += value;
}

void OwnCursor::onKeyStateChanged(int key, bool pressed)
{
    if (!pressed) return;

    if (key == GLFW_KEY_F5) toggleScaleFunction();

    if (key == GLFW_KEY_F6) toggleImage();

    if (key == GLFW_KEY_F7) updateCushionFactor(-0.05f);

    if (key == GLFW_KEY_F8) updateCushionFactor(0.05f);
}


vec2 OwnCursor::calculateCursorPosInVisualSpace(vec2 cursorPosBeforeMove, vec2 const & deltaMotorSpace)
{
    auto& wnd = m_app->getWindow();

    auto deltaLength = glm::length(deltaMotorSpace);

    if ( deltaLength > glm::epsilon<float>()) // only calculate if cursor was moved
    {
        auto deltaDir = deltaMotorSpace/deltaLength;
        
        while( deltaLength > glm::epsilon<float>() ) // move by distance 1 at once, then again by 1 until whole cursor-delta is passed
        {
            auto length = glm::min( deltaLength, 1.0f );

            cursorPosBeforeMove = calculateCursorMoveDeltaInVisualSpace(cursorPosBeforeMove, deltaDir*length);

            deltaLength -= length;
        }
    }
    
    return cursorPosBeforeMove;
}

vec2 OwnCursor::calculateCursorMoveDeltaInVisualSpace(vec2 const & cursorPosBeforeMove, vec2 const & deltaMotorSpace)
{
    // calculate scale
    {
        auto D = m_app->getPicker().getFocusDistance();     // C...cutoff distance
        auto C = m_app->getPicker().maxDistance();          // D...distnace to nearest target
        
        float t = 1.0f;

        if(m_scale_linear)
        {
            // linear scaling function
            t = D/C;
        }
        else
        {
            // invers scaling function
            float s = 0.5f;         // scaling constant (emperically chosen)
            t = 1.0f - pow((D+1),-s);
        }

        m_scale = glm::mix(m_minScale,
                           m_maxScale,
                           glm::clamp(t,
                                      0.0f,
                                      1.0f));
    }

    // update scale-factor by cushion-factor
    float scaleCushion = m_scale*m_cushion_factor;
    
    // return new cursor-pos
    return cursorPosBeforeMove + deltaMotorSpace * scaleCushion;
}

void OwnCursor::update(double time, double timeDelta)
{
    const double updateDelta = 0.3;
    
    if (time > (m_lastMeasure + updateDelta))
    {
        m_lastMeasure = time;
        m_lastSpF = timeDelta;
        m_blink = !m_blink;
    }
}

void OwnCursor::draw(double time, double timeDelta)
{
    auto& wnd = m_app->getWindow();
    auto& wndSize = m_app->getWindow().getSize();
    auto& sprite = m_app->getSprites();

    auto cursorPos = wnd.getCursor();

    auto px = [wndSize]
              (float x, float y)
              { 
                  return vec2(x / wndSize.x, y / wndSize.y); 
              };

    sprite.begin2D();
    {
        sprite.begin();
        {
            if(m_active_hand)
                m_tex_hand->bind();
            else
                m_tex_arrow->bind();

            // hand
            {
                int tex_size_x;
                int tex_size_y;

                if(m_active_hand){
                    tex_size_x= m_tex_hand->getSize().x;
                    tex_size_y= m_tex_hand->getSize().y;
                }else{
                    tex_size_x= m_tex_arrow->getSize().x;
                    tex_size_y= m_tex_arrow->getSize().y;
                }
                
                // red-white color-sheme
                float g = (m_scale-m_minScale)*(1.0f/(m_maxScale-m_minScale)); // min_scale...max_scale auf 0..1 mappen
                float b = g;
                float r = 1.0f;

                // blinking
                if((m_scale-m_minScale) <= 0.01 && m_blink){
                    r = 0.8f;
                    g = 0.0f;
                    b = 0.0f;
                }
                if((m_scale-m_minScale) <= 0.01 && !m_blink){
                    r = 1.0f;
                    g = 1.0f;
                    b = 1.0f;
                }

                // cursor scaling
                float cursor_scale = 0.7f+0.4f*(m_scale-m_minScale)*(1.0f/(m_maxScale-m_minScale)); // map scale to 0.7...1.1 for icon-scaling

                sprite.draw(vec4(r, g, b, 1.0f), px(cursorPos.x, wndSize.y-cursorPos.y), px(tex_size_x*cursor_scale, tex_size_y*cursor_scale), vec2(1,-1), HAlign::Left, VAlign::Top);
            }
        }
        sprite.end();
    }
    sprite.end2D();
}