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

---

ViewSphere.h

Go to the documentation of this file.

// RvB: Status: Demonstration/Example purpose only.
//
// Maybe in future, when time allows, give it a real interface
// of adding images, changing the number of columns and rows, etc..

#ifndef OglGui_ViewSphere_h
#define OglGui_ViewSphere_h

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

#define MyFabs(f)   ((f<0)?(-f):(f))
#define SPHERE_TAG  (1<<24)
#define NCOL 10
#define NROW 24

namespace OglGui
{

static char *viewSpherekeyCmd[] = {
                "",             "",                                     // Empty string generates 6 pixel gap
                "i",    "show/hide this information",
                "?",    "show/hide 3D viewer keys",
                "",             "",                                     // Empty string generates 6 pixel gap
                "F9",   "Object shape 0 (ownerdrawn)",
                "F1..F8",       "Object shape 1 .. 8",
                "",             "",                                     // Empty string generates 6 pixel gap
                "E/e",  "Increase/Decrease ring Extrusion",
                "R/r",  "Increase/Decrease sphere Radius",
        "",     "",
                "f",    "Toggle Fill with central viewer",
                "F",    "Toggle Fixed/Polar view dimensions",
                "=",    "Toggle Double/Single Ring",
                "v",    "Toggle vertical/horizontal ring",
                "t",    "Toggle Text",
        "",     "",
                "9",    "Rotate Sphere 90 deg over Z-axis",
        "",     "",
                "A",    "Animate swirling viewers",
        "Ctrl A/a", "Increase/Decrease Animation steps",
                "C",    "Row change",
                "c",    "Column change",
        "S/s",  "Increase/Decrease rotate ring speed",
                "a",    "Toggle Auto rotate ring",
                "ScrollWheel",  "Rotate ring",
        "",     "",
                "#",    "Pauze/Continue",
                "CTRL x,y,z / X,Y,Z", "Decrease/Increase Spheres X/Y/Z rotation speed",
                "ESC",  "Reset Sphere Rotation",
                "@KEY", "@ACTION",
                NULL,   NULL // The string array must end with a row of NULL.
};


class ViewSphere : public Window
{
public:

    ViewSphere(int x, int y, int w, int h) :
        Window(x, y, w, h, false)
        {
                Init();
        InitSphere();
        }

    ViewSphere(Window *parent, int w, int h) :
        Window(parent, w, h, false)
        {
                Init();
        InitSphere();
        }

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

        void
        InitSphere()
        {
                int                     i, j;
                OGLVIEW3D       *oglView;

                for( i=0; i<7; i++ )
                {
                        char    buf[100];

                        sprintf(buf, "Im_%d.png", i+1 );
                        if( !(oglIm[i] = TryReadPNG( buf )) )
                printf("Reading mock-up image %s failed\n", buf);
                }

                for( i=0; i<NCOL; i++ )
                        for( j=0; j<NROW; j++ )
                        {
                                oglView = view3DSys.View3D( mOglWnd, oglIm[(i+j)%7], 0,0,0, 1.96f,1.4f,1 );
                oglSys.ReleaseOglImage(oglIm[(i+j)%7]);
                // next line, instead of previous, would let every 2e viewer stick out 1 unit
                                // oglView = view3DSys.View3D( mOglWnd, oglIm[j%20], 0,0,(j%2)?0.0f:-1.0f,1.9f,1.4f,1 );
                                view3DSys.SetZoom( oglView, 1.76f, 1.2f );
                                view3DSys.SetTags( oglView, FlexViewTags | SPHERE_TAG );
                                view3DSys.SetBgColor( oglView, oglWHITE );
                                // Ork: Next line sets object3D to 0 for ownerdrawing
                                view3DSys.SetObject3D( oglView, 0  );

                                // Next line sets viewers to different object3D
                                //view3DSys.SetObject3D( oglView, (i+j) % 9  );
                        }

                SetBackground( oglWHITE );

                // Central Sphere to prevent see-through tiling
                // NOTE: Use of viewer here only for test purposes.
                // Should use a stand-alone sphere rather then a 3D viewer
                centralView = view3DSys.View3D( mOglWnd, oglIm[0], 0,0,-20,
                                                                2 * mRadius - 0.3f, 2 * mRadius - 0.3f,1.0f );
                centralView->drawMode = OGL_FILL;
                centralView->object3D = OGL_SPHERE;
                centralView->drawColor = 0x80c0f0c0;
                view3DSys.SetTags( centralView, visibleTag|selectableTag|sizableTag );

                oglSys.SetAllowCameraMove( mOglWnd, 1 );
                oglSys.AllowPicking( mOglWnd, 1, 1 );
                oglSys.SetAlwaysDraw( mOglWnd, 1 );
        }

    void InitAnimation()
    {
        LIST        *obj;
        OGLVIEW3D   *view;
        int         i = 0;

        mAnimCnt = mAnimSteps;
        ForAllElements( obj, mOglWnd->objectList ){
            view = (OGLVIEW3D *) obj->info;
            view->x -= i * 0.1f;
            view->y -= i * 0.1f;
            i++;
        }
    }

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

//#ifndef OGL_USING_GLUT
#if defined(Q_OS_WIN) || (!defined(OGL_USING_GLUT) && !defined(OGL_USING_QT))
                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, (LPCTSTR) "Verdana" );
#endif
                // Transform MsWindows fonts to OpenGL fontBases
                txtFontBase = oglSys.Create3DFont( mOglWnd, font, 1, 0.6f, NULL );

#if defined(Q_OS_WIN) || (!defined(OGL_USING_GLUT) && !defined(OGL_USING_QT))
        // MsWindows font no longer needed
                DeleteObject( (HFONT) font );
#endif
                Window::InitFunc();

        InitAnimation();
        sphereInfoBox = oglSys.InfoBoxStrArr( oglWnd, &viewSpherekeyCmd[0], 2, 20, 0x0080ff, oglRED, oglWHITE );
        }

    virtual void
    ExitFunc()
    {
        oglSys.InfoBoxDestroy( sphereInfoBox );

    }

        virtual void
        KeyboardFunc( INT c, INT state )
        {
                INT                     shiftDown = state & oglShift;
                FLOAT           add = shiftDown ? 0.01f : -0.01f;

                if( c=='c' ){
                        mVertRingNr += 1;
                        if( mVertRingNr == NCOL )
                                mVertRingNr = 0;
                }
                else if( c=='C' ){
                        mHorRingNr += 1;
                        if( mHorRingNr == NROW )
                                mHorRingNr = 0;
                }
        else if (c=='s' || c=='S')
            mRotRingDelta += (c=='S') ? 0.05f : -0.05f;
                else if( c == 'R' || c == 'r' ) // Radius of sphere
                        mRadius += (c=='R') ? 0.2f : -0.2f;
                else if( !(c==oglCTRL('x')) && !(c==oglCTRL('y')) && !(c==oglCTRL('z')) )
                        Window::KeyboardFunc( c, state );

        if( c == 'i' )
            mKeyInfo = !mKeyInfo;

        if (c==oglCTRL('s'))
                        mSphereRotDx = mSphereRotDy = mSphereRotDz = 0.0f;

                if( c == oglESC ) { // Reset: Set rotation and rotation speed to zero
                        mSphereRotDx = mSphereRotDy = mSphereRotDz = 0.0f;
                        mSphereRotX = mSphereRotY = mSphereRotZ = 0.0f;
                }

        if( c == oglFUNC(9) )
            c = oglFUNC(0);
        if( c >= oglFUNC(0) && c <= oglFUNC(8) ) // Change all viewer object3D shape
            view3DSys.Object3DTagged( mOglWnd, visibleTag, 1, c - oglFUNC(0) );

        // CTRL x,y,z adds rotation speed over X,Y,Z axis

                if( c == oglCTRL('x') && (mSphereRotDx += add) ) oglSys.SetAlwaysDraw( mOglWnd, 1 );
                if( c == oglCTRL('y') && (mSphereRotDy += add) ) oglSys.SetAlwaysDraw( mOglWnd, 1 );
                if( c == oglCTRL('z') && (mSphereRotDz += add) ) oglSys.SetAlwaysDraw( mOglWnd, 1 );

                if( c == '#' ) // Pauze/continue
            oglSys.SetAlwaysDraw( mOglWnd, !oglSys.GetAlwaysDraw(mOglWnd) );

                if( c == 'e' || c == 'E' ) // Extrusion of ring
                        mStdStickOut += (c == 'E') ? 0.05f : -0.05f;
                if( c == '9' ) // Rotate 90 deg over Z axis
                        mSphereRotZ += 90;
                if( c == 'f' ) // Fill / hide central view
                        mShowCentralView = !mShowCentralView;

                if( c == 'F' && !(mAdjustViewDims = !mAdjustViewDims) ) // Toggle Fixed/adjusted viewed dimensions
            view3DSys.SizeTagged( mOglWnd, SPHERE_TAG, 1, 1.96f, 1.4f, 1.f, 0 );

                if( c == 't' ) // Show/Hide
                        mShowText = !mShowText;
                if( c == 'v' ) // Vertical/horizontal ring when not double ring
                        mStdVertRing = !mStdVertRing;
                if( c == '=' ) // Toggle between double ring and single ring
                        mDblRing = !mDblRing;

        // Auto rotate ring(s)
                if( c == 'a' && (mAutoRotateRing = !mAutoRotateRing) )
                        oglSys.SetAlwaysDraw( mOglWnd, 1 );

        // Animate viewers swirling in
                if( c == 'A' && !mAnimCnt )
                        InitAnimation();
        if( c == oglCTRL('a') ){
            mAnimSteps += (state & oglShift) ? 50 : -50;
            if( mAnimSteps < 100 ) mAnimSteps = 100;
        }

                oglSys.UpdateSceneFlag( mOglWnd, 1 );
        }


        void
        DoViewTransRot( OGLVIEW3D *view )
        {
                glTranslatef( view->x, view->y, view->z ); // Move to the viewers position

                // Perform axis rotations according to the view's rotation values
                glRotatef( view->xRot, 1.0f, 0.0f, 0.0f );
                glRotatef( view->yRot, 0.0f, 1.0f, 0.0f );
                glRotatef( view->zRot, 0.0f, 0.0f, 1.0f );
        }

    void
    HandleAnimation()
    {
                LIST            *obj;
                OGLVIEW3D       *view;
        int         cnt = 0;

        if( mAnimCnt && (mAnimCnt-- >= 0) ){
            ForAllElements( obj, mOglWnd->objectList ){
                view = (OGLVIEW3D *) obj->info;
                view->x += (cnt*0.1f) / mAnimSteps;
                view->y += (cnt*0.1f) / mAnimSteps;
                view->zRot += (720.0f / mAnimSteps);
                view->xRot += (720.0f / mAnimSteps);
                view->yRot += (720.0f / mAnimSteps);
                cnt++;
            }
        }
    }

        virtual void
        DisplayFunc()
        {
        SCENE3D     *scene3D;
                LIST            *obj;
                OGLVIEW3D       *view;
        OGC         myOGC;
                int                     i, j;
                float           angle, rad, stickOut;
                float           hW, hH;

        if( (scene3D = (SCENE3D *) mOglWnd->sceneInfo) ){
            if (scene3D->isLighting)
                glEnable(GL_LIGHTING);
        }

        OGCSave( &myOGC );
        HandleAnimation();

                view3DSys.View3DCameraTransform( mOglWnd );

                glTranslatef( mSphereX, mSphereY, mSphereZ );
                glRotatef( mSphereRotX, 1.0f, 0.0f, 0.0f );     // Rotate X
                glRotatef( mSphereRotY, 0.0f, 1.0f, 0.0f );     // Rotate Y
                glRotatef( mSphereRotZ, 0.0f, 0.0f, 1.0f );     // Rotate Z
                obj = mOglWnd->objectList;
                for( i=0; i<NCOL; i++)
                {
                        glPushMatrix();
                        glRotatef( i * 180/NCOL, 0.0f, 1.0f, 0.0f );

                        for( j=0; j<NROW; j++)
                        {
                                angle = stickOut = 0.f;
                                view = (OGLVIEW3D *) obj->info;

                                // Prevent all overlapping at poles
                                if( (i%NCOL) && (j==NROW/4 || j==3*NROW/4) ){
                                        obj = obj->next;
                                        continue;
                                }

                                glPushMatrix();

                                if( (mDblRing || mStdVertRing) && i==mVertRingNr )
                                {
                                        glRotatef( mRotRingAngle, 1.0f, 0.0f, 0.0f );
                                        stickOut = mStdStickOut + (mDblRing ? 0.2f : 0.0f );
                                        angle += mRotRingAngle;
                                }
                                else if( (mDblRing || !mStdVertRing) && (j==mHorRingNr ||
                    (j == ((mHorRingNr<=NROW/2) ? NROW/2-mHorRingNr : NROW + (NROW/2-mHorRingNr))) ) )
                                {
                                                glRotatef( mRotRingAngle, 0.0f, 1.0f, 0.0f );
                                                stickOut = mStdStickOut;
                                }

                                // Rotate view into place
                                rad = mRadius + stickOut;
                                angle += (j*360/NROW);
                                glRotatef( j * 360/NROW, 1.0f, 0.0f, 0.0f );
                                glTranslatef( 0.0f, 0.0f, -rad);

                                hH = (OGL_PI * rad) / NROW;
                                hW = (OGL_PI * (rad*MyFabs(cos(DEG2RAD(angle))))) / (2 * NCOL);
                if( mAdjustViewDims )
                                view3DSys.SetDimensions(view, FRETAIN, FRETAIN, FRETAIN, 2*hW, 2*hH, FRETAIN);

                                view3DSys.DrawView( (OGLVIEW3D *) obj->info );

                                DoViewTransRot( view );

                                // If object3D == 0, no image is drawn. So we draw our own
                                if( !view->object3D )
                                {
                                        float   hW0, hW1;
                                        hW0 = (float) (OGL_PI_05 * rad*MyFabs(cos(DEG2RAD(angle - 90.0/NCOL )))) / NCOL;
                                        hW1 = (float) (OGL_PI_05 * rad*MyFabs(cos(DEG2RAD(angle + 90.0/NCOL )))) / NCOL;
                                        glColor3f( 1.0f, 1.0f, 1.0f );
                                        glEnable( GL_TEXTURE_2D );
#ifndef OGL_USING_GLUT
                                        glNormal3f( 0.f, 0.f, 1.f );
#else
                    glNormal3f( 0.f, 0.f, -1.f );
#endif
                                        glBegin( GL_QUADS );
                                        glTexCoord2f(0.f, 1.f); glVertex3f( hW1, hH, -0.01f );
                                        glTexCoord2f(1.f, 1.f); glVertex3f( -hW1, hH, -0.01f );
                                        glTexCoord2f(1.f, 0.f); glVertex3f( -hW0, -hH, -0.01f );
                                        glTexCoord2f(0.f, 0.f); glVertex3f( hW0, -hH, -0.01f );

                                        glEnd();
                    glDisable( GL_TEXTURE_2D );
                                }

                                // Show in 3D text the indices. Trial for later use with 3D text menus
                                // on a sphere
                                if( mShowText ){
                                        char buf[100];
                                        sprintf( buf, "%d,%d", i, j );
                                        glPushMatrix();
                                        glRotatef( 180.0f, 1.0f, 0.0f, 0.0f );
                                        glColor3f( 1.0f, 1.0f, 0.0f );
                    float oldLineWidth = GetLineWidth();
                    SetLineWidth(2.0f);
                                        oglSys.Printf3D( txtFontBase, -0.25f, 0.0f, 0.1f, 0.4f, 0.4f, 0.2f, buf );
                    SetLineWidth(oldLineWidth);
                                        glPopMatrix();
                                }
                                obj = obj->next;
                                glPopMatrix();
                        }
                        glPopMatrix();
                }
        glLoadName(0);

                if( mShowCentralView )
                {
                        view3DSys.View3DCameraTransform( mOglWnd );                             
                        view3DSys.DrawView( centralView );
                }

                // If rotation is not halted, advance rotation angles
                if( mSphereRotating ){
                        // Change the orientation variables
                        mSphereRotX += mSphereRotDx;
                        mSphereRotY += mSphereRotDy;
                        mSphereRotZ += mSphereRotDz;
                }
                if ( mAutoRotateRing )
                        mRotRingAngle += mRotRingDelta;

        {
            SCENE3D *scene3D = (SCENE3D *) mOglWnd->sceneInfo;
                if( scene3D->showKeys ){
                        oglSys.InfoBoxCenter( mOglWnd, view3DKeyInfoBox );
                        oglSys.InfoBoxDraw( mOglWnd, view3DKeyInfoBox );
                }
        }

            if( !mOglWnd->hitDetecting && mKeyInfo ){
                    oglSys.InfoBoxCenter( mOglWnd, sphereInfoBox );
                    oglSys.InfoBoxDraw( mOglWnd, sphereInfoBox );
            }
        OGCRestore( &myOGC );
        glDisable(GL_LIGHTING);
        }

        virtual void
        MouseFunc( int msg, int but, int state, int x, int y )
        {
                if( msg == oglMouseWheelUp || msg == oglMouseWheelDown )
                {
                        mRotRingAngle += (msg == oglMouseWheelUp) ? 3 : -3;
                }
                else
                        Window::MouseFunc( msg, but, state, x, y );
        }

private:
        float           mSphereX, mSphereY, mSphereZ;   // Sphere center X,Y,Z
        float           mSphereRotX, mSphereRotY, mSphereRotZ;  // Sphere center rotation angles (deg)
        float           mSphereRotDx, mSphereRotDy, mSphereRotDz;// Sphere center rotation deltas X,Y,Z 
    float       mRotRingDelta;
        bool            mSphereRotating;                                        // Rotating or not (toggled by s [start/stop])
        bool            mShowText;                                                      // Show/hide text on viewer
        bool            mAdjustViewDims;                                        // When set, dims of view smaller at poles
    int         mAnimSteps;
    int         mAnimCnt;

        float           mRadius;                                                        // Radius of sphere
        float           mStdStickOut;                                           // Default stickout value

        float           mRotRingAngle;                                                  // Active ring rotation angle (deg)
        int                     mVertRingNr;                                        // Vertical active ring nr
        int                     mHorRingNr;                                                     // Horizontal active ring nr
        int                     txtFontBase;                                            // 3D font baes
        bool            mStdVertRing;                                           // Use standard vertical ring (false:hor)
        bool            mDblRing;                                                       // Use both vertical and hor rings
        bool            mAutoRotateRing;                                                // Automatic rotation of rings

        OGLIMAGE        *oglIm[7];                                                      // Mockup images to fill sphere with
        OGLVIEW3D       *centralView;                                           // Test-purpose central colored sphere
        bool            mShowCentralView;                                       // Show/hide central sphere
    bool        mKeyInfo;

    INFOBOX     *sphereInfoBox; // InfoBox for user instruction

        void Init()
        {
        for (int i=0 ; i<7; i++)
            oglIm[i] = 0;

        // When set view dimensions are adjusted to be smaller at the poles
        // NOTE: If set, no individual viewer sizes can be set
                mAdjustViewDims = true;

                mSphereX = mSphereY = 0;
                mSphereZ=-20;
                mSphereRotY = mSphereRotX = mSphereRotZ = 0;
                mSphereRotDx = mSphereRotDy= mSphereRotDz = 0;
        mRotRingDelta = 0.5f;
                mSphereRotating = true;
        // Next line would start with rotation around Y-axis
                // mSphereRotDy = 1.0f;

                mShowCentralView = false;
                mRadius = 6.0f;
                mStdStickOut = 0.2f;
                mRotRingAngle = 0.0f;
                mVertRingNr = 0;
                mHorRingNr = 0;
                mStdVertRing = true;
                mDblRing = false;
                mKeyInfo = false;
                mShowText = true;
        mAnimSteps = 200;
        mAnimCnt = mAnimSteps;
                mAutoRotateRing = true;
        }
};

} // namespace OglGui
#endif

---