|| || || || || ||

---

ChangingToView.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
#ifndef OglGui_ChangingToView_h
#define OglGui_ChangingToView_h

#ifndef OglGui_time_included
#include <time.h>
#define OglGui_time_included
#endif

#ifndef OglGui_ChangingToViewListener_h
#include "OglGui/ChangingToViewListener.h"
#endif

#ifndef OglGui_View_h
#include "OglGui/View.h"
#endif

#ifndef OglGui_Window_h
#include "OglGui/Window.h"
#endif

namespace OglGui {

class ChangingToView : public OglGui::View
{
public:
    ChangingToView(Window* wnd, OGLIMAGE *oglIm, float x, float y, float z,
                   float w, float h, float d, ViewListener* li=0) :
        OglGui::View(wnd, oglIm, x, y, z, w, h, d, li)
    {
        Init(x,y,z,w,h,d);
    }

    ChangingToView(OGLWND* oglWnd, OGLIMAGE *oglIm, float x, float y, float z,
                  float w, float h, float d, ViewListener* li=0) :
        OglGui::View(oglWnd, oglIm, x, y, z, w, h, d, li)
    {
        Init(x,y,z,w,h,d);
    }

    ChangingToView(OGLVIEW3D* v) :
        OglGui::View(v)
    {
        float x,y,z,w,h,d;
        GetDimensions3D(&x,&y,&z,&w,&h,&d);
        Init(x,y,z,w,h,d);
    }

    void SetChangingToViewListener(ChangingToViewListener* l, void *userData)
    {
        mListener       = l;
        mListenerData   = userData;
    }

    void MoveDuration(int d)        { mMoveDuration   = d; }
    void SizeDuration(int d)        { mSizeDuration   = d; }
    void RotateDuration(int d)      { mRotateDuration = d; }
    int  MoveDuration()             { return mMoveDuration; }
    int  SizeDuration()             { return mSizeDuration; }
    int  RotateDuration()           { return mRotateDuration; }

    void MoveTo(float x, float y, float z, int duration=500)
    {
        mReqX = (x != FRETAIN ? x : mView3D->x);
        mReqY = (y != FRETAIN ? y : mView3D->y);
        mReqZ = (z != FRETAIN ? z : mView3D->z);
        GetDimensions3D(&mStartX,&mStartY,&mStartZ,0,0,0);

        mIsOnDestiny    = false;
        mMoveDuration   = duration;
        mMoveStartTime  = StartClock();
    }

    void SizeTo(float w, float h, float d, int duration=500)
    {
        mReqW = (w != FRETAIN ? w : mView3D->w);
        mReqH = (h != FRETAIN ? h : mView3D->h);
        mReqD = (d != FRETAIN ? d : mView3D->d);
        GetDimensions3D(0,0,0,&mStartW,&mStartH,&mStartD);

        mIsOnDestiny    = false;
        mSizeDuration   = duration;
        mSizeStartTime  = StartClock();
    }

    void RotateTo(float rX, float rY, float rZ, int duration=500)
    {
        mReqRotX = (rX != FRETAIN ? rX : mView3D->xRot);
        mReqRotY = (rY != FRETAIN ? rY : mView3D->yRot);
        mReqRotZ = (rZ != FRETAIN ? rZ : mView3D->zRot);

        mStartRotX = mCurRotX = mView3D->xRot;
        mStartRotY = mCurRotY = mView3D->yRot;
        mStartRotZ = mCurRotZ = mView3D->zRot;

        mIsOnDestiny        = false;
        mRotateDuration     = duration;
        mRotateStartTime    = StartClock();
    }

    bool IsAt(float& f, float t)
    {
        if (fabs(t-f)<=0.001)
        {
            f = t;
            return true;
        }
        return false;
    }

    bool IsOnMoveDestiny()
    {
        OGLVIEW3D* v = mView3D;
        bool res =  IsAt(v->x,mReqX) && IsAt(v->y,mReqY) && IsAt(v->z,mReqZ);
        return res;
    }

    bool IsOnSizeDestiny()
    {
        OGLVIEW3D* v = mView3D;
        if (mReqW < 0 || mReqH < 0 || mReqD < 0)
            return true;
        bool res = IsAt(v->w,mReqW) && IsAt(v->h,mReqH) && IsAt(v->d,mReqD);
        return res;
    }

    bool IsOnRotateDestiny()
    {
        OGLVIEW3D* v = mView3D;
        float   oX = mCurRotX;
        float   oY = mCurRotY;
        float   oZ = mCurRotZ;

        bool res =  IsAt(mCurRotX,mReqRotX) && IsAt(mCurRotY,mReqRotY) &&
                    IsAt(mCurRotZ,mReqRotZ);

        if (oX!=mCurRotX || oY!=mCurRotY || oZ!=mCurRotZ)
        {
            v->xRot = mCurRotX;
            v->yRot = mCurRotY;
            v->zRot = mCurRotZ;
        }
        return res;
    }

    /* This did not work because of OGL's rotation clamping
    bool IsOnRotateDestiny()
    {
        OGLVIEW3D* v = mView3D;
        bool res =  IsAt(v->xRot,mReqRotX) && IsAt(v->yRot,mReqRotY) &&
                    IsAt(v->zRot,mReqRotZ);
        return res;
    }
    */
    void UpdatePosition(float x, float y, float z)
    {
        float oX,oY,oZ,oW,oH,oD;
        GetDimensions3D(&oX,&oY,&oZ,&oW,&oH,&oD);

        if (x!=oX || y!=oY || z!=oZ)
        {
            SetDimensions3D(x,y,z,oW,oH,oD);
            oglSys.UpdateSceneFlag(mView3D->oglWnd,1);
        }
    }

    void UpdateSize(float w, float h, float d)
    {
        float oX,oY,oZ,oW,oH,oD;
        GetDimensions3D(&oX,&oY,&oZ,&oW,&oH,&oD);

        if (w!=oW || h!=oH || d!=oD)
        {
            SetDimensions3D(oX,oY,oZ,w,h,d);
            oglSys.UpdateSceneFlag(mView3D->oglWnd,1);
        }
    }

    void UpdateRotations(float rX, float rY, float rZ)
    {
        float oX = mCurRotX;
        float oY = mCurRotY;
        float oZ = mCurRotZ;
        if (rX!=oX || rY!=oY || rZ!=oZ)
        {
            mView3D->xRot = mCurRotX = rX;
            mView3D->yRot = mCurRotY = rY;
            mView3D->zRot = mCurRotZ = rZ;
            oglSys.UpdateSceneFlag(mView3D->oglWnd,1);
        }
    }

    /* This did not work because of OGL's rotation clamping
    void UpdateRotations(float rX, float rY, float rZ)
    {
        float oX = mView3D->xRot;
        float oY = mView3D->yRot;
        float oZ = mView3D->zRot;
        if (rX!=oX || rY!=oY || rZ!=oZ)
        {
            mView3D->xRot = rX;
            mView3D->yRot = rY;
            mView3D->zRot = rZ;
            oglSys.UpdateSceneFlag(mView3D->oglWnd,1);
        }
    }
    */

    virtual void OnDrawView()
    {
        if (!mInitialized)
        {
            mInitialized = true;
            mMoveStartTime = mSizeStartTime = mRotateStartTime = StartClock();
        }

        float t           = (float) OglClock()*1000;
        mMoveTimePassed   = (t-mMoveStartTime);
        mSizeTimePassed   = (t-mSizeStartTime);
        mRotateTimePassed = (t-mRotateStartTime);

        if (!IsOnMoveDestiny() && !mView3D->oglWnd->dragging)
        {
            if (mMoveTimePassed > mMoveDuration+200)
                MoveTo(mReqX,mReqY,mReqZ,mMoveDuration);
            else
                DoMovePhysics();
        }
        if (!IsOnSizeDestiny() && mSizeTimePassed < mSizeDuration+100)
            DoSizePhysics();
        if (!IsOnRotateDestiny() && mRotateTimePassed < mRotateDuration+100)
            DoRotatePhysics();
        if (!mIsOnDestiny && IsOnMoveDestiny() && IsOnSizeDestiny() &&
            IsOnRotateDestiny())
        {
            mIsOnDestiny = true;
            if (mListener)
                mListener->OnChangingToViewDestiny(this, mListenerData);
        }
        OglGui::View::OnDrawView();
    }

private:
    float StartClock()
    {
        oglSys.UpdateSceneFlag(mView3D->oglWnd,1);
        return (float) OglClock()*1000;
    }

    float TimePassedFactor(float tPassed, float tDuration)
    {
        if (tPassed <= tDuration)
            oglSys.UpdateSceneFlag(mView3D->oglWnd,1);
        else
            tPassed = tDuration;
        return tDuration>0 ? tPassed/tDuration : 1;
    }

    void DoMovePhysics()
    {
        float fact = TimePassedFactor(mMoveTimePassed,mMoveDuration);
        float x = mStartX + fact * (mReqX-mStartX);
        float y = mStartY + fact * (mReqY-mStartY);
        float z = mStartZ + fact * (mReqZ-mStartZ);
        UpdatePosition(x,y,z);
    }

    void DoSizePhysics()
    {
        float fact = TimePassedFactor(mSizeTimePassed,mSizeDuration);
        float w = mStartW + fact * (mReqW-mStartW);
        float h = mStartH + fact * (mReqH-mStartH);
        float d = mStartD + fact * (mReqD-mStartD);
        UpdateSize(w,h,d);
    }

    void DoRotatePhysics()
    {
        float fact = TimePassedFactor(mRotateTimePassed,mRotateDuration);
        float rX = mStartRotX + fact * (mReqRotX-mStartRotX);
        float rY = mStartRotY + fact * (mReqRotY-mStartRotY);
        float rZ = mStartRotZ + fact * (mReqRotZ-mStartRotZ);
        UpdateRotations(rX,rY,rZ);
    }

    void Init(float x, float y, float z, float w, float h, float d)
    {
        SetTags(FlexViewTags);
        mListener           = false;
        mInitialized        = false;
        mIsOnDestiny        = true;

        mMoveDuration       = 0;
        mSizeDuration       = 0;
        mRotateDuration     = 0;

        mStartX = mReqX     = x;
        mStartY = mReqY     = y;
        mStartZ = mReqZ     = z;

        mStartW = mReqW     = -1;
        mStartH = mReqH     = -1;
        mStartD = mReqD     = -1;

        mStartRotX = mCurRotX = mReqRotX = mView3D->xRot;
        mStartRotY = mCurRotY = mReqRotY = mView3D->yRot;
        mStartRotZ = mCurRotZ = mReqRotZ = mView3D->zRot;
    }

    ChangingToViewListener* mListener;
    void*                   mListenerData;

    bool            mInitialized;
    bool            mIsOnDestiny;
    float           mMoveStartTime;
    float           mMoveTimePassed;
    float           mSizeStartTime;
    float           mSizeTimePassed;
    float           mRotateStartTime;
    float           mRotateTimePassed;
    float           mMoveDuration;
    float           mSizeDuration;
    float           mRotateDuration;
    float           mStartX, mStartY, mStartZ;
    float           mStartW, mStartH, mStartD;
    float           mStartRotX, mStartRotY, mStartRotZ;
    float           mCurRotX, mCurRotY, mCurRotZ;
    float           mReqX, mReqY, mReqZ;
    float           mReqW, mReqH, mReqD;
    float           mReqRotX, mReqRotY, mReqRotZ;

   //ILOG_VAR_DEC;
}; // class ChangeToView

//ILOG_VAR_INIT(ChangeToView, OglGui);

} // namespace OglGui

#endif

---