windows-nt/Source/XPSP1/NT/shell/osshell/control/scrnsave/pipes/pipes.cpp

659 lines
20 KiB
C++
Raw Permalink Normal View History

2020-09-26 03:20:57 -05:00
//-----------------------------------------------------------------------------
// File: Pipes.cpp
//
// Desc: Fun screen saver.
//
// Copyright (c) 2000-2001 Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
#include "stdafx.h"
//-----------------------------------------------------------------------------
// Name: struct MYVERTEX
// Desc: D3D vertex type for this app
//-----------------------------------------------------------------------------
struct MYVERTEX
{
D3DXVECTOR3 p; // Position
FLOAT tu; // Vertex texture coordinates
FLOAT tv;
MYVERTEX(D3DXVECTOR3 pInit, FLOAT tuInit, FLOAT tvInit)
{ p = pInit; tu = tuInit; tv = tvInit; }
};
#define D3DFVF_MYVERTEX (D3DFVF_XYZ | D3DFVF_TEX1)
#define BUF_SIZE 255
TCHAR g_szSectName[BUF_SIZE];
TCHAR g_szFname[BUF_SIZE];
CPipesScreensaver* g_pMyPipesScreensaver = 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;
CPipesScreensaver pipesScreensaverSS;
if( FAILED( hr = pipesScreensaverSS.Create( hInst ) ) )
{
pipesScreensaverSS.DisplayErrorMsg( hr );
return 0;
}
return pipesScreensaverSS.Run();
}
//-----------------------------------------------------------------------------
// Name: CPipesScreensaver()
// Desc: Constructor
//-----------------------------------------------------------------------------
CPipesScreensaver::CPipesScreensaver( )
{
g_pMyPipesScreensaver = this;
InitCommonControls();
for( int i=0; i<MAX_DEVICE_OBJECTS; i++ )
{
m_DeviceObjects[i].m_pState = NULL;
}
LoadString( NULL, IDS_DESCRIPTION, m_strWindowTitle, 200 );
m_bUseDepthBuffer = TRUE;
m_SwapEffectFullscreen = D3DSWAPEFFECT_COPY;
m_SwapEffectWindowed = D3DSWAPEFFECT_COPY_VSYNC;
m_pDeviceObjects = NULL;
lstrcpy( m_strRegPath, TEXT("Software\\Microsoft\\ScreenSavers\\Pipes") );
m_Config.bMultiPipes = FALSE;
m_Config.nJointType = JOINT_ELBOW;
m_Config.bTextured = FALSE;
m_Config.bDefaultTexture = TRUE;
lstrcpy( m_Config.strTextureName[0], TEXT("") );
m_Config.bFlexMode = FALSE;
m_Config.dwTesselFact = 0;
m_Config.dwSpeed = 16;
m_iRenderUnit = 0;
RandInit();
}
//-----------------------------------------------------------------------------
// Name: SetDevice()
// Desc:
//-----------------------------------------------------------------------------
VOID CPipesScreensaver::SetDevice( UINT iDevice )
{
m_pDeviceObjects = &m_DeviceObjects[iDevice];
m_iRenderUnit = iDevice;
}
//-----------------------------------------------------------------------------
// Name: RegisterSoftwareDevice()
// Desc: This can register the D3D8RGBRasterizer or any other
// pluggable software rasterizer.
//-----------------------------------------------------------------------------
HRESULT CPipesScreensaver::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 CPipesScreensaver::FrameMove()
{
m_pDeviceObjects->m_pState->FrameMove( m_fElapsedTime );
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: DoPaint()
// Desc:
//-----------------------------------------------------------------------------
VOID CPipesScreensaver::DoPaint(HWND hwnd, HDC hdc)
{
CD3DScreensaver::DoPaint( hwnd, hdc );
for( int iDevice=0; iDevice<MAX_DEVICE_OBJECTS; iDevice++ )
{
if( m_DeviceObjects[iDevice].m_pState )
m_DeviceObjects[iDevice].m_pState->Repaint();
}
}
//-----------------------------------------------------------------------------
// 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 CPipesScreensaver::Render()
{
BOOL bRenderNewPiece = FALSE;
if( m_Config.dwSpeed == 20 )
{
bRenderNewPiece = TRUE;
}
else
{
FLOAT fCurTime = DXUtil_Timer( TIMER_GETAPPTIME );
if( fCurTime - m_pDeviceObjects->m_pState->m_fLastTime >
(20-m_Config.dwSpeed) * 0.005 )
{
bRenderNewPiece = TRUE;
m_pDeviceObjects->m_pState->m_fLastTime = fCurTime;
}
}
if( bRenderNewPiece )
{
// Begin the scene
if( SUCCEEDED( m_pd3dDevice->BeginScene() ) )
{
m_pDeviceObjects->m_pState->Render();
// End the scene.
m_pd3dDevice->EndScene();
}
}
else
{
if( m_iRenderUnit == 0 )
{
// Wait for a little while so we don't draw the pipes too fast
Sleep(10);
}
}
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: RestoreDeviceObjects()
// Desc:
//-----------------------------------------------------------------------------
HRESULT CPipesScreensaver::RestoreDeviceObjects()
{
if( m_pd3dDevice == NULL )
return S_OK;
m_pDeviceObjects->m_pState = new STATE( &m_Config );
m_pDeviceObjects->m_pState->InitDeviceObjects( m_pd3dDevice );
m_pDeviceObjects->m_pState->RestoreDeviceObjects();
m_pd3dDevice->Clear( 0L, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,
0x00000000, 1.0f, 0L );
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: InvalidateDeviceObjects()
// Desc:
//-----------------------------------------------------------------------------
HRESULT CPipesScreensaver::InvalidateDeviceObjects()
{
m_pDeviceObjects->m_pState->InvalidateDeviceObjects();
m_pDeviceObjects->m_pState->DeleteDeviceObjects();
SAFE_DELETE( m_pDeviceObjects->m_pState );
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: ConfigureDialogProcHelper()
// Desc:
//-----------------------------------------------------------------------------
INT_PTR CALLBACK ConfigureDialogProcHelper( HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
return g_pMyPipesScreensaver->ConfigureDialogProc( hwndDlg, uMsg, wParam, lParam );
}
//-----------------------------------------------------------------------------
// Name: DoConfig()
// Desc:
//-----------------------------------------------------------------------------
VOID CPipesScreensaver::DoConfig()
{
DialogBox( NULL, MAKEINTRESOURCE(IDD_CONFIGURE), m_hWndParent, ConfigureDialogProcHelper );
}
//-----------------------------------------------------------------------------
// Name: ConfigureDialogProc()
// Desc:
//-----------------------------------------------------------------------------
INT_PTR CALLBACK CPipesScreensaver::ConfigureDialogProc( HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
static CONFIG s_TempConfig;
switch (uMsg)
{
case WM_INITDIALOG:
{
ReadSettings();
s_TempConfig = m_Config;
lstrcpy( s_TempConfig.strTextureName[0], m_Config.strTextureName[0] );
if( s_TempConfig.bMultiPipes )
CheckRadioButton(hwndDlg, IDC_RADIO_SINGLE_PIPE, IDC_RADIO_MULTIPLE_PIPES,
IDC_RADIO_MULTIPLE_PIPES);
else
CheckRadioButton(hwndDlg, IDC_RADIO_SINGLE_PIPE, IDC_RADIO_MULTIPLE_PIPES,
IDC_RADIO_SINGLE_PIPE);
HWND hCtrl = GetDlgItem(hwndDlg, DLG_COMBO_JOINTTYPE);
SendMessage(hCtrl, CB_RESETCONTENT, 0, 0);
TCHAR strJointNames[IDS_JOINT_COUNT][MAX_PATH];
for (int i = 0; i < IDS_JOINT_COUNT; i++)
{
LoadString( NULL, i+IDS_JOINT_FIRST, strJointNames[i],
sizeof(strJointNames)/IDS_JOINT_COUNT );
SendMessage(hCtrl, CB_ADDSTRING, 0, (LPARAM)strJointNames[i]);
}
SendMessage(hCtrl, CB_SETCURSEL, s_TempConfig.nJointType, 0);
if( !s_TempConfig.bTextured )
{
CheckRadioButton(hwndDlg, IDC_RADIO_SOLID, IDC_RADIO_TEX,
IDC_RADIO_SOLID);
EnableWindow( GetDlgItem( hwndDlg, DLG_SETUP_TEXTURE ), FALSE );
}
else
{
CheckRadioButton(hwndDlg, IDC_RADIO_SOLID, IDC_RADIO_TEX,
IDC_RADIO_TEX);
EnableWindow( GetDlgItem( hwndDlg, DLG_SETUP_TEXTURE ), TRUE );
}
SendDlgItemMessage( hwndDlg, IDC_SPEED_SLIDER, TBM_SETRANGE, (WPARAM) TRUE, (LPARAM) MAKELONG( 0, 20 ) );
SendDlgItemMessage( hwndDlg, IDC_SPEED_SLIDER, TBM_SETPOS, (WPARAM) TRUE, (LPARAM) m_Config.dwSpeed );
SendDlgItemMessage( hwndDlg, IDC_SPEED_SLIDER, TBM_SETPAGESIZE, (WPARAM) 0, (LPARAM) 5 );
SendDlgItemMessage( hwndDlg, IDC_SPEED_SLIDER, TBM_SETLINESIZE, (WPARAM) 0, (LPARAM) 1 );
return TRUE;
}
case WM_COMMAND:
{
switch( LOWORD( wParam ) )
{
case IDC_RADIO_TEX:
EnableWindow( GetDlgItem( hwndDlg, DLG_SETUP_TEXTURE ), TRUE );
break;
case IDC_RADIO_SOLID:
EnableWindow( GetDlgItem( hwndDlg, DLG_SETUP_TEXTURE ), FALSE );
break;
case DLG_SETUP_TEXTURE:
{
if( SelectTextureFile( hwndDlg, s_TempConfig.strTextureName[0] ) )
{
CheckRadioButton(hwndDlg, IDC_RADIO_SOLID, IDC_RADIO_TEX,
IDC_RADIO_TEX);
s_TempConfig.bDefaultTexture = FALSE;
}
else
{
s_TempConfig.bDefaultTexture = TRUE;
}
break;
}
case IDC_SCREENSETTINGS:
{
DoScreenSettingsDialog( hwndDlg );
break;
}
case IDOK:
{
s_TempConfig.bMultiPipes = IsDlgButtonChecked(hwndDlg, IDC_RADIO_MULTIPLE_PIPES);
HWND hCtrl = GetDlgItem(hwndDlg, DLG_COMBO_JOINTTYPE);
s_TempConfig.nJointType = (DWORD) SendMessage(hCtrl, CB_GETCURSEL, 0, 0);
s_TempConfig.bTextured = IsDlgButtonChecked(hwndDlg, IDC_RADIO_TEX);
s_TempConfig.dwSpeed = (DWORD) SendDlgItemMessage( hwndDlg, IDC_SPEED_SLIDER, TBM_GETPOS, 0, 0 );
m_Config = s_TempConfig;
lstrcpy( m_Config.strTextureName[0], s_TempConfig.strTextureName[0] );
WriteSettings();
EndDialog(hwndDlg, IDOK);
break;
}
case IDCANCEL:
{
EndDialog(hwndDlg, IDCANCEL);
break;
}
}
return TRUE;
}
}
return FALSE;
}
//-----------------------------------------------------------------------------
// Name: SelectTextureFile()
// Desc:
//-----------------------------------------------------------------------------
BOOL CPipesScreensaver::SelectTextureFile( HWND hDlg, TCHAR* origPathName )
{
TCHAR fn[MAX_PATH] = TEXT("\0");
TCHAR szDialogTitle[MAX_PATH];
TCHAR szTextureFilter[MAX_PATH];
TCHAR szTitle[MAX_PATH];
LoadString(NULL, IDS_TEXTUREFILTER, szTextureFilter, MAX_PATH);
// Filter strings are weird because they contain nulls.
// The string loaded from a resource has # where nulls
// should be inserted.
for( TCHAR* pch = szTextureFilter; *pch != TEXT('\0'); pch++ )
{
if (*pch == TEXT('#'))
*pch = TEXT('\0');
}
LoadString(NULL, IDS_TEXTUREDIALOGTITLE, szDialogTitle, MAX_PATH);
LoadString(NULL, IDS_TITLE, szTitle, MAX_PATH);
TCHAR szWindowsDir[MAX_PATH];
szWindowsDir[0] = TEXT('\0');
GetWindowsDirectory( szWindowsDir, MAX_PATH );
OPENFILENAME ofn;
memset( &ofn, 0, sizeof(ofn) );
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = hDlg;
ofn.hInstance = m_hInstance;
ofn.lpstrFilter = szTextureFilter;
ofn.nFilterIndex = 1;
ofn.lpstrFile = origPathName;
ofn.nMaxFile = sizeof(fn);
ofn.lpstrTitle = szDialogTitle;
ofn.Flags = OFN_ENABLESIZING|OFN_FILEMUSTEXIST;
ofn.lpstrDefExt = TEXT("BMP");
if( lstrlen( origPathName ) == 0 )
ofn.lpstrInitialDir = szWindowsDir;
if( GetOpenFileName( &ofn ) )
{
lstrcpy( origPathName, ofn.lpstrFile );
return TRUE;
}
else
{
return FALSE;
}
}
//-----------------------------------------------------------------------------
// Name: ReadSettings()
// Desc:
//-----------------------------------------------------------------------------
VOID CPipesScreensaver::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 ) )
{
ReadScreenSettings( hkey );
// DXUtil_ReadBoolRegKey( hkey, TEXT("Flex Mode"), &m_Config.bFlexMode, m_Config.bFlexMode );
DXUtil_ReadBoolRegKey( hkey, TEXT("MultiPipes"), &m_Config.bMultiPipes, m_Config.bMultiPipes );
DXUtil_ReadBoolRegKey( hkey, TEXT("Textured"), &m_Config.bTextured, m_Config.bTextured );
DXUtil_ReadBoolRegKey( hkey, TEXT("Default Texture"), &m_Config.bDefaultTexture, m_Config.bDefaultTexture );
DXUtil_ReadIntRegKey( hkey, TEXT("Tessel Factor"), &m_Config.dwTesselFact, m_Config.dwTesselFact );
if( m_Config.dwTesselFact >= 4 )
m_Config.dwTesselFact = 4;
DXUtil_ReadIntRegKey( hkey, TEXT("Joint Type"), &m_Config.nJointType, m_Config.nJointType );
if( m_Config.nJointType >= NUM_JOINTTYPES )
m_Config.nJointType = JOINT_ELBOW;
DXUtil_ReadIntRegKey( hkey, TEXT("Speed"), &m_Config.dwSpeed, m_Config.dwSpeed );
DXUtil_ReadStringRegKey( hkey, TEXT("Texture Name"), m_Config.strTextureName[0], MAX_PATH, m_Config.strTextureName[0] );
RegCloseKey( hkey );
}
}
//-----------------------------------------------------------------------------
// Name: ss_ReadSettings()
// Desc:
//-----------------------------------------------------------------------------
VOID CPipesScreensaver::ss_ReadSettings()
{
// Get registry settings
if( ss_RegistrySetup( IDS_SAVERNAME, IDS_INIFILE ) )
{
m_Config.nJointType = ss_GetRegistryInt( IDS_JOINTTYPE, 0 );
m_Config.bTextured = (ss_GetRegistryInt( IDS_SURFSTYLE, 0 ) == 1);
if( m_Config.bTextured )
m_Config.bDefaultTexture = TRUE;
m_Config.bMultiPipes = ss_GetRegistryInt( IDS_MULTIPIPES, 0 );
ss_GetRegistryString( IDS_TEXTURE, 0, m_Config.strTextureName[0], MAX_PATH);
if( lstrlen(m_Config.strTextureName[0]) > 0 )
m_Config.bDefaultTexture = FALSE;
}
}
//-----------------------------------------------------------------------------
// Name: ss_GetRegistryString()
// Desc:
//-----------------------------------------------------------------------------
BOOL CPipesScreensaver::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 CPipesScreensaver::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 CPipesScreensaver::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: WriteSettings()
// Desc:
//-----------------------------------------------------------------------------
VOID CPipesScreensaver::WriteSettings()
{
HKEY hkey;
DWORD dwType = REG_DWORD;
DWORD dwLength = sizeof(DWORD);
if( ERROR_SUCCESS == RegCreateKeyEx( HKEY_CURRENT_USER, m_strRegPath,
0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, NULL ) )
{
WriteScreenSettings( hkey );
// DXUtil_WriteBoolRegKey( hkey, TEXT("Flex Mode"), m_Config.bFlexMode );
DXUtil_WriteBoolRegKey( hkey, TEXT("MultiPipes"), m_Config.bMultiPipes );
DXUtil_WriteBoolRegKey( hkey, TEXT("Textured"), m_Config.bTextured );
DXUtil_WriteBoolRegKey( hkey, TEXT("Default Texture"), m_Config.bDefaultTexture );
DXUtil_WriteIntRegKey( hkey, TEXT("Tessel Factor"), m_Config.dwTesselFact );
DXUtil_WriteIntRegKey( hkey, TEXT("Joint Type"), m_Config.nJointType );
DXUtil_WriteStringRegKey( hkey, TEXT("Texture Name"), m_Config.strTextureName[0] );
DXUtil_WriteIntRegKey( hkey, TEXT("Speed"), m_Config.dwSpeed );
RegCloseKey( hkey );
}
}
//-----------------------------------------------------------------------------
// Name: iRand()
// Desc: Generates integer random number 0..(max-1)
//-----------------------------------------------------------------------------
int CPipesScreensaver::iRand( int max )
{
return (int) ( max * ( ((float)rand()) / ((float)(RAND_MAX+1)) ) );
}
//-----------------------------------------------------------------------------
// Name: iRand2()
// Desc: Generates integer random number min..max
//-----------------------------------------------------------------------------
int CPipesScreensaver::iRand2( int min, int max )
{
if( min == max )
{
return min;
}
else if( max < min )
{
int temp = min;
min = max;
max = temp;
}
return min + (int) ( (max-min+1) * ( ((float)rand()) / ((float)(RAND_MAX+1)) ) );
}
//-----------------------------------------------------------------------------
// Name: fRand()
// Desc: Generates float random number min...max
//-----------------------------------------------------------------------------
FLOAT CPipesScreensaver::fRand( FLOAT min, FLOAT max )
{
FLOAT diff;
diff = max - min;
return min + ( diff * ( ((float)rand()) / ((float)(RAND_MAX)) ) );
}
//-----------------------------------------------------------------------------
// Name: RandInit()
// Desc: Initializes the randomizer
//-----------------------------------------------------------------------------
VOID CPipesScreensaver::RandInit()
{
struct _timeb time;
_ftime( &time );
srand( time.millitm );
for( int i = 0; i < 10; i ++ )
rand();
}