windows-xp/Source/XPSP1/NT/multimedia/opengl/test/misc/uidemo/logobj.cxx

/**************************************************************************\
*
* Module Name: logon.cxx
*
* Copyright (c) 1997 Microsoft Corporation
*
\**************************************************************************/

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>

#include "logon.hxx"
#include "logobj.hxx"
#include "util.hxx"

static GLIRECT nullRect = {0};

/**************************************************************************\
* LOG_OBJECT
*
*
\**************************************************************************/

//#define DEEP_FRAME 1

LOG_OBJECT::LOG_OBJECT()
{
    pTex = NULL;

    // Set some default size values...

    fImageSize.width = fImageSize.height = OBJECT_WIDTH;
    bShowContext = FALSE; // Only show image to start
    fCurContextWidth = 0.0f;
    fMaxContextWidth = OBJECT_WIDTH / 2.0f;

#if DEEP_FRAME
    fFrameSize.width = fFrameSize.height = FRAME_SIZE;
#else
    fFrameSize.width = fFrameSize.height = 0.0f;
#endif
    bFramed = FALSE;
    // fFrameDepth is depth offset in z-direction.  Since the frame is usually
    // drawn further away from the viewer (down -z axis), it is negative.
#if DEEP_FRAME
    fFrameDepth = - 3.3f;
#else
    fFrameDepth = - FRAME_DEPTH;
#endif
    bSwapHints = FALSE;
    dest[0] = dest[1] = dest[2] = 0.0f;
    ResetMotion();

    rect = nullRect;

    // Calc initial coords

    CalcCoords();
}

LOG_OBJECT::~LOG_OBJECT()
{
}

void    
LOG_OBJECT::ShowFrame( BOOL bShow )
{
    if( bFramed == bShow )
        return;

    // new state
    bFramed = bShow;
    if( bFramed ) {
        // mf : could optimize by not redoing this if framesize constant...
        CalcFrameCoords();
    }
}

void    
LOG_OBJECT::ShowContext( BOOL bShow )
{
    if( bShowContext == bShow )
        return;

    // new state
    bShowContext = bShow;
    CalcCoords();
//mf: !!! readjust dest to reflect this ?
}

void    
LOG_OBJECT::SetDest( float x, float y, float z )
{
    dest[0] = x;
    dest[1] = y;
    dest[2] = z;
}

void    
LOG_OBJECT::SetDest( POINT3D *pDest )
{
    dest[0] = pDest->x;
    dest[1] = pDest->y;
    dest[2] = pDest->z;
}

void    
LOG_OBJECT::GetDest( POINT3D *pDest )
{
    pDest->x = dest[0];
    pDest->y = dest[1];
    pDest->z = dest[2];
}

void
LOG_OBJECT::OffsetDest( float x, float y, float z )
{
    dest[0] += x;
    dest[1] += y;
    dest[2] += z;
}

void    
LOG_OBJECT::SetTexture( TEXTURE *pTexture )
{
    pTex = pTexture;
    if( !pTex )
        return;

    // Set the size of the object based on the aspect ratio of the texture
    // The textures for all the objects should have the same dimensions.

    float aspectRatio = pTex->GetAspectRatio();  // width/height

    // The texture is assumed to have an image on the right, and context on
    // the left, of equal size

    // We'll keep the width consant, and vary height according to aspect

    fImageSize.width = OBJECT_WIDTH / 2.0f;
    fImageSize.height = OBJECT_WIDTH / aspectRatio;
    
    fMaxContextWidth = fImageSize.width;
    fCurContextWidth = fMaxContextWidth;

    CalcCoords();
}

void    
LOG_OBJECT::SetContextSize( float fPortion )
{
    // This sets the visible portion of the context ( 0.0 - 1.0 )

    fCurContextWidth = fPortion * fMaxContextWidth;

    // Recalc coords
    CalcCoords();
}

void    
LOG_OBJECT::SetImageSize( FSIZE *pSize )
{
    fImageSize = *pSize;
    float fPortion = fCurContextWidth / fMaxContextWidth;
    fMaxContextWidth = fImageSize.width;
    fCurContextWidth = fPortion * fMaxContextWidth;
    CalcCoords();
}

void    
LOG_OBJECT::Translate()
{
    glTranslatef(dest[0]+offset[0], dest[1]+offset[1], dest[2]+offset[2]);
}

void    
LOG_OBJECT::Rotate()
{
    if( ang != 0.0f )
    	glRotatef(ang, rotAxis[0], rotAxis[1], rotAxis[2]);
}

void    
LOG_OBJECT::Draw()
{
    Draw( FALSE );
}

void    
LOG_OBJECT::Draw( BOOL bUpdateWinRect )
{
    // Draws object in its current position

    // An object either has its context showing on the right or not.  If not,
    // then origin is the centre of the image, else origin is on border of
    // image and context

    pTex->MakeCurrent(); // Set the objects texture
    glPushMatrix();
        Translate();
        Rotate();
        if( bUpdateWinRect ) {
            UpdateLocalTransforms( UPDATE_MODELVIEW_MATRIX_BIT );
            CalcWinRect( FALSE );
        }
        DrawFace(); 
        if( bFramed )
            DrawFrame();
    glPopMatrix();
    if( bSwapHints )
        AddSwapHintRect( &rect );
}

void
LOG_OBJECT::DrawFace()
{
    glNormal3f( 0.0f, 0.0f, 1.0f );
    glBegin( GL_QUADS );
        glTexCoord2fv( (float *) &texPoint[0] );
        glVertex2fv(   (float *) &point[0] );
        glTexCoord2fv( (float *) &texPoint[1] );
        glVertex2fv(   (float *) &point[1] );
        glTexCoord2fv( (float *) &texPoint[2] );
        glVertex2fv(   (float *) &point[2] );
        glTexCoord2fv( (float *) &texPoint[3] );
        glVertex2fv(   (float *) &point[3] );
    glEnd();
}

void
LOG_OBJECT::DrawFrame()
{
    glDisable( GL_TEXTURE_2D );
    glEnable( GL_LIGHTING );

    glBegin( GL_QUADS );

        glNormal3fv( (float *) &frameNormal[0] );
        glVertex3fv( (float *) &point[0] );
        glVertex3fv( (float *) &point[4] );
        glVertex3fv( (float *) &point[7] );
        glVertex3fv( (float *) &point[3] );

        glNormal3fv( (float *) &frameNormal[1] );
        glVertex3fv( (float *) &point[1] );
        glVertex3fv( (float *) &point[5] );
        glVertex3fv( (float *) &point[4] );
        glVertex3fv( (float *) &point[0] );

        glNormal3fv( (float *) &frameNormal[2] );
        glVertex3fv( (float *) &point[2] );
        glVertex3fv( (float *) &point[6] );
        glVertex3fv( (float *) &point[5] );
        glVertex3fv( (float *) &point[1] );

        glNormal3fv( (float *) &frameNormal[3] );
        glVertex3fv( (float *) &point[3] );
        glVertex3fv( (float *) &point[7] );
        glVertex3fv( (float *) &point[6] );
        glVertex3fv( (float *) &point[2] );

    glEnd();

    glDisable( GL_LIGHTING );
    glEnable( GL_TEXTURE_2D );
}

void    
LOG_OBJECT::CalcWinRect()
{
    CalcWinRect( TRUE );
}

void    
LOG_OBJECT::CalcWinRect( BOOL bTransform )
{
    POINT3D ptOut[8];
    int nPts = bFramed ? 8 : 4;

    if( bTransform ) {
        // Need to transorm object according to current translation & rotation
        glPushMatrix();
            Translate();
            Rotate();
            UpdateLocalTransforms( UPDATE_MODELVIEW_MATRIX_BIT );
        glPopMatrix();
    }

    TransformObjectToWindow( point, ptOut, nPts );

    // Update the rect member
    CalcMinMaxRect( ptOut, &rect, nPts );
}

void    
LOG_OBJECT::CalcCoords()
{
    POINT3D *pt;

    // Calculate object coords based on current state of the object.  If
    // bShowContext, then origin is in centre of object, else it's in centre
    // of image part of object.
    // Also calculate frame coords if applicable.

    // Points are ordered CCW from top right for each face

    pt = point;
    pt[0].z = pt[1].z = pt[2].z = pt[3].z = 0.0f;

    // Calc front face points

    if( ! bShowContext ) {
        POINT2D image =  { fImageSize.width / 2.0f, fImageSize.height / 2.0f };

        pt[0].x =  image.x;
        pt[0].y =  image.y;
        pt[1].x = -image.x;
        pt[1].y =  image.y;
        pt[2].x = -image.x;
        pt[2].y = -image.y;
        pt[3].x =  image.x;
        pt[3].y = -image.y;
    } else {
        POINT2D image =  { fImageSize.width, fImageSize.height / 2.0f };

        pt[0].x =  image.x;
        pt[0].y =  image.y;
        pt[1].x = -fCurContextWidth;
        pt[1].y =  image.y;
        pt[2].x = -fCurContextWidth;
        pt[2].y = -image.y;
        pt[3].x =  image.x;
        pt[3].y = -image.y;
    }

    // Calc frame points

    if( bFramed ) {
        CalcFrameCoords();
    }

    // Always need the texture coords
//mf: optimize...
    CalcTexCoords();
}

void    
LOG_OBJECT::CalcFrameCoords()
{
    POINT3D *frontPt = point;
    POINT3D *pt = point + 4;

    pt[0].z = pt[1].z = pt[2].z = pt[3].z = fFrameDepth;

    pt[0].x =  frontPt[0].x + fFrameSize.width;
    pt[0].y =  frontPt[0].y + fFrameSize.height;
    pt[1].x =  frontPt[1].x - fFrameSize.width;
    pt[1].y =  frontPt[1].y + fFrameSize.height;
    pt[2].x =  frontPt[2].x - fFrameSize.width;
    pt[2].y =  frontPt[2].y - fFrameSize.height;
    pt[3].x =  frontPt[3].x + fFrameSize.width;
    pt[3].y =  frontPt[3].y - fFrameSize.height;

    // May as well do the normals too
    CalcFrameNormals();
}

void    
LOG_OBJECT::CalcFrameNormals()
{
    POINT3D *pNorm = frameNormal;

    float fDepth = fFrameDepth;
    float fFramex = fFrameSize.width;
    float fFramey = fFrameSize.height;

    // Calc the face normals for the sides of the frame.  The faces are
    // ordered CCW from the right face.

    float norm1 = (float) fabs( fDepth );

    pNorm[0].x = norm1;
    pNorm[0].y = 0.0f;
    pNorm[0].x = fFramex;

    pNorm[1].x = 0.0f;
    pNorm[1].y = norm1;
    pNorm[1].x = fFramey;

    pNorm[0].x = -norm1;
    pNorm[0].y = 0.0f;
    pNorm[0].x = fFramex;

    pNorm[1].x = 0.0f;
    pNorm[1].y = -norm1;
    pNorm[1].x = fFramey;

    mtk_NormalizePoints( pNorm, 4 );
}

void    
LOG_OBJECT::CalcTexCoords()
{
    // Calculate texture coords based on current state of the object.

    // The texture spans across the front face, and includes the image on right,
    // and context on left.  The 't' coords are constant, but the 's' coord
    // varies, depending on if or how much context is shown.

    // Again, points are ordered CCW from top right for each face

    // Calc ratio of image over total width of object
    float ratio = fImageSize.width / (fImageSize.width + fMaxContextWidth);

    float sStart = 1.0f - ratio;

    if( bShowContext ) {
        sStart -= (fCurContextWidth / fMaxContextWidth) * (1.0f - ratio);
    }

    texPoint[0].s = texPoint[3].s = 1.0f;
    texPoint[1].s = texPoint[2].s = sStart;

    texPoint[0].t = texPoint[1].t = 1.0f;
    texPoint[2].t = texPoint[3].t = 0.0f;
}

void    
LOG_OBJECT::GetRect( GLIRECT *pRect )
{
    *pRect = rect;
}

#if 0
void    
LOG_OBJECT::GetPos( POINT3D *curpos )
{
    float *fpos = (float *) curpos;

    for( int i = 0; i < 3; i ++ )
        fpos[i] = dest[i] + offset[i];
}
#endif

/**************************************************************************\
* NextFlyIteration
*
* Calcs next offset and angle for a 'fly'sequence
*
\**************************************************************************/

BOOL
LOG_OBJECT::NextFlyIteration()
{
    int i;

	if( !iter ) {
        // Done iterating
        return FALSE;
    }

    // Calculate new iterations
    for (i = 0; i < 3; i++) {
        offset[i] = Clamp( iter,  offset[i] );
    }
	ang = Clamp( iter,  ang);
	iter--;

    return TRUE;
}

/**************************************************************************\
* ResetMotion
*
* Resets all position and motion params to 0
*
\**************************************************************************/

void
LOG_OBJECT::ResetMotion()
{
    offset[0] = offset[1] = offset[2] = 0.0f;
    rotAxis[0] = rotAxis[1] = rotAxis[2] = 0.0f;
    ang = 0.0f;
    iter = 0;
}

/**************************************************************************\
*
* Ranomnly chooses motion params for a fly sequence
*
* The motion is 'damped', since near the end of the fly sequence the object
* is constrained to 0 rotation and the dest[] position
*
\**************************************************************************/


void
LOG_OBJECT::SetDampedFlyMotion( float deviation )
{
    SetDampedFlyMotion( deviation, NULL );
}

void
LOG_OBJECT::SetDampedFlyMotion( float deviation, POINT3D *pOffset )
{
    if( pOffset ) {
        // Use supplied offset
        offset[0] = pOffset->x;
       	offset[1] = pOffset->y;
       	offset[2] = pOffset->z;
    } else {
        // Calc a random offset
        offset[0] = MyRand();
       	offset[1] = MyRand();
       	offset[2] = MyRand();
    }

	ang = 260.0f * MyRand();

   	rotAxis[0] = MyRand();
   	rotAxis[1] = MyRand();
	rotAxis[2] = MyRand();
   	iter = (int) (deviation * MyRand() + 60.0f);
}