windows-xp/Source/XPSP1/NT/shell/osshell/control/scrnsave/flowerbox/flowerbox.cpp

//-----------------------------------------------------------------------------
// File: FlowerBox.cpp
//
// Desc: Fun screen saver
//       Original OpenGL version by Drew Bliss
//       Ported to Direct3D 8.0 by Mike Anderson
//
// Copyright (c) 2000-2001 Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
#include <windows.h>
#include <tchar.h>
#include <d3d8.h>
#include <d3dx8.h>
#include <d3d8rgbrast.h>
#include <stdio.h>
#include <commctrl.h>
#include <scrnsave.h>
#include "d3dsaver.h"
#include "FlowerBox.h"
#include "Resource.h"
#include "dxutil.h"

#ifndef GL_FRONT
#define GL_FRONT                          0x0404
#endif

#ifndef GL_FRONT_AND_BACK
#define GL_FRONT_AND_BACK                 0x0408
#endif


// Minimum and maximum image sizes
#define MINIMAGESIZE 10
#define MAXIMAGESIZE 100

// Color tables for checkboard, per-side and single color modes
FLOAT base_checker_cols[MAXSIDES][NCCOLS][4] =
{
    1.0f, 0.0f, 0.0f, 1.0f,
    0.0f, 1.0f, 0.0f, 1.0f,
    0.0f, 1.0f, 0.0f, 1.0f,
    0.0f, 0.0f, 1.0f, 1.0f,
    0.0f, 0.0f, 1.0f, 1.0f,
    1.0f, 0.0f, 1.0f, 1.0f,
    1.0f, 0.0f, 1.0f, 1.0f,
    0.0f, 1.0f, 1.0f, 1.0f,
    0.0f, 1.0f, 1.0f, 1.0f,
    1.0f, 1.0f, 0.0f, 1.0f,
    1.0f, 1.0f, 0.0f, 1.0f,
    0.5f, 0.5f, 1.0f, 1.0f,
    0.5f, 0.5f, 1.0f, 1.0f,
    1.0f, 0.5f, 0.5f, 1.0f,
    1.0f, 0.5f, 0.5f, 1.0f,
    1.0f, 0.0f, 0.0f, 1.0f
};
FLOAT checker_cols[MAXSIDES][NCCOLS][4];

FLOAT base_side_cols[MAXSIDES][4] =
{
    1.0f, 0.0f, 0.0f, 1.0f,
    0.0f, 1.0f, 0.0f, 1.0f,
    0.0f, 0.0f, 1.0f, 1.0f,
    1.0f, 0.0f, 1.0f, 1.0f,
    0.0f, 1.0f, 1.0f, 1.0f,
    1.0f, 1.0f, 0.0f, 1.0f,
    0.5f, 0.5f, 1.0f, 1.0f,
    1.0f, 0.5f, 0.5f, 1.0f
};
FLOAT side_cols[MAXSIDES][4];

FLOAT base_solid_cols[4] =
{
    1.0f, 1.0f, 1.0f, 1.0f
};
FLOAT solid_cols[4];


// Default configuration
CONFIG config =
{
    TRUE, FALSE, FALSE, TRUE, TRUE, MAXSUBDIV, ID_COL_PER_SIDE,
    (MAXIMAGESIZE+MINIMAGESIZE)/2, GEOM_CUBE, GL_FRONT
};

// A slider range
typedef struct _RANGE
{
    INT min_val;
    INT max_val;
    INT step;
    INT page_step;
} RANGE;

RANGE complexity_range = {MINSUBDIV, MAXSUBDIV, 1, 2};
RANGE image_size_range = {MINIMAGESIZE, MAXIMAGESIZE, 1, 10};

// Values to map a 2D point onto a 3D plane
// Base point and axes to map X and Y coordinates onto
struct PLANE_MAP
{
    D3DXVECTOR3 base, x_axis, y_axis;
    PLANE_MAP(D3DXVECTOR3 tbase, D3DXVECTOR3 tx_axis, D3DXVECTOR3 ty_axis)
        { base = tbase; x_axis = tx_axis; y_axis = ty_axis; }
    PLANE_MAP(VOID) {};
};

// Data area used by the current geometry
// Base points and generated points
D3DXVECTOR3 pts[MAXPTS], npts[MAXPTS];
MYVERTEX vertices[MAXPTS];

// Scaling factor for spherical projection
FLOAT vlen[MAXPTS];
// Normals
D3DXVECTOR3 normals[MAXPTS];
// Vertex data indices
WORD index[MAXPTS*2];
// Triangle strip sizes
INT strip_size[MAXSIDES*MAXSUBDIV];

VOID InitCube(GEOMETRY *geom);
VOID InitTetra(GEOMETRY *geom);
VOID InitPyramids(GEOMETRY *geom);
VOID InitCylinder(GEOMETRY *geom);
VOID InitSpring(GEOMETRY *geom);

GEOMETRY cube_geom = {InitCube};
GEOMETRY tetra_geom = {InitTetra};
GEOMETRY pyramids_geom = {InitPyramids};
GEOMETRY cylinder_geom = {InitCylinder};
GEOMETRY spring_geom = {InitSpring};

GEOMETRY *geom_table[] =
{
    &cube_geom,
    &tetra_geom,
    &pyramids_geom,
    &cylinder_geom,
    &spring_geom
};


#define BUF_SIZE 255
TCHAR g_szSectName[BUF_SIZE];
TCHAR g_szFname[BUF_SIZE];

CFlowerBoxScreensaver* g_pMyFlowerBoxScreensaver = NULL;




//-----------------------------------------------------------------------------
// Name: WinMain()
// Desc: Entry point to the program. Initializes everything, and goes into a
//       message-processing loop. Idle time is used to render the scene.
//-----------------------------------------------------------------------------
INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR, INT )
{
    HRESULT hr;
    CFlowerBoxScreensaver flowerboxSS;

    if( FAILED( hr = flowerboxSS.Create( hInst ) ) )
    {
        flowerboxSS.DisplayErrorMsg( hr );
        return 0;
    }

    return flowerboxSS.Run();
}




//-----------------------------------------------------------------------------
// Name: CFlowerBoxScreensaver()
// Desc: Constructor
//-----------------------------------------------------------------------------
CFlowerBoxScreensaver::CFlowerBoxScreensaver( )
{
    g_pMyFlowerBoxScreensaver = this;

    LoadString( NULL, IDS_DESCRIPTION, m_strWindowTitle, 200 );
    m_bUseDepthBuffer = TRUE;

    lstrcpy( m_strRegPath, TEXT("Software\\Microsoft\\Screensavers\\Flowerbox") );

    m_xr = 0;
    m_yr = 0;
    m_zr = 0;

    m_sf = 0;
    m_sfi = 0;

    m_phase = 0.0f;

    m_pGeomCur = NULL;

    m_floatrect.xSize = 0.0f;
    InitCommonControls();
}


//-----------------------------------------------------------------------------
// Name: RegisterSoftwareDevice()
// Desc: This can register the D3D8RGBRasterizer or any other
//       pluggable software rasterizer.
//-----------------------------------------------------------------------------
HRESULT CFlowerBoxScreensaver::RegisterSoftwareDevice()
{ 
    m_pD3D->RegisterSoftwareDevice( D3D8RGBRasterizer );

    return S_OK; 
}


//-----------------------------------------------------------------------------
// Name: FrameMove()
// Desc: Called once per frame, the call is the entry point for animating
//       the scene.
//-----------------------------------------------------------------------------
HRESULT CFlowerBoxScreensaver::FrameMove()
{
    // update floatrect
    RECT rcBounceBounds;

    if( m_floatrect.xSize == 0.0f )
    {
        // Initialize floatrect
        RECT rcBounds;
        DWORD dwParentWidth;
        DWORD dwParentHeight;

        rcBounds = m_rcRenderTotal;

        dwParentWidth = rcBounds.right - rcBounds.left;
        dwParentHeight = rcBounds.bottom - rcBounds.top;

        FLOAT sizeFact;
        FLOAT sizeScale;
        DWORD size;

        sizeScale = (FLOAT)config.image_size / 150.0f;

    //    sizeFact = 0.25f + (0.5f * sizeScale);     // range 25-75%
    //    size = (DWORD) (sizeFact * ( ((FLOAT)(dwParentWidth + dwParentHeight)) / 2.0f ));

        sizeFact = 0.25f + (0.75f * sizeScale);     // range 25-100%
        size = (DWORD) (sizeFact * ( dwParentWidth > dwParentHeight ? dwParentHeight : dwParentWidth ) );

        if( size > dwParentWidth )
            size = dwParentWidth;
        if( size > dwParentHeight )
            size = dwParentHeight;

        // Start floatrect centered on primary
        m_floatrect.xMin = rcBounds.left + (dwParentWidth - size) / 2.0f;
        m_floatrect.yMin = rcBounds.top + (dwParentHeight - size) / 2.0f;
        m_floatrect.xSize = (FLOAT)size;
        m_floatrect.ySize = (FLOAT)size;

        m_floatrect.xVel = 0.01f * (FLOAT) size;
        m_floatrect.yVel = 0.01f * (FLOAT) size;
    }

    rcBounceBounds = m_rcRenderTotal;

    FLOAT xMinOld = m_floatrect.xMin;
    FLOAT yMinOld = m_floatrect.yMin;

    m_floatrect.xMin += m_floatrect.xVel * 20.0f * m_fElapsedTime;
    m_floatrect.yMin += m_floatrect.yVel * 20.0f * m_fElapsedTime;
    if( m_floatrect.xVel < 0 && m_floatrect.xMin < rcBounceBounds.left || 
        m_floatrect.xVel > 0 && (m_floatrect.xMin + m_floatrect.xSize) > rcBounceBounds.right )
    {
        m_floatrect.xMin = xMinOld; // undo last move
        m_floatrect.xVel = -m_floatrect.xVel; // change direction
    }
    if( m_floatrect.yVel < 0 && m_floatrect.yMin < rcBounceBounds.top || 
        m_floatrect.yVel > 0 && (m_floatrect.yMin + m_floatrect.ySize) > rcBounceBounds.bottom )
    {
        m_floatrect.yMin = yMinOld; // undo last move
        m_floatrect.yVel = -m_floatrect.yVel; // change direction
    }

    if (config.spin)
    {
        m_xr += 3 * 20.0f * m_fElapsedTime;
        m_yr += 2 * 20.0f * m_fElapsedTime;
    }

    if (config.bloom)
    {
        m_sf += m_sfi * 20.0f * m_fElapsedTime;
        if (m_sfi > 0.0f && m_sf > m_pGeomCur->max_sf ||
            m_sfi < 0.0f && m_sf < m_pGeomCur->min_sf )
        {
            m_sfi = -m_sfi;
        }
        UpdatePts(m_pGeomCur, m_sf);
    }

    if (config.cycle_colors)
    {
        ComputeHsvColors();
        m_phase += (FLOAT)(2.5 * 20.0f * m_fElapsedTime * D3DX_PI/180.);
    }

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: Render()
// Desc: Called once per frame, the call is the entry point for 3d
//       rendering. This function sets up render states, clears the
//       viewport, and renders the scene.
//-----------------------------------------------------------------------------
HRESULT CFlowerBoxScreensaver::Render()
{
    D3DVIEWPORT8 vp;

    // First, clear the entire back buffer to the background color
    vp.X = 0;
    vp.Y = 0;
    vp.Width = m_rcRenderCurDevice.right - m_rcRenderCurDevice.left;
    vp.Height = m_rcRenderCurDevice.bottom - m_rcRenderCurDevice.top;
    vp.MinZ = 0.0f;
    vp.MaxZ = 1.0f;
    m_pd3dDevice->SetViewport( &vp );
    m_pd3dDevice->Clear( 0L, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xff000000, 1.0f, 0L );

    // Now determine what part of the floatrect, if any, intersects the current screen
    RECT rcFloatThisScreen;
    RECT rcFloatThisScreenClipped;

    rcFloatThisScreen.left = (INT)m_floatrect.xMin;
    rcFloatThisScreen.top = (INT)m_floatrect.yMin;
    rcFloatThisScreen.right = rcFloatThisScreen.left + (INT)m_floatrect.xSize;
    rcFloatThisScreen.bottom = rcFloatThisScreen.top + (INT)m_floatrect.ySize;

    if( !IntersectRect(&rcFloatThisScreenClipped, &rcFloatThisScreen, &m_rcRenderCurDevice) )
    {
        return S_OK; // no intersection, so nothing further to render on this screen
    }

    // Convert rcFloatThisScreen from screen to window coordinates
    OffsetRect(&rcFloatThisScreen, -m_rcRenderCurDevice.left, -m_rcRenderCurDevice.top);
    OffsetRect(&rcFloatThisScreenClipped, -m_rcRenderCurDevice.left, -m_rcRenderCurDevice.top);

    // Now set up the viewport to render to the clipped rect
    vp.X = rcFloatThisScreenClipped.left;
    vp.Y = rcFloatThisScreenClipped.top;
    vp.Width = rcFloatThisScreenClipped.right - rcFloatThisScreenClipped.left;
    vp.Height = rcFloatThisScreenClipped.bottom - rcFloatThisScreenClipped.top;
    vp.MinZ = 0.0f;
    vp.MaxZ = 1.0f;
    m_pd3dDevice->SetViewport( &vp );

    // Now set up the projection matrix to only render the onscreen part of the
    // rect to the viewport
    D3DXMATRIX matProj;
    FLOAT l,r,b,t;
    l = -0.8f;
    r =  0.8f;
    b =  0.8f;
    t = -0.8f;
    FLOAT cxUnclipped = (rcFloatThisScreen.right + rcFloatThisScreen.left) / 2.0f;
    FLOAT cyUnclipped = (rcFloatThisScreen.bottom + rcFloatThisScreen.top) / 2.0f;
    l *= (rcFloatThisScreenClipped.left - cxUnclipped) / (rcFloatThisScreen.left - cxUnclipped);
    r *= (rcFloatThisScreenClipped.right - cxUnclipped) / (rcFloatThisScreen.right - cxUnclipped);
    t *= (rcFloatThisScreenClipped.top - cyUnclipped) / (rcFloatThisScreen.top - cyUnclipped);
    b *= (rcFloatThisScreenClipped.bottom - cyUnclipped) / (rcFloatThisScreen.bottom - cyUnclipped);
    D3DXMatrixPerspectiveOffCenterLH( &matProj, l, r, b, t, 2.0f, 5.0f );
    m_pd3dDevice->SetTransform( D3DTS_PROJECTION , &matProj );

    // Begin the scene 
    if( SUCCEEDED( m_pd3dDevice->BeginScene() ) )
    {
        D3DXMATRIX mat, matx, maty, matz;
        D3DXMatrixRotationX( &matx, D3DXToRadian( (FLOAT)m_xr ) );
        D3DXMatrixRotationY( &maty, D3DXToRadian( (FLOAT)m_yr ) );
        D3DXMatrixRotationZ( &matz, D3DXToRadian( (FLOAT)m_zr ) );
        mat = matx * maty * matz;
        m_pd3dDevice->SetTransform( D3DTS_WORLD, &mat );

        DrawGeom(m_pGeomCur);

        // End the scene.
        m_pd3dDevice->EndScene();
    }

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: RestoreDeviceObjects()
// Desc: 
//-----------------------------------------------------------------------------
HRESULT CFlowerBoxScreensaver::RestoreDeviceObjects()
{
    if( m_pd3dDevice == NULL )
        return S_OK;
    
    D3DXMATRIX matView;
    D3DXVECTOR3 vUpVec( 0.0f, 1.0f, 0.0f );
    D3DXVECTOR3 vEyePt(0, 0, 3.5f);
    D3DXVECTOR3 vLookatPt(0, 0, 0);
    D3DXMatrixLookAtLH( &matView, &vEyePt, &vLookatPt, &vUpVec );
    m_pd3dDevice->SetTransform( D3DTS_VIEW , &matView );

    D3DLIGHT8 light;
    ZeroMemory( &light, sizeof(D3DLIGHT8) );
    light.Type       = D3DLIGHT_POINT;
    light.Diffuse.r  = 1.0f;
    light.Diffuse.g  = 1.0f;
    light.Diffuse.b  = 1.0f;
    light.Diffuse.a  = 1.0f;
    light.Specular.r = 1.0f;
    light.Specular.g = 1.0f;
    light.Specular.b = 1.0f;
    light.Specular.a = 1.0f;
    light.Position.x = 2.0;
    light.Position.y = 2.0;
    light.Position.z = 10.0;
    light.Range      = 1000.0f;
    light.Attenuation0 = 1.0f;
    m_pd3dDevice->SetLight(0, &light);
    m_pd3dDevice->LightEnable(0, TRUE);
    
    // Set some basic renderstates
    m_pd3dDevice->SetRenderState( D3DRS_DITHERENABLE , TRUE );
    m_pd3dDevice->SetRenderState( D3DRS_SPECULARENABLE , TRUE );
    m_pd3dDevice->SetRenderState( D3DRS_LIGHTING, TRUE );
    m_pd3dDevice->SetRenderState( D3DRS_AMBIENT, D3DCOLOR(0x40404040 ) );
    if( config.two_sided == GL_FRONT_AND_BACK )
        m_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
    else
        m_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_CW );
    
    NewConfig(&config);

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: InvalidateDeviceObjects()
// Desc: 
//-----------------------------------------------------------------------------
HRESULT CFlowerBoxScreensaver::InvalidateDeviceObjects()
{
    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: InitVlen()
// Desc: Precomputes scaling factor for spherical projection
//-----------------------------------------------------------------------------
VOID CFlowerBoxScreensaver::InitVlen(GEOMETRY *geom, INT npts, D3DXVECTOR3 *pts)
{
    const FLOAT RADIUS = 1;
    FLOAT d;
    FLOAT *vl;

    vl = vlen;
    while (npts-- > 0)
    {
        d = D3DXVec3Length(pts);

        // Don't allow really close points because this leads to
        // numeric instability and really large objects
//        assert(d > 0.01f);

        // Geometries are created with size one, filling the area
        // from -.5 to .5.  This leads to distances generally less
        // than one, which leaves off half of the interesting morphing
        // effects due to the projection
        // Scaling up the scaling factor allows the values to
        // be both above and below one
        d *= geom->init_sf;
        
//        assert(d > 0.0001f);
        
        *vl++ = (RADIUS-d)/d;

        pts++;
    }
}




//-----------------------------------------------------------------------------
// Name: MapToSide()
// Desc: Takes x,y coordinates in the range 0-1 and maps them onto the given
//       side plane for the current geometry
//-----------------------------------------------------------------------------
VOID MapToSide(PLANE_MAP *map, FLOAT x, FLOAT y, D3DXVECTOR3 *pt)
{
    pt->x = x*map->x_axis.x+y*map->y_axis.x+map->base.x;
    pt->y = x*map->x_axis.y+y*map->y_axis.y+map->base.y;
    pt->z = x*map->x_axis.z+y*map->y_axis.z+map->base.z;
}





//-----------------------------------------------------------------------------
// Name: InitCube()
// Desc: Initializes the cube's geometry
//-----------------------------------------------------------------------------
VOID InitCube(GEOMETRY *geom)
{
    const INT CUBE_SIDES = 6;
    PLANE_MAP cube_planes[CUBE_SIDES] =
    {
        PLANE_MAP(D3DXVECTOR3(-0.5f, -0.5f,  0.5f),  D3DXVECTOR3( 1.0f,  0.0f, 0.0f), D3DXVECTOR3(0.0f, 1.0f, 0.0f)),
        PLANE_MAP(D3DXVECTOR3( 0.5f, -0.5f, -0.5f),  D3DXVECTOR3(-1.0f,  0.0f, 0.0f), D3DXVECTOR3(0.0f, 1.0f, 0.0f)),
        PLANE_MAP(D3DXVECTOR3( 0.5f,  0.5f, -0.5f),  D3DXVECTOR3(-1.0f,  0.0f, 0.0f), D3DXVECTOR3(0.0f, 0.0f, 1.0f)),
        PLANE_MAP(D3DXVECTOR3(-0.5f, -0.5f, -0.5f),  D3DXVECTOR3( 1.0f,  0.0f, 0.0f), D3DXVECTOR3(0.0f, 0.0f, 1.0f)),
        PLANE_MAP(D3DXVECTOR3( 0.5f, -0.5f, -0.5f),  D3DXVECTOR3( 0.0f,  1.0f, 0.0f), D3DXVECTOR3(0.0f, 0.0f, 1.0f)),
        PLANE_MAP(D3DXVECTOR3(-0.5f,  0.5f, -0.5f),  D3DXVECTOR3( 0.0f, -1.0f, 0.0f), D3DXVECTOR3(0.0f, 0.0f, 1.0f))
    };
    INT side, x, y;
    D3DXVECTOR3 *pt;
    unsigned short/*INT*/ *idx;
    INT *sz;
    INT side_pts;

    side_pts = (config.subdiv+1)*(config.subdiv+1);
    
    geom->nsides = CUBE_SIDES;
    geom->pts = &pts[0];
    geom->npts = &npts[0];
    geom->normals = &normals[0];
    geom->pVertices = &vertices[0];

    geom->min_sf = -1.1f;
    geom->max_sf = 5.1f;
    geom->sf_inc = 0.05f;
    geom->init_sf = 2.0f;
    
    // Generate triangle strip data
    sz = &strip_size[0];
    idx = &index[0];
    for (side = 0; side < geom->nsides; side++)
    {
        geom->sides[side].nstrips = config.subdiv;
        geom->sides[side].strip_size = sz;
        geom->sides[side].strip_index = idx;
        
        for (x = 0; x < config.subdiv; x++)
        {
            *sz++ = (config.subdiv+1)*2;

            for (y = 0; y < config.subdiv+1; y++)
            {
                *idx++ = side * side_pts + x * (config.subdiv + 1) + y;
                *idx++ = side * side_pts + (x + 1) * (config.subdiv + 1) + y;
            }
        }
    }

    // Generate base vertices
    pt = geom->pts;
    for (side = 0; side < geom->nsides; side++)
    {
        for (x = 0; x < config.subdiv+1; x++)
        {
            for (y = 0; y < config.subdiv+1; y++)
            {
                MapToSide(&cube_planes[side],
                          (FLOAT)x/config.subdiv, (FLOAT)y/config.subdiv,
                          pt);
                pt++;
            }
        }
    }

    geom->total_pts = geom->nsides*side_pts;
}





//-----------------------------------------------------------------------------
// Name: InitTetra()
// Desc: Initializes the tetrahedron's geometry
//-----------------------------------------------------------------------------
VOID InitTetra(GEOMETRY *geom)
{
    const INT TETRA_SIDES = 4;
    const FLOAT SQRT3 = 1.73205f;
    const FLOAT SQRT3_2 = (SQRT3/2.0f);
    const FLOAT SQRT3_3 = (SQRT3/3.0f);
    const FLOAT SQRT3_6 = (SQRT3/6.0f);
    const FLOAT SQRT3_12 = (SQRT3/12.0f);
    const FLOAT TETRA_BASE = (-SQRT3/8.0f);
    PLANE_MAP tetra_planes[TETRA_SIDES] =
    {
        PLANE_MAP(D3DXVECTOR3(-0.5f, TETRA_BASE, SQRT3_6), D3DXVECTOR3(1.0f, 0.0f, 0.0f),      D3DXVECTOR3(0.0f, SQRT3_2, -SQRT3_6)),
        PLANE_MAP(D3DXVECTOR3(0.0f, TETRA_BASE, -SQRT3_3), D3DXVECTOR3(-0.5f, 0.0f, SQRT3_2),  D3DXVECTOR3(0.25f, SQRT3_2, SQRT3_12)),
        PLANE_MAP(D3DXVECTOR3(0.5f, TETRA_BASE, SQRT3_6),  D3DXVECTOR3(-0.5f, 0.0f, -SQRT3_2), D3DXVECTOR3(-0.25f, SQRT3_2, SQRT3_12)),
        PLANE_MAP(D3DXVECTOR3(0.5f, TETRA_BASE, SQRT3_6),  D3DXVECTOR3(-1.0f, 0.0f, 0.0f),     D3DXVECTOR3(0.0f, 0.0f, -SQRT3_2)),
    };

    INT side, x, y;
    D3DXVECTOR3 *pt;
    unsigned short/*INT*/ *idx;
    INT *sz;
    unsigned short side_pts;
    unsigned short base_pt;
    unsigned short row_pts;
    FLOAT fx;

    side_pts = (config.subdiv+2)*(config.subdiv+1)/2;
    
    geom->nsides = TETRA_SIDES;
    geom->pts = &pts[0];
    geom->npts = &npts[0];
    geom->normals = &normals[0];
    geom->pVertices = &vertices[0];

    geom->min_sf = -1.1f;
    geom->max_sf = 5.2f;
    geom->sf_inc = 0.05f;
    geom->init_sf = 3.75f;

    // Generate triangle strip data
    sz = &strip_size[0];
    idx = &index[0];
    base_pt = 0;
    for (side = 0; side < geom->nsides; side++)
    {
        geom->sides[side].nstrips = config.subdiv;
        geom->sides[side].strip_size = sz;
        geom->sides[side].strip_index = idx;

        for (x = 0; x < config.subdiv; x++)
        {
            row_pts = config.subdiv-x+1;
            *sz++ = row_pts*2-1;

            *idx++ = base_pt;
            for (y = 0; y < row_pts-1; y++)
            {
                *idx++ = base_pt+row_pts+y;
                *idx++ = base_pt+1+y;
            }

            base_pt += row_pts;
        }

        base_pt++;
    }

    // Generate base vertices
    pt = geom->pts;
    for (side = 0; side < geom->nsides; side++)
    {
        for (x = 0; x < config.subdiv+1; x++)
        {
            fx = (FLOAT)x/config.subdiv;
            for (y = 0; y < config.subdiv-x+1; y++)
            {
                MapToSide(&tetra_planes[side],
                          fx+(FLOAT)y/(config.subdiv*2),
                          (FLOAT)y/config.subdiv,
                          pt);
                pt++;
            }
        }
    }

    geom->total_pts = geom->nsides*side_pts;
}




//-----------------------------------------------------------------------------
// Name: InitPyramids()
// Desc: Initializes double pyramid geometry
//-----------------------------------------------------------------------------
VOID InitPyramids(GEOMETRY *geom)
{
    const INT PYRAMIDS_SIDES = 8;
    PLANE_MAP pyramids_planes[PYRAMIDS_SIDES] =
    {
        PLANE_MAP(D3DXVECTOR3(-0.5f, 0.0f,  0.5f), D3DXVECTOR3( 1.0f, 0.0f,  0.0f), D3DXVECTOR3( 0.0f,  0.5f, -0.5f)),
        PLANE_MAP(D3DXVECTOR3( 0.5f, 0.0f,  0.5f), D3DXVECTOR3(-1.0f, 0.0f,  0.0f), D3DXVECTOR3( 0.0f, -0.5f, -0.5f)),
        PLANE_MAP(D3DXVECTOR3( 0.5f, 0.0f,  0.5f), D3DXVECTOR3( 0.0f, 0.0f, -1.0f), D3DXVECTOR3(-0.5f,  0.5f,  0.0f)),
        PLANE_MAP(D3DXVECTOR3( 0.5f, 0.0f, -0.5f), D3DXVECTOR3( 0.0f, 0.0f,  1.0f), D3DXVECTOR3(-0.5f, -0.5f,  0.0f)),
        PLANE_MAP(D3DXVECTOR3( 0.5f, 0.0f, -0.5f), D3DXVECTOR3(-1.0f, 0.0f,  0.0f), D3DXVECTOR3( 0.0f,  0.5f,  0.5f)),
        PLANE_MAP(D3DXVECTOR3(-0.5f, 0.0f, -0.5f), D3DXVECTOR3( 1.0f, 0.0f,  0.0f), D3DXVECTOR3( 0.0f, -0.5f,  0.5f)),
        PLANE_MAP(D3DXVECTOR3(-0.5f, 0.0f, -0.5f), D3DXVECTOR3( 0.0f, 0.0f,  1.0f), D3DXVECTOR3( 0.5f,  0.5f,  0.0f)),
        PLANE_MAP(D3DXVECTOR3(-0.5f, 0.0f,  0.5f), D3DXVECTOR3( 0.0f, 0.0f, -1.0f), D3DXVECTOR3( 0.5f, -0.5f,  0.0f))
    };

    INT side, x, y;
    D3DXVECTOR3 *pt;
    unsigned short/*INT*/ *idx;
    INT *sz;
    unsigned short side_pts;
    unsigned short base_pt;
    unsigned short row_pts;
    FLOAT fx;

    side_pts = (config.subdiv+2)*(config.subdiv+1)/2;
    
    geom->nsides = PYRAMIDS_SIDES;
    geom->pts = &pts[0];
    geom->npts = &npts[0];
    geom->normals = &normals[0];
    geom->pVertices = &vertices[0];

    geom->min_sf = -1.1f;
    geom->max_sf = 5.2f;
    geom->sf_inc = 0.05f;
    geom->init_sf = 3.0f;

    // Generate triangle strip data
    sz = &strip_size[0];
    idx = &index[0];
    base_pt = 0;

    for (side = 0; side < geom->nsides; side++) {
        geom->sides[side].nstrips = config.subdiv;
        geom->sides[side].strip_size = sz;
        geom->sides[side].strip_index = idx;
            
        for (x = 0; x < config.subdiv; x++) {
            row_pts = config.subdiv-x+1;
            *sz++ = row_pts*2-1;

            *idx++ = base_pt;
            for (y = 0; y < row_pts-1; y++) {
                *idx++ = base_pt+row_pts+y;
                *idx++ = base_pt+1+y;
            }

            base_pt += row_pts;
        }
            
        base_pt++;
    }

    // Generate base vertices
    pt = geom->pts;
    for (side = 0; side < geom->nsides; side++)
    {
        
        for (x = 0; x < config.subdiv+1; x++)
        {
            fx = (FLOAT)x/config.subdiv;
            for (y = 0; y < config.subdiv-x+1; y++)
            {
                MapToSide(&pyramids_planes[side],
                          fx+(FLOAT)y/(config.subdiv*2),
                          (FLOAT)y/config.subdiv,
                          pt);
                pt++;
            }
        }
    }

    geom->total_pts = geom->nsides*side_pts;
}




//-----------------------------------------------------------------------------
// Name: InitCylinder()
// Desc: Initializes the cylinder geometry
//-----------------------------------------------------------------------------
VOID InitCylinder(GEOMETRY *geom)
{
    unsigned short side, x, y;
    D3DXVECTOR3 *pt;
    unsigned short/*INT*/ *idx;
    INT *sz;
    unsigned short base_pt;
    unsigned short row_pts;
    FLOAT fx, fz;
    double ang;

    geom->nsides = 1;
    geom->pts = &pts[0];
    geom->npts = &npts[0];
    geom->normals = &normals[0];
    geom->pVertices = &vertices[0];

    geom->min_sf = -2.5f;
    geom->max_sf = 8.5f;
    geom->sf_inc = 0.05f;
    geom->init_sf = 2.1f;

    // Generate triangle strip data
    // If version 1.1 then allocate the index buffer for glDrawElements
    sz = &strip_size[0];
    idx = &index[0];
    side = 0;
    geom->sides[side].nstrips = config.subdiv;
    geom->sides[side].strip_size = sz;
    geom->sides[side].strip_index = idx;
    
    row_pts = config.subdiv+1;
    base_pt = 0;
    for (x = 0; x < config.subdiv; x++) {
        *sz++ = row_pts*2;
        
        for (y = 0; y < row_pts; y++) {
            // Wrap around at the edge so the cylinder normals
            // are properly averaged
            if (x == config.subdiv-1) {
                *idx++ = y;
            }
            else {
                *idx++ = base_pt+row_pts+y;
            }
            *idx++ = base_pt+y;
        }

        base_pt += row_pts;
    }
    
    // Generate base vertices
    pt = geom->pts;
    ang = 0;
    for (x = 0; x < config.subdiv; x++)
    {
        fx = (FLOAT)cos(ang)*0.5f;
        fz = (FLOAT)sin(ang)*0.5f;
        for (y = 0; y < config.subdiv+1; y++)
        {
            pt->x = fx;
            pt->y = (FLOAT)y/config.subdiv-0.5f;
            pt->z = fz;
            pt++;
        }
        ang += (2*D3DX_PI)/config.subdiv;
    }

    geom->total_pts = geom->nsides*(config.subdiv+1)*config.subdiv;
}




//-----------------------------------------------------------------------------
// Name: InitSpring()
// Desc: Initializes the spring geometry
//-----------------------------------------------------------------------------
VOID InitSpring(GEOMETRY *geom)
{
    const FLOAT SPRING_RADIUS = 0.1f;
    const FLOAT SPRING_CENTER = (0.5f-SPRING_RADIUS);
    INT side, x, y;
    D3DXVECTOR3 *pt;
    unsigned short/*INT*/ *idx;
    INT *sz;
    double ang_center, ang_surf;
    FLOAT cs, sn;
    FLOAT rad;
    PLANE_MAP plane;
    INT spin_pts;
    INT row_pts;

    geom->nsides = 1;
    geom->pts = &pts[0];
    geom->npts = &npts[0];
    geom->normals = &normals[0];
    geom->pVertices = &vertices[0];

    geom->min_sf = -2.2f;
    geom->max_sf = 0.2f;
    geom->sf_inc = 0.05f;
    geom->init_sf = 1.0f;

    // Generate triangle strip data
    // If version 1.1 then allocate the index buffer for glDrawElements
    sz = &strip_size[0];
    idx = &index[0];
    side = 0;
    geom->sides[side].nstrips = config.subdiv;
    geom->sides[side].strip_size = sz;
    geom->sides[side].strip_index = idx;
    
    row_pts = config.subdiv;
    spin_pts = 4*config.subdiv+1;
    for (x = 0; x < config.subdiv; x++) {
        *sz++ = spin_pts*2;

        for (y = 0; y < spin_pts; y++) {
            *idx++ = x+row_pts*y;
            // Wrap around at the edge so the cylindrical surface
            // of the tube is seamless.  Without this the normal
            // averaging would be incorrect and a seam would be visible
            if (x == config.subdiv-1) {
                *idx++ = row_pts*y;
            }
            else {
                *idx++ = x+row_pts*y+1;
            }
        }
    }
    
    // Generate base vertices
    pt = geom->pts;
    ang_center = 0;
    plane.y_axis.x = 0.0f;
    plane.y_axis.y = SPRING_RADIUS;
    plane.y_axis.z = 0.0f;
    plane.x_axis.y = 0.0f;
    for (x = 0; x < spin_pts; x++)
    {
        cs = (FLOAT)cos(ang_center);
        sn = (FLOAT)sin(ang_center);
        rad = 0.5f-(FLOAT)x/(spin_pts-1)*(SPRING_CENTER/2);
        plane.base.x = cs*rad;
        plane.base.y = -0.5f+(FLOAT)x/(spin_pts-1);
        plane.base.z = sn*rad;
        plane.x_axis.x = cs*SPRING_RADIUS;
        plane.x_axis.z = sn*SPRING_RADIUS;

        ang_surf = 0;
        for (y = 0; y < config.subdiv; y++)
        {
            MapToSide(&plane,
                      (FLOAT)cos(ang_surf), (FLOAT)sin(ang_surf),
                      pt);
            pt++;
            ang_surf += (2*D3DX_PI)/config.subdiv;
        }
        
        ang_center += (4*D3DX_PI)/(spin_pts-1);
    }

    geom->total_pts = geom->nsides*spin_pts*config.subdiv;
}




//-----------------------------------------------------------------------------
// Name: DrawGeom()
// Desc: Draw the current geometry
//-----------------------------------------------------------------------------
VOID CFlowerBoxScreensaver::DrawGeom(GEOMETRY *geom)
{
    if (config.smooth_colors)
        m_pd3dDevice->SetRenderState( D3DRS_SHADEMODE, D3DSHADE_GOURAUD );
    else
        m_pd3dDevice->SetRenderState( D3DRS_SHADEMODE, D3DSHADE_FLAT );

    if (config.color_pick == ID_COL_SINGLE)
        SetMaterialColor(solid_cols);

    for( INT i = 0; i < geom->total_pts; i++ )
    {
        geom->pVertices[i].p = *(D3DXVECTOR3*)&geom->npts[i];
        D3DXVec3Normalize( &geom->pVertices[i].n, (D3DXVECTOR3*)&geom->normals[i] );
    }

    m_pd3dDevice->SetVertexShader( D3DFVF_MYVERTEX );

    WORD col0Indices[5000];
    INT numCol0Indices;
    WORD col1Indices[5000];
    INT numCol1Indices;

    INT side;
    INT strip;
    INT triangle;
    unsigned short *idx;
    BOOL bBackwards; // triangle backwards for original strip implementation
    BOOL bCol0; // col0 or col1 for this triangle?
    INT numThisColor; // num tris done in this color; helps determine bCol0
    for (side = 0; side < geom->nsides; side++) 
    {
        numCol0Indices = 0;
        numCol1Indices = 0;
        bCol0 = TRUE;

        idx = geom->sides[side].strip_index;
        for (strip = 0; strip < geom->sides[side].nstrips; strip++, idx += 2) 
        {
            numThisColor = 0;
            if( !config.triangle_colors )
                numThisColor++;
            bBackwards = FALSE;
            if( config.color_pick == ID_COL_CHECKER )
                bCol0 = ( strip & 1 );

            for( triangle = 0; triangle < geom->sides[side].strip_size[strip] - 2; triangle++ )
            {
                if( config.color_pick == ID_COL_CHECKER )
                {
                    numThisColor++;
                    if( numThisColor == 2 )
                    {
                        bCol0 = !bCol0;
                        numThisColor = 0;
                    }
                }

                if( bCol0 )
                {
                    if( bBackwards )
                    {
                        col0Indices[numCol0Indices++] = *(idx+1);
                        col0Indices[numCol0Indices++] = *(idx+0);
                        col0Indices[numCol0Indices++] = *(idx+2);
                    }
                    else
                    {
                        col0Indices[numCol0Indices++] = *(idx+0);
                        col0Indices[numCol0Indices++] = *(idx+1);
                        col0Indices[numCol0Indices++] = *(idx+2);
                    }
                }
                else
                {
                    if( bBackwards )
                    {
                        col1Indices[numCol1Indices++] = *(idx+1);
                        col1Indices[numCol1Indices++] = *(idx+0);
                        col1Indices[numCol1Indices++] = *(idx+2);
                    }
                    else
                    {
                        col1Indices[numCol1Indices++] = *(idx+0);
                        col1Indices[numCol1Indices++] = *(idx+1);
                        col1Indices[numCol1Indices++] = *(idx+2);
                   }
                }
                idx ++;
                bBackwards = !bBackwards;
            }
        }

        // Draw this side's col0 primitives
        if (config.color_pick == ID_COL_PER_SIDE) 
            SetMaterialColor(side_cols[side]);
        else if (config.color_pick == ID_COL_CHECKER) 
            SetMaterialColor(checker_cols[side][0]);
        m_pd3dDevice->DrawIndexedPrimitiveUP( D3DPT_TRIANGLELIST, 0,
            geom->total_pts, numCol0Indices / 3, 
            col0Indices, D3DFMT_INDEX16, &geom->pVertices[0], sizeof(MYVERTEX) );

        // Draw this side's col1 primitives, if any
        if (config.color_pick == ID_COL_CHECKER) 
        {
            SetMaterialColor(checker_cols[side][1]);
            m_pd3dDevice->DrawIndexedPrimitiveUP( D3DPT_TRIANGLELIST, 0,
                geom->total_pts, numCol1Indices / 3, 
                col1Indices, D3DFMT_INDEX16, &geom->pVertices[0], sizeof(MYVERTEX) );
        }
    }
}




//-----------------------------------------------------------------------------
// Name: ComputeAveragedNormals()
// Desc: Compute face-averaged normals for each vertex
//-----------------------------------------------------------------------------
VOID ComputeAveragedNormals(GEOMETRY *geom)
{
    INT side, strip;
    INT *sz;
    unsigned short/*INT*/ *idx;
    INT idx1, idx2, idx3;
    INT tc, idc;
    D3DXVECTOR3 v1, v2, n1;
    
    memset(geom->normals, 0, sizeof(D3DXVECTOR3)*geom->total_pts);
    
    for (side = 0; side < geom->nsides; side++)
    {
        idx = geom->sides[side].strip_index;
        sz = geom->sides[side].strip_size;
        for (strip = 0; strip < geom->sides[side].nstrips; strip++)
        {
            idx1 = *idx++;
            idx2 = *idx++;

//            assert(idx1 >= 0 && idx1 < geom->total_pts &&
//                   idx2 >= 0 && idx2 < geom->total_pts);
            
            tc = (*sz++)-2;
            for (idc = 0; idc < tc; idc++)
            {
                idx3 = *idx++;

//                assert(idx3 >= 0 && idx3 < geom->total_pts);

                v1 = geom->npts[idx3] - geom->npts[idx1];
                v2 = geom->npts[idx2] - geom->npts[idx1];
                D3DXVec3Cross( &n1, &v1, &v2 );

                // Triangle strip ordering causes half of the triangles
                // to be oriented oppositely from the others
                // Those triangles need to have their normals flipped
                // so the whole triangle strip has consistent normals
                if ((idc & 1) == 0)
                {
                    n1.x = -n1.x;
                    n1.y = -n1.y;
                    n1.z = -n1.z;
                }

                geom->normals[idx1] += n1;
                geom->normals[idx2] += n1;
                geom->normals[idx3] += n1;

                idx1 = idx2;
                idx2 = idx3;
            }
        }
    }
}




//-----------------------------------------------------------------------------
// Name: UpdatePts()
// Desc: 
//-----------------------------------------------------------------------------
VOID CFlowerBoxScreensaver::UpdatePts(GEOMETRY *geom, FLOAT sf)
{
    INT pt;
    FLOAT f, *vl;
    D3DXVECTOR3 *v;
    D3DXVECTOR3 *p;

    vl = vlen;
    p = &geom->pts[0];
    v = &geom->npts[0];
    for (pt = 0; pt < geom->total_pts; pt++)
    {
        f = (*vl++)*sf+1;
        v->x = p->x*f;
        v->y = p->y*f;
        v->z = p->z*f;
        p++;
        v++;
    }

    ComputeAveragedNormals(geom);
}




//-----------------------------------------------------------------------------
// Name: ComputeHsvColors()
// Desc: 
//-----------------------------------------------------------------------------
VOID CFlowerBoxScreensaver::ComputeHsvColors(VOID)
{
    FLOAT *cols;
    INT ncols;
    FLOAT ang, da;
    INT hex;
    FLOAT fhex, frac;
    FLOAT p, q, t;
    FLOAT sat, val;

    switch(config.color_pick)
    {
    case ID_COL_CHECKER:
        ncols = MAXSIDES*NCCOLS;
        cols = &checker_cols[0][0][0];
        break;
    case ID_COL_PER_SIDE:
        ncols = MAXSIDES;
        cols = &side_cols[0][0];
        break;
    case ID_COL_SINGLE:
        ncols = 1;
        cols = &solid_cols[0];
        break;
    }

    ang = m_phase;
    da = (FLOAT)((2*D3DX_PI)/ncols);
    val = sat = 1.0f;

    while (ncols > 0)
    {
        fhex = (FLOAT)(6*ang/(2*D3DX_PI));
        hex = (INT)fhex;
        frac = fhex-hex;
        hex = hex % 6;
        
	p = val*(1-sat);
	q = val*(1-sat*frac);
	t = val*(1-sat*(1-frac));
        
	switch(hex)
	{
	case 0:
            cols[0] = val;
            cols[1] = t;
            cols[2] = p;
	    break;
	case 1:
            cols[0] = q;
            cols[1] = val;
            cols[2] = p;
	    break;
	case 2:
            cols[0] = p;
            cols[1] = val;
            cols[2] = t;
	    break;
	case 3:
            cols[0] = p;
            cols[1] = q;
            cols[2] = val;
	    break;
	case 4:
            cols[0] = t;
            cols[1] = p;
            cols[2] = val;
            break;
	case 5:
            cols[0] = val;
            cols[1] = p;
            cols[2] = q;
	    break;
	}

        ang += da;
        cols += 4;
        ncols--;
    }
}




//-----------------------------------------------------------------------------
// Name: NewConfig()
// Desc: 
//-----------------------------------------------------------------------------
VOID CFlowerBoxScreensaver::NewConfig(CONFIG *cnf)
{
    // Set new config
    config = *cnf;

    HKEY hkey;

    if( ERROR_SUCCESS == RegCreateKeyEx( HKEY_CURRENT_USER, m_strRegPath,
        0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, NULL ) )
    {
        DXUtil_WriteBoolRegKey( hkey, TEXT("Smooth"), config.smooth_colors );
        DXUtil_WriteBoolRegKey( hkey, TEXT("Slanted"), config.triangle_colors );
        DXUtil_WriteBoolRegKey( hkey, TEXT("Cycle"), config.cycle_colors );
        DXUtil_WriteBoolRegKey( hkey, TEXT("Spin"), config.spin );
        DXUtil_WriteBoolRegKey( hkey, TEXT("Bloom"), config.bloom );
        DXUtil_WriteIntRegKey( hkey, TEXT("Subdiv"), config.subdiv );
        DXUtil_WriteIntRegKey( hkey, TEXT("ColorPick"), config.color_pick );
        DXUtil_WriteIntRegKey( hkey, TEXT("ImageSize"), config.image_size );
        DXUtil_WriteIntRegKey( hkey, TEXT("Geom"), config.geom );
        DXUtil_WriteIntRegKey( hkey, TEXT("TwoSided"), config.two_sided );

        WriteScreenSettings( hkey );

        RegCloseKey( hkey );
    }

    // Reset colors
    memcpy(checker_cols, base_checker_cols, sizeof(checker_cols));
    memcpy(side_cols, base_side_cols, sizeof(side_cols));
    memcpy(solid_cols, base_solid_cols, sizeof(solid_cols));

    // Reset geometry
    m_pGeomCur = geom_table[config.geom];
    m_pGeomCur->init(m_pGeomCur);
    
//    assert(m_pGeomCur->total_pts <= MAXPTS);
           
    InitVlen(m_pGeomCur, m_pGeomCur->total_pts, m_pGeomCur->pts);
    m_sf = 0.0f;
    m_sfi = m_pGeomCur->sf_inc;
    UpdatePts(m_pGeomCur, m_sf);
}




//-----------------------------------------------------------------------------
// Name: SetupTrackbar()
// Desc: Setup a common control trackbar
//-----------------------------------------------------------------------------
VOID SetupTrackbar( HWND hDlg, INT item, INT lo, INT hi, INT lineSize, 
                  INT pageSize, INT pos )
{
    SendDlgItemMessage( 
        hDlg, 
        item,
        TBM_SETRANGE, 
        (WPARAM) TRUE, 
        (LPARAM) MAKELONG( lo, hi )
    );
    SendDlgItemMessage( 
        hDlg, 
        item,
        TBM_SETPOS, 
        (WPARAM) TRUE, 
        (LPARAM) pos
    );
    SendDlgItemMessage( 
        hDlg, 
        item,
        TBM_SETPAGESIZE, 
        (WPARAM) 0,
        (LPARAM) pageSize 
    );
    SendDlgItemMessage( 
        hDlg, 
        item,
        TBM_SETLINESIZE, 
        (WPARAM) 0,
        (LPARAM) lineSize
    );
}




//-----------------------------------------------------------------------------
// Name: GetTrackbarPos()
// Desc: Get the current position of a common control trackbar
//-----------------------------------------------------------------------------
INT GetTrackbarPos( HWND hDlg, INT item )
{
    return 
       (INT)SendDlgItemMessage( 
            hDlg, 
            item,
            TBM_GETPOS, 
            0,
            0
        );
}

// Temporary configuration for when the configuration dialog is active
// If the dialog is ok'ed then this becomes the current configuration,
// otherwise it is discarded
CONFIG temp_config;

//-----------------------------------------------------------------------------
// Name: ScreenSaverConfigureDialog()
// Desc: 
//-----------------------------------------------------------------------------
BOOL CALLBACK CFlowerBoxScreensaver::ScreenSaverConfigureDialog(HWND hdlg, UINT msg,
                                         WPARAM wpm, LPARAM lpm)
{
    HWND hCtrl;
    INT i;
    
    switch(msg)
    {
    case WM_INITDIALOG:

        InitCommonControls();

        g_pMyFlowerBoxScreensaver->ReadSettings();
    
        temp_config = config;
        
        CheckRadioButton(hdlg, ID_COL_PICK_FIRST, ID_COL_PICK_LAST,
                         config.color_pick);
        CheckDlgButton(hdlg, ID_COL_SMOOTH, config.smooth_colors);
        CheckDlgButton(hdlg, ID_COL_TRIANGLE, config.triangle_colors);
        CheckDlgButton(hdlg, ID_COL_CYCLE, config.cycle_colors);
        CheckDlgButton(hdlg, ID_SPIN, config.spin);
        CheckDlgButton(hdlg, ID_BLOOM, config.bloom);
        CheckDlgButton(hdlg, ID_TWO_SIDED,
                       config.two_sided == GL_FRONT_AND_BACK);
        
        SetupTrackbar( hdlg, ID_COMPLEXITY, MINSUBDIV, MAXSUBDIV, 
                          complexity_range.step,
                          complexity_range.page_step,
                          config.subdiv);

        SetupTrackbar( hdlg, ID_IMAGE_SIZE, MINIMAGESIZE, MAXIMAGESIZE, 
                          image_size_range.step,
                          image_size_range.page_step,
                          config.image_size);

        hCtrl = GetDlgItem(hdlg, ID_GEOM);
        SendMessage(hCtrl, CB_RESETCONTENT, 0, 0);

        // String storage
        TCHAR geom_names[IDS_GEOM_COUNT][20];
        
        for (i = 0; i < IDS_GEOM_COUNT; i++)
        {
            LoadString( NULL, i+IDS_GEOM_FIRST, geom_names[i],
                        sizeof(geom_names)/IDS_GEOM_COUNT );
            SendMessage(hCtrl, CB_ADDSTRING, 0, (LPARAM)geom_names[i]);
        }
        SendMessage(hCtrl, CB_SETCURSEL, config.geom, 0);
        
        SetFocus(GetDlgItem(hdlg, ID_COMPLEXITY));
        return FALSE;

    case WM_COMMAND:
        switch(LOWORD(wpm))
        {
        case ID_COL_CHECKER:
        case ID_COL_PER_SIDE:
        case ID_COL_SINGLE:
            temp_config.color_pick = LOWORD(wpm);
            break;

        case ID_COL_SMOOTH:
            temp_config.smooth_colors = !temp_config.smooth_colors;
            break;
        case ID_COL_TRIANGLE:
            temp_config.triangle_colors = !temp_config.triangle_colors;
            break;
        case ID_COL_CYCLE:
            temp_config.cycle_colors = !temp_config.cycle_colors;
            break;
            
        case ID_SPIN:
            temp_config.spin = !temp_config.spin;
            break;
        case ID_BLOOM:
            temp_config.bloom = !temp_config.bloom;
            break;
        case ID_TWO_SIDED:
            temp_config.two_sided =
                temp_config.two_sided == GL_FRONT_AND_BACK ? GL_FRONT :
                GL_FRONT_AND_BACK;
            break;

        case IDC_SCREENSETTINGS:
            g_pMyFlowerBoxScreensaver->DoScreenSettingsDialog(hdlg);
            break;

        case IDOK:
            temp_config.subdiv =
                GetTrackbarPos(hdlg, ID_COMPLEXITY);
            temp_config.image_size =
                GetTrackbarPos(hdlg, ID_IMAGE_SIZE);
            temp_config.geom =
                (INT)SendMessage(GetDlgItem(hdlg, ID_GEOM), CB_GETCURSEL, 0, 0);
//            NewConfig(&temp_config);
            // Fall through
        case IDCANCEL:
            EndDialog(hdlg, LOWORD(wpm));
            break;
        }
        return TRUE;
        
    }

    return FALSE;
}





//-----------------------------------------------------------------------------
// Name: SetMaterialColor()
// Desc: 
//-----------------------------------------------------------------------------
HRESULT CFlowerBoxScreensaver::SetMaterialColor(FLOAT* pfColors)
{
    D3DMATERIAL8 mtrl;

    ZeroMemory( &mtrl, sizeof(D3DMATERIAL8) );
    mtrl.Diffuse.r = mtrl.Ambient.r = pfColors[0];
    mtrl.Diffuse.g = mtrl.Ambient.g = pfColors[1];
    mtrl.Diffuse.b = mtrl.Ambient.b = pfColors[2];
    mtrl.Diffuse.a = mtrl.Ambient.a = pfColors[3];
    mtrl.Specular.r = 0.8f;
    mtrl.Specular.g = 0.8f;
    mtrl.Specular.b = 0.8f;
    mtrl.Specular.a = 1.0f;
    mtrl.Power = 30.0f;

    return m_pd3dDevice->SetMaterial(&mtrl);
}




//-----------------------------------------------------------------------------
// Name: ReadSettings()
// Desc: Read user preferences from registry
//-----------------------------------------------------------------------------
VOID CFlowerBoxScreensaver::ReadSettings()
{
    HKEY hkey;

    // Read OpenGL settings first, so OS upgrade cases work
    ss_ReadSettings();

    if( ERROR_SUCCESS == RegCreateKeyEx( HKEY_CURRENT_USER, m_strRegPath,
        0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, NULL ) )
    {
        DXUtil_ReadBoolRegKey( hkey, TEXT("Smooth"), &config.smooth_colors, config.smooth_colors );
        DXUtil_ReadBoolRegKey( hkey, TEXT("Slanted"), &config.triangle_colors, config.triangle_colors );
        DXUtil_ReadBoolRegKey( hkey, TEXT("Cycle"), &config.cycle_colors, config.cycle_colors );
        DXUtil_ReadBoolRegKey( hkey, TEXT("Spin"), &config.spin, config.spin );
        DXUtil_ReadBoolRegKey( hkey, TEXT("Bloom"), &config.bloom, config.bloom );
        DXUtil_ReadIntRegKey( hkey, TEXT("Subdiv"), (DWORD*)&config.subdiv, config.subdiv );
        if( config.subdiv < MINSUBDIV )
            config.subdiv = MINSUBDIV;
        if( config.subdiv > MAXSUBDIV )
            config.subdiv = MAXSUBDIV;
        DXUtil_ReadIntRegKey( hkey, TEXT("ColorPick"), (DWORD*)&config.color_pick, config.color_pick );
        DXUtil_ReadIntRegKey( hkey, TEXT("ImageSize"), (DWORD*)&config.image_size, config.image_size );
        DXUtil_ReadIntRegKey( hkey, TEXT("Geom"), (DWORD*)&config.geom, config.geom );
        DXUtil_ReadIntRegKey( hkey, TEXT("TwoSided"), (DWORD*)&config.two_sided, config.two_sided );

        ReadScreenSettings( hkey );

        RegCloseKey( hkey );
    }
}




//-----------------------------------------------------------------------------
// Name: ss_ReadSettings()
// Desc: 
//-----------------------------------------------------------------------------
VOID CFlowerBoxScreensaver::ss_ReadSettings()
{
    if( !ss_RegistrySetup( IDS_INI_SECTION, IDS_INIFILE ) )
        return;
    
    config.smooth_colors =
        ss_GetRegistryInt( IDS_CONFIG_SMOOTH_COLORS, config.smooth_colors );
    config.triangle_colors =
        ss_GetRegistryInt( IDS_CONFIG_TRIANGLE_COLORS, config.triangle_colors );
    config.cycle_colors =
        ss_GetRegistryInt( IDS_CONFIG_CYCLE_COLORS, config.cycle_colors );
    config.spin =
        ss_GetRegistryInt( IDS_CONFIG_SPIN, config.spin );
    config.bloom =
        ss_GetRegistryInt( IDS_CONFIG_BLOOM, config.bloom );
    config.subdiv =
        ss_GetRegistryInt( IDS_CONFIG_SUBDIV, config.subdiv );
    config.color_pick =
        ss_GetRegistryInt( IDS_CONFIG_COLOR_PICK, config.color_pick );
    config.image_size =
        ss_GetRegistryInt( IDS_CONFIG_IMAGE_SIZE, config.image_size );
    config.geom =
        ss_GetRegistryInt( IDS_CONFIG_GEOM, config.geom );
    config.two_sided =
        ss_GetRegistryInt( IDS_CONFIG_TWO_SIDED, config.two_sided );
}




//-----------------------------------------------------------------------------
// Name: ss_GetRegistryString()
// Desc: 
//-----------------------------------------------------------------------------
BOOL CFlowerBoxScreensaver::ss_RegistrySetup( int section, int file )
{
    if( LoadString(m_hInstance, section, g_szSectName, BUF_SIZE) &&
        LoadString(m_hInstance, file, g_szFname, BUF_SIZE) ) 
    {
        TCHAR pBuffer[100];
        DWORD dwRealSize = GetPrivateProfileSection( g_szSectName, pBuffer, 100, g_szFname );
        if( dwRealSize > 0 )
            return TRUE;
    }

    return FALSE;
}




//-----------------------------------------------------------------------------
// Name: ss_GetRegistryString()
// Desc: 
//-----------------------------------------------------------------------------
int CFlowerBoxScreensaver::ss_GetRegistryInt( int name, int iDefault )
{
    TCHAR szItemName[BUF_SIZE];

    if( LoadString( m_hInstance, name, szItemName, BUF_SIZE ) ) 
        return GetPrivateProfileInt(g_szSectName, szItemName, iDefault, g_szFname);

    return 0;
}




//-----------------------------------------------------------------------------
// Name: ss_GetRegistryString()
// Desc: 
//-----------------------------------------------------------------------------
VOID CFlowerBoxScreensaver::ss_GetRegistryString( int name, LPTSTR lpDefault, 
                                                         LPTSTR lpDest, int bufSize )
{
    TCHAR szItemName[BUF_SIZE];

    if( LoadString( m_hInstance, name, szItemName, BUF_SIZE ) ) 
        GetPrivateProfileString(g_szSectName, szItemName, lpDefault, lpDest,
                                bufSize, g_szFname);

    return;
}




//-----------------------------------------------------------------------------
// Name: DoConfig()
// Desc: 
//-----------------------------------------------------------------------------
VOID CFlowerBoxScreensaver::DoConfig()
{
    if( IDOK == DialogBox( NULL, MAKEINTRESOURCE( DLG_SCRNSAVECONFIGURE ),
        m_hWndParent, (DLGPROC)ScreenSaverConfigureDialog ) )
    {
        NewConfig(&temp_config);
    }
}