Inertia.cpp

Go to the documentation of this file.

/* ***********************************************************************************
        Writer:         Sebastien Bloc
        Copyright:      2003-2004
        eMail:          sebastien.bloc@free.fr
        URL:            http://mignonsoft.free.fr

        This program is free software; you can redistribute it and/or
        modify it under the terms of the GNU General Public License
        as published by the Free Software Foundation; either version 2
        of the License, or (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
        http://www.gnu.org/copyleft/gpl.html
*********************************************************************************** */

#include "inertia.h"
#include "control.h"
#include "controlEngine.h"

extern ControlEngine ce;

Inertia::Inertia()
{
        viewTime = 0;
        inertiaTime = 0;
}

void Inertia::Start(double _viewTime,double _inertiaTime)
{
        viewTime = _viewTime;
        inertiaTime = _inertiaTime;
        timer.GetDeltaTime(TRUE);
}

void Inertia::Add(Point2D<int> element)
{
        ElemStack elemStack;
        elemStack.elem=element;
        elemStack.timing = timer.GetDeltaTime(FALSE);
        stack.Push(elemStack);
}

Point2D<double> Inertia::GetMoyValue()
{
        double timing = timer.GetDeltaTime(FALSE);
        Point2D<double> power; 
        ElemStack elemStack;
        double timeInside=-1;

        // on elimine tout les elements dont le timing est depasée
        while (1) 
        {
                if (!stack.GetNbElem()) return power; 
                elemStack = stack.FrontPeek();
                timeInside = elemStack.timing+inertiaTime-timing+viewTime;
                if (timeInside>0) break;
                stack.FrontPop();
        };

        power.x = (double)elemStack.elem.x*timeInside; 
        power.y = (double)elemStack.elem.y*timeInside; 

        // on ajout tout le rest
        double lastTime=0; // gestion des coupures entre elements 
        double deltaTime;
        for (stack.i=0;stack.i.More();stack.i++)
        {
                elemStack = stack.i.GetElem();
                timeInside = timing-elemStack.timing;
                deltaTime=timeInside-lastTime;
                lastTime=timeInside;
                if (timeInside>inertiaTime) timeInside = inertiaTime;
                power.x += (double)elemStack.elem.x*deltaTime; 
                power.y += (double)elemStack.elem.y*deltaTime; 
        }

        // calcul de moyenne
        power/=viewTime; // T doit avoir "void operateur/=(double)"
        return power;
}

EventInertia::EventInertia()
{
        numButton= -1;
        face = -1;
        enable = FALSE;
}

void EventInertia::Init(int _numButton)
{
        numButton=_numButton;
}

void EventInertia::operator=(EventInertia &src)
{
        enable = src.enable;
        face = src.face;
        mousePos = src.mousePos;
        mouseState = src.mouseState;
        numButton = src.numButton;
        timer = src.timer;
        vectorInertia = src.vectorInertia;
}

void EventInertia::Start(int _face,Point2D<double> _vectorInertia)
{
        face = _face;
        vectorInertia = _vectorInertia;
        ce.pickingInertia=ce.pickingCursor;
        mouseState = &ce.pickingInertia.mouse;
        mousePos.x = mouseState->pos.x;
        mousePos.y = mouseState->pos.y;
        SwitchButton();

        BindTimer(timer,OnInertia,40); 
}

void EventInertia::SwitchButton()
{
        switch (numButton)
        {
                case 0: mouseState->leftBtn=!mouseState->leftBtn; break;        // left
                case 1: mouseState->midBtn=!mouseState->midBtn; break;          // mid
                case 2: mouseState->rightBtn=!mouseState->rightBtn; break;      // right
        }
}

void EventInertia::Stop()
{
        timer.Stop();
        enable=FALSE;
        ce.usingInertia--;
        switch (numButton)
        {
                case 0: ce.pickingInertia.OnLButtonUp(); break;
                case 1: ce.pickingInertia.OnMButtonUp(); break;
                case 2: ce.pickingInertia.OnRButtonUp(); break;
        }
}

#define TIME_MOVE_ON_INERTIA 2.0 // durée de l'inertie: 2 seconds
int EventInertia::OnInertia(Timer *timerCur)
{
        double delta = timer.GetDeltaTime();
        double coef = (TIME_MOVE_ON_INERTIA-delta)/TIME_MOVE_ON_INERTIA;
        if (coef<=0) 
        { 
                Stop(); 
                return 0; 
        }

        Point2D<double> vectorInertiaCur=vectorInertia*coef;

        mousePos.x-=vectorInertiaCur.x;
        mousePos.y-=vectorInertiaCur.y;

        ce.pickingInertia.OnMouseMove((int)mousePos.x,(int)mousePos.y);
        return 0;
}

---