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

---

Carousel3D.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
// Author: Richard van Balen
#ifndef OglGui_Carousel3D_h
#define OglGui_Carousel3D_h

#include <vector>

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

#ifndef OglGui_Carousel3DListener_h
#include "OglGui/Carousel3DListener.h"
#endif

#ifndef OglGui_ChangingToView_h
#include "OglGui/ChangingToView.h"
#endif

namespace OglGui {

class Carousel3D :  public Window,
                    public ChangingToViewListener
{
public:
    Carousel3D(int x, int y, int w, int h) :
        Window(x, y, w, h, false)
    {
        Init(w,h);
    }

    Carousel3D(Window* parent, int x, int y, int w, int h) :
        Window(parent, x, y, w, h, false)
    {
        Init(w,h);
    }

    void SetCarousel3DListener(Carousel3DListener* l, void *userData)
    {
        mListener = l;
        mListenerData = userData;
    }

    virtual void OnChangingToViewDestiny(ChangingToView* v, void *userData)
    {
        int idx = (int)(long long) userData;
        if (mListener)
            mListener->OnChangingToViewDestination(this, idx, mListenerData);
    }

    float   CenterX()                       { return mCenterX; }
    float   CenterY()                       { return mCenterY; }
    float   CenterZ()                       { return mCenterZ; }
    float   Radius()                        { return mRadius; }

    void    Friction(double f)              { mFriction = f; }
    double  Friction()                      { return mFriction; }

    OGLVIEW3D* AddView(strconst str)
    {
        OGLVIEW3D* v = view3DSys.View3D(mOglWnd, 0, 0, 0, 0, 1, 1, 1);
        if (v)
        {
            //view3DSys.SetTags(v, FlexViewTags);
            mOglViews.push_back(v);
            mTitles.push_back(str);
        }
        return v;
    }

    void
    AddCaptureView(strconst str, int x, int y, int w, int h, bool capture=true)
    {
        OGLVIEW3D* v = AddView(str);
        view3DSys.SetRotation(v, 180, 0, 0);
        view3DSys.SetTexFilter(v, 0, GL_LINEAR);
        view3DSys.SetTexFilter(v, 1, GL_LINEAR);
        OGLIMAGE* oglIm = MyOglImage(4, 10, 10);
        oglIm->noTexScaling = 1;
        v->im = oglIm;

        ChangingToView* chToView = new ChangingToView(v);
        int idx = mTitles.size()-1;
        chToView->SetChangingToViewListener(this, (void *) idx);
        mChangingToViews.push_back(chToView);

        if (capture)
            OglImCapture(v->im, x, y, w, h);
    }

    ChangingToView* ChToView(int idx)
    {
        if (idx < 0 || idx >= mChangingToViews.size())
            return 0;
        return mChangingToViews[idx];
    }

    int IndexOf(strconst str)
    {
        for (int i=0; i<mTitles.size(); i++)
        {
            if (str == mTitles[i])
                return i;
        }
        return -1;
    }

    int IndexOf(OGLVIEW3D* v)
    {
        for (int i=0; i<mOglViews.size(); i++)
        {
            if (v == mOglViews[i])
                return i;
        }
        return -1;
    }

    void TitledCapture(strconst str, int x, int y, int w, int h)
    {
        int idx = IndexOf(str);
        if (idx == -1)
            AddCaptureView(str, x, y, w, h);
        else
        {
            OglImCapture(mOglViews[idx]->im, x, y, w, h);
            CheckOglImageChanged(mOglViews[idx]->im);
            for (int i=0; i<mOglViews.size(); i++)
            {
                OGLVIEW3D*  oglV3D  = mOglViews[i];
                OGLIMAGE*   im      = oglV3D->im; 
                oglV3D->w = (w/(float)h);
                oglV3D->h = 1;
                float tW = im->noTexScaling ? im->texW : im->w;
                float tH = im->noTexScaling ? im->texH : im->h;
                float zX = (oglV3D->w)*(tW/im->w);
                float zY = (oglV3D->h)*(tH/im->h);
                view3DSys.SetZoom(oglV3D,zX,zY);
            }
        }
    }

    void Clamp360(float& f)
    {
        while (f < 0)
            f += 360;
        while (f - 360 > 0)
            f -= 360;
    }

    void RotateTo(float deg, int ms=500)
    {
        Clamp360(mCenterRotY);
        Clamp360(deg);

        float diff    = deg - mCenterRotY;
        float absDiff = fabs(diff);

        if ((mCenterRotY == deg) || absDiff <= 0.2 || absDiff >= 359.8)
        {
            mCenterRotY     = deg;
            mIsRotatingTo   = false;
            return;
        }
        if (absDiff > 180)
            deg += (diff > 0 ? -360 : 360);

        mRotateTo           = deg;
        mRotateToStart      = mCenterRotY;
        //mRotateToDuration   = ms;
        mRotateToDuration   = ms/1000.0;
        //mRotateToStartTime  = clock();
        mRotateToStartTime  = OglClock();
        mIsRotatingTo       = true;
    }

    void RotateToSpike(int idx, int ms=500)
    {
        float spikes  = 360.f / mOglViews.size();
        RotateTo(-idx * spikes, ms);
        UpdateScene();
    }

    void RotateToNearest(int ms=500)
    {
        Clamp360(mCenterRotY);
        int     nrOfViews = mOglViews.size();
        float   spikes    = 360.f / nrOfViews;
        float   n         = floor(0.5f + mCenterRotY / spikes);
        int     s         = abs(n-nrOfViews);
        RotateToSpike(s);
    }

    void HandleRotateTo()
    {
        if (!mIsRotatingTo)
            return;

        //float timePassed = clock() - mRotateToStartTime;
        double timePassed = OglClock() - mRotateToStartTime;
        if (timePassed > mRotateToDuration)
        {
            mCenterRotY   = mRotateTo;
            mIsRotatingTo = false;
            return;
        }
        double factor = timePassed/mRotateToDuration;
        mCenterRotY  = mRotateToStart + factor * (mRotateTo-mRotateToStart);
        UpdateScene();
    }

        virtual void DisplayFunc()
        {
        if (!mShowCarousel)
            return;

        OGC myOGC;
        OGCSave(&myOGC);

                view3DSys.View3DCameraTransform(mOglWnd);

        int nrOfViews = mOglViews.size();

        mRadius  = (nrOfViews*mOglViews[0]->w) / OGL_PI_2;
        mCenterZ = -mRadius - 1.5;
                glTranslatef(mCenterX, mCenterY, mCenterZ);
                glRotatef(mCenterRotY, 0.0f, 1.0f, 0.0f);       // Rotate Y

                for (int i=0; i<nrOfViews; i++)
                {
                        glPushMatrix();
                        glRotatef( i * 360.f/nrOfViews, 0.0f, 1.0f, 0.0f );
            glTranslatef(0, 0, mRadius);
                    view3DSys.DrawView(mOglViews[i]);
                        glColor3f( 1.0f, 1.0f, 0.0f );
                        oglSys.Printf3D(mTxtFontBase, -0.5, 0.5, 0.1, 0.08, 0.08, 0.01,
                            "%s", mTitles[i].c_str());
                        glPopMatrix();
                }
        OGCRestore( &myOGC );
        glLoadName(0);

        HandleRotateTo();

//SetAlwaysDraw(mFlowing || mIsRotatingTo);
        if (!mFlowing)
            return;

        //float   t    = (clock() - mFlowDragStartTime)/1000.f;
        float   t    = (OglClock() - mFlowDragStartTime);
        float   endT = fabs(mFlowSpeed / mFriction);
        if (t >= endT)
        {
            t = endT;
            mFlowing = false;
            //SetAlwaysDraw(mFlowing = false);
            UpdateScene();
            RotateToNearest();
        }
        float d = mFlowSpeed*t + (0.5 * (mFlowSpeed>0?1:-1)*mFriction * (t*t));
        mCenterRotY = mFlowStartRotY + d;
        }

    virtual void MouseFunc(int msg, int btn, int state, int x, int y)
    {
        Window::MouseFunc(msg, btn, state, x, y);

        if (msg == oglMouseDown && btn == oglLeftButton)
        {
            if (mDragged = ((mFlowing||mIsRotatingTo) ? true : false))
                SetAlwaysDraw(mFlowing = mIsRotatingTo = false);
            //mFlowDragStartTime  = clock();
            mFlowDragStartTime  = OglClock();
            mDragStarted        = true;
            mFlowDragDiff       = 0;
            mFlowDragStartX     = x;
            mFlowDragLastX      = x;
            mFlowStartRotY      = mCenterRotY;
        }
        if (msg == oglMouseMove && mDragStarted)
        {
            mFlowDragDiff  = mFlowDragLastX - x;
            mCenterRotY   -= mFlowDragDiff / 10.f;
            mFlowDragLastX = x;
            if (fabs(mFlowStartRotY - mCenterRotY) > mDragPixThreshold)
                mDragged = true;
        }
        if (msg == oglMouseUp && btn == oglLeftButton)
        {
            OGLVIEW3D*    v;
            if (!mDragged && mListener && (v = view3DSys.FindView(mOglWnd,x,y)))
                mListener->OnCarousel3D(this, IndexOf(v), mListenerData);
            if (mDragged)
            {
                //double t = (clock() - mFlowDragStartTime) / (CLOCKS_PER_SEC*1.);
                double t = (OglClock() - mFlowDragStartTime);
                if (t<0.1) t = 0.1;
                mFlowSpeed = ((x-mFlowDragStartX)/10.f) / t;
                if (abs(mFlowDragDiff) < 5)
                    mFlowSpeed = 0;
                SetAlwaysDraw(mFlowing = (fabs(mFlowSpeed) > 30));
                mFlowStartRotY     = mCenterRotY;
                //mFlowDragStartTime = clock();
                mFlowDragStartTime = OglClock();
            }
            mDragStarted = mDragged = false;
        }
    }

    virtual void InitFunc()
        {
                OGLWND* oglWnd = oglSys.GetTopOGLWND( mOglWnd );
        void*   font;

#ifdef OGL_USING_GLUT
                mTxtFontBase = oglSys.Create3DFont( mOglWnd, font, 1, 0.6f, NULL );
#else
                font = (void*) CreateFont(
                        -12, 0, 0, 0, FW_NORMAL, 0, 0, 0,
                        ANSI_CHARSET, OUT_TT_PRECIS, CLIP_DEFAULT_PRECIS,
                        ANTIALIASED_QUALITY, VARIABLE_PITCH | FF_DONTCARE, "Verdana" );
                // Transform MsWindows fonts to OpenGL fontBases
                mTxtFontBase = oglSys.Create3DFont( mOglWnd, font, 1, 0.6f, NULL );
                // MsWindows font no longer needed
                DeleteObject( (HFONT) font );
#endif
                Window::InitFunc();
        }

protected:

    void ReadPixels(OGLIMAGE* oglIm, int x, int y, int w, int h)
    {
        if (oglIm->imData)
            free(oglIm->imData);

            // Allocate memory for a 4 byte RGBA buffer
            if( !(oglIm->imData = (void *) malloc(w * h * 4))){
                    oglSys.ErrorBox("Error", "Could not allocate image memory");
                    exit( 0 );;
            }
        oglIm->w = w;
        oglIm->h = h;

            // Specification of our image alignment
            glPixelStorei(GL_UNPACK_ALIGNMENT, 1); // Contineous pixels
            glPixelStorei(GL_UNPACK_ROW_LENGTH, w); // Width of 1 line in our buffer
            glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
            glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);

            glReadPixels( x, y, w, h, GL_RGBA, GL_UNSIGNED_BYTE, oglIm->imData );

        glPixelStorei( GL_UNPACK_SKIP_PIXELS, 0 );
        glPixelStorei( GL_UNPACK_SKIP_ROWS, 0 );
        glPixelStorei( GL_UNPACK_ROW_LENGTH, 0 );
        oglIm->changed = 1;
    }

    void OglImCapture(OGLIMAGE* oglIm, int x, int y, int w, int h)
    {
        if (!oglIm)
            return;
        ReadPixels(oglIm, x, y, w, h);
    }

    OGLIMAGE* MyOglImage(int type, int w, int h)
    {
        OGLIMAGE* oglIm   = NewOglImage(type, w, h);
        oglIm->imData     = calloc(w*h,4);
        memset(oglIm->imData, 0x80, w*h*4);
        oglIm->imDataFunc = MyOglImDataFunc;
        oglIm->onDestroy  = MyOglImDestroy;
        return oglIm;
    }

private:
    static void *MyOglImDataFunc(OGLIMAGE *oglIm)
    {
        return (void *) oglIm ? oglIm->imData : 0;
    }

    static void MyOglImDestroy(OGLIMAGE *oglIm)
    {
        if (!oglIm)
            return;
        if(oglIm->imData)
            free(oglIm->imData);
        oglIm->imData = 0;
    }

    void Init(int w, int h)
    {
//SetBackground(oglTrRED);
        SetBorderFillShaded(-2);
        oglSys.SetAllowCameraMove(mOglWnd, CamMove_Mouse);
        oglSys.AllowPicking(mOglWnd, false, false);
        Friction(-150);

        mTargetOGLWND       = oglSys.GetTopOGLWND(mOglWnd);
        mShowCarousel       = true;
        mDragStarted        = false;
        mDragged            = false;
        mFlowing            = false;
        mIsRotatingTo       = false;
        mRotateToDuration   = 0;
        mDragPixThreshold   = 3;
        mCenterX            = 0;
        mCenterY            = 0;
        mCenterZ            = -4.5;
        mCenterRotY         = 0;
    }

    Carousel3DListener*             mListener;
    void*                           mListenerData;

    std::vector<OGLVIEW3D*>         mOglViews;
    std::vector<ChangingToView*>    mChangingToViews;
    std::vector<std::string>        mTitles;

    OGLWND*                         mTargetOGLWND;
    bool                            mShowCarousel;
    int                             mDragLastX;
    int                             mDragPixThreshold;
    int                             mTxtFontBase;

    //clock_t                         mRotateToStartTime;
    double                          mRotateToStartTime;
    bool                            mIsRotatingTo;
    //int                             mRotateToDuration;
    double                          mRotateToDuration;
    float                           mRotateToStart;
    float                           mRotateTo;
    float                           mCenterRotY;
    float                           mCenterX;
    float                           mCenterY;
    float                           mCenterZ;
    float                           mRadius;

    //clock_t                         mFlowDragStartTime;
    double                          mFlowDragStartTime;
    double                          mFlowSpeed;
    double                          mFriction;
    int                             mFlowDragDiff;
    int                             mFlowDragStartX;
    int                             mFlowDragLastX;
    int                             mFlowStartRotY;
    bool                            mDragStarted;
    bool                            mDragged;
    bool                            mFlowing;
};

} // namespace OglGui
#endif

---