/******************************Module*Header*******************************\ * Module Name: sswindow.cxx * * Copyright (c) 1996 Microsoft Corporation * \**************************************************************************/ #include #include #include "scrnsave.h" #include "glscrnsv.h" #include "ssintrnl.hxx" #include "sswindow.hxx" #include "ssutil.hxx" static void (__stdcall *glAddSwapHintRect)(GLint, GLint, GLint, GLint); // externs from ssinit.cxx extern void *gDataPtr; extern void (*gReshapeFunc)(int, int, void *); extern void (*gRepaintFunc)( LPRECT, void *); extern void (*gUpdateFunc)( void *); extern void (*gInitFunc)( void *); extern void (*gFinishFunc)( void *); extern void (*gFloaterBounceFunc)( void *); // forwards static void GetWindowSize( HWND hwnd, ISIZE *pSize ); static void ss_QueryAddSwapHintRect(); static void DrawGdiDeltaRect( HDC hdc, HBRUSH hbr, RECT *pRect1, RECT *pRect2 ); static void DrawGLDeltaRect( GLRECT *pRect1, GLRECT *pRect2 ); /**************************************************************************\ * SSW constructor * \**************************************************************************/ SSW::SSW( PSSW psswParentArg, ISIZE *pSize, IPOINT2D *pPos, BOOL bMotion, SSCHILDSIZEPROC ChildSizeFuncArg ) { // Basic initialization Reset(); // Initialization based on constructor parameters psswParent = psswParentArg; ChildSizeFunc = ChildSizeFuncArg; if( pSize ) size = *pSize; if( pPos ) pos = *pPos; else pos.x = pos.y = 0; if( bMotion && psswParent ) { // Allocate motion structure pMotion = (MOTION *) LocalAlloc( LMEM_ZEROINIT | LMEM_FIXED, sizeof(MOTION) ); // If pMotion is NULL, then motion is disabled } // Call back to the client screen saver to determine size and motion // characteristics of child based on its parent size. GetChildInfo(); // this can set pos and size if( pMotion ) { if( pPos == NULL ) { // Set a random window pos pos.x = ss_iRand2( 0, (psswParent->size.width - size.width) ); pos.y = ss_iRand2( 0, (psswParent->size.height - size.height) ); // Set the motion parameters ResetMotion(); } // Have to make sure parent has an hdc so it can draw background when // this child moves if( !psswParent->hdc ) psswParent->hdc = GetDC( psswParent->hwnd ); } if( psswParent ) { // Need to add this pssw to its parent's list psswParent->AddChild( this ); // Default is to be subWindow of parent psswParent->iSubWindow++; // increment reference count } } /**************************************************************************\ * SSW constructor * * Used when wrapping an SSW around an already existing window * (as when drawing GL on dialog buttons) \**************************************************************************/ SSW::SSW( PSSW psswParentArg, HWND hwndArg ) { Reset(); psswParent = psswParentArg; if( psswParent ) // Need to add this pssw to its parent's list psswParent->AddChild( this ); hwnd = hwndArg; if( !hwnd ) { SS_ERROR( "SSW::SSW : NULL hwnd\n" ); return; } bOwnWindow = FALSE; // Get the window size GetWindowSize( hwnd, &size ); gpss->sswTable.Register( hwnd, this ); } /**************************************************************************\ * Reset * * Reset parameters to default init state \**************************************************************************/ void SSW::Reset() { // Basic initialization bOwnWindow = TRUE; iSubWindow = 0; bValidateBg = FALSE; wFlags = 0; hwnd = 0; hdc = 0; hrc = 0; pos.x = pos.y = 0; size.width = size.height = 0; psswParent = NULL; psswSibling = NULL; psswChildren = NULL; bDoubleBuf = FALSE; pStretch = NULL; pMotion = NULL; pGLc = NULL; InitFunc = NULL; UpdateFunc = NULL; ReshapeFunc = NULL; RepaintFunc = NULL; FloaterBounceFunc = NULL; FinishFunc = NULL; ChildSizeFunc = NULL; DataPtr = NULL; } /**************************************************************************\ * SSW destructor * * This can be called when a window is closed, or by the ss client * \**************************************************************************/ SSW::~SSW() { // If this window has any children, they will have to be terminated too if( psswChildren ) { PSSW psswChild = psswChildren; while( psswChild ) { // Delete first child in list if( psswChild->hwnd && bOwnWindow ) { // We created this window, we must destroy it DestroyWindow( psswChild->hwnd ); } else { delete psswChild; } // Next child is now first child in list psswChild = psswChildren; } } if( psswParent ) // Need to remove this pssw from its parent's list psswParent->RemoveChild( this ); if( hwnd ) { // Remove from SSWTable gpss->sswTable.Remove( hwnd ); } else { // subWindow if( psswParent ) { SS_ASSERT1( (psswParent->iSubWindow > 0), "Invalid subWindow reference count for pssw=0x%x\n", this ); psswParent->iSubWindow--; // decrement subWindow reference count } } // Clean up GL if( hrc ) { // FinishFunc still needs gl if( FinishFunc ) (*FinishFunc)( DataPtr ); wglMakeCurrent( NULL, NULL ); if( ! (wFlags & SS_HRC_PROXY_BIT) ) wglDeleteContext( hrc ); } // Clean up any bitmaps if( pStretch ) { SS_BITMAP *pssbm = &pStretch->ssbm; DeleteObject(SelectObject(pssbm->hdc, pssbm->hbmOld)); DeleteDC(pssbm->hdc); } // Release the dc if( hdc ) { HWND hwndForHdc = hwnd ? hwnd : psswParent ? psswParent->hwnd : NULL; ReleaseDC(hwndForHdc, hdc); } } /**************************************************************************\ * AddChild * * Add the supplied child SSW to this SSW. \**************************************************************************/ void SSW::AddChild( PSSW psswChild ) { if( !psswChildren ) { psswChildren = psswChild; return; } // Else travel along the sibling chain of psswChildren and deposit // psswChild at the end PSSW pssw = psswChildren; while( pssw->psswSibling ) pssw = pssw->psswSibling; pssw->psswSibling = psswChild; } /**************************************************************************\ * RemoveChild * * Remove this child from the parent's list * * Whoever calls this needs to update SSW_TABLE too... \**************************************************************************/ BOOL SSW::RemoveChild( PSSW psswChild ) { if( !psswChildren ) { // Something wrong - this window has no children SS_ERROR( "SSW::RemoveChild : no children\n" ); return FALSE; } PSSW psswPrev; PSSW pssw = psswChildren; while( pssw != NULL ) { if( pssw == psswChild ) { // found it ! if( psswChild == psswChildren ) // The child being removed is the first in the list psswChildren = psswChild->psswSibling; else psswPrev->psswSibling = pssw->psswSibling; return TRUE; } // Move up the pointers psswPrev = pssw; pssw = psswPrev->psswSibling; } SS_ERROR( "SSW::RemoveChild : child not found\n" ); return FALSE; } /**************************************************************************\ * GetWindowSize * \**************************************************************************/ static void GetWindowSize( HWND hwnd, ISIZE *pSize ) { RECT clientRect; GetClientRect( hwnd, &clientRect ); pSize->width = clientRect.right - clientRect.left + 1; pSize->height = clientRect.bottom - clientRect.top + 1; } /**************************************************************************\ * CreateSSWindow * * Create OpenGL floater window. This window floats on top of the screen * saver window, bouncing off each of the screen edges. * * History * Apr. 28, 95 : [marcfo] * - Floater motion characteristics now defined by caller * Aug. 14, 95 : [marcfo] * - Position the window offscreen initially, to workaround a win95 bug * with a corrupted initial clip rect. * \**************************************************************************/ BOOL SSW::CreateSSWindow(HINSTANCE hMainInstance, UINT uStyle, UINT uExStyle , LPCTSTR pszWindowTitle, WNDPROC wndProcArg, LPCTSTR pszClassName, HWND hwndParentOverride ) { IPOINT2D startPos; HWND hwndParent; if( hwndParentOverride ) hwndParent = hwndParentOverride; else hwndParent = psswParent ? psswParent->hwnd : NULL; wndProc = wndProcArg; if( !pMotion ) startPos = pos; else { // Initialize start position off screen to work around win95 screen // validation bug startPos.x = pos.x - psswParent->size.width; startPos.y = pos.y - psswParent->size.height; } hwnd = CreateWindowEx( uExStyle, pszClassName, pszWindowTitle, uStyle, startPos.x, startPos.y, size.width, // width size.height, // height hwndParent, NULL, // menu hMainInstance, (LPVOID) this ); if (!hwnd) { //mf: could still continue here by using sub-windows SS_WARNING( "SSW::CreateSSWindow : CreateWindowEx failure\n" ); return FALSE; } // This window is on its own now if( psswParent ) { SS_ASSERT1( (psswParent->iSubWindow > 0), "Invalid subWindow reference count for pssw=0x%x\n", this ); psswParent->iSubWindow--; // decrement subWindow reference count } ShowWindow(hwnd, SW_SHOW); return TRUE; } /**************************************************************************\ * GetChildInfo * * Call the window's ChildSizeFunc \**************************************************************************/ void SSW::GetChildInfo( ) { if( !ChildSizeFunc ) return; CHILD_INFO childInfo; // Call the client's SizeFunc to get required info (*ChildSizeFunc)( &psswParent->size, &childInfo ); // Pull required values into pssw and validate them size = childInfo.size; ValidateChildSize(); if( !pMotion ) { pos = childInfo.pos; bValidateChildPos(); } else { pMotion->posInc = childInfo.motionInfo.posInc; pMotion->posIncVary = childInfo.motionInfo.posIncVary; pMotion->posIncCur = pMotion->posInc; } } /**************************************************************************\ * ConfigureForGdi * * Creates an hdc for the window * \**************************************************************************/ BOOL SSW::ConfigureForGdi() { if( hdc ) // already configured return TRUE; // Figure window to get hdc from HWND hwndForHdc = hwnd ? hwnd : psswParent ? psswParent->hwnd : NULL; if( !hwndForHdc || !(hdc = GetDC(hwndForHdc)) ) { SS_WARNING( "SSW::ConfigureForGdi failed\n" ); return FALSE; } return TRUE; } /**************************************************************************\ * ConfigureForGL * * Creates a GL rendering context for the specified window * \**************************************************************************/ BOOL SSW::ConfigureForGL( SS_GL_CONFIG *pGLcArg ) { pGLc = pGLcArg; return ConfigureForGL(); } BOOL SSW::ConfigureForGL() { if( hrc ) // Already configured... return TRUE; if( ConfigureForGdi() && (hrc = hrcSetupGL()) ) return TRUE; SS_WARNING( "SSW::ConfigureForGL failed\n" ); return FALSE; } /**************************************************************************\ * hrcSetupGL * * Setup OpenGL. * \**************************************************************************/ #define NULL_RC ((HGLRC) 0) HGLRC SSW::hrcSetupGL() { if( !pGLc ) return NULL_RC; //mf: This routine does not yet fully support logical sub-windows... HGLRC hrc; HDC hgldc; int pfFlags = pGLc->pfFlags; PIXELFORMATDESCRIPTOR pfd = {0}; pStretch = pGLc->pStretch; if( pStretch ) { if( NeedStretchedWindow() ) { // Only need single buffered pixel format pfFlags &= ~SS_DOUBLEBUF_BIT; pfFlags |= SS_BITMAP_BIT; // yup, BOTH window and bitmap need this } else // Turn off stretching pStretch = NULL; } // If preview mode or config mode, don't allow pixel formats that need // the system palette, as this will create much ugliness. if( ss_fPreviewMode() || ss_fConfigMode() ) pfFlags |= SS_NO_SYSTEM_PALETTE_BIT; // If config mode, force a non-accelerated pixel format, as WNDOBJ's // seem to have problems with MCD, ICD. Do the same thing if a // monitor configuration is detected, since only the generic implementation // will work properly in this case on all displays. if( ss_fConfigMode() || (GetSystemMetrics(SM_CMONITORS) > 1) ) pfFlags |= SS_GENERIC_UNACCELERATED_BIT; bDoubleBuf = SS_HAS_DOUBLEBUF( pfFlags ); if( !SSU_SetupPixelFormat( hdc, pfFlags, &pfd ) ) return NULL_RC; // Update pGLc->pfFlags based on pfd returned // !!! mf: klugey, fix after SUR // (for now, the only ones we care about are the generic/accelerated flags) if( (pfd.dwFlags & (PFD_GENERIC_FORMAT|PFD_GENERIC_ACCELERATED)) == PFD_GENERIC_FORMAT ) pGLc->pfFlags |= SS_GENERIC_UNACCELERATED_BIT; if( SSU_bNeedPalette( &pfd ) ) { // Note: even if bStretch, need to set up palette here so they match if( !gpss->pssPal ) { SS_PAL *pssPal; BOOL bTakeOverPalette = ss_fFullScreenMode() ? TRUE : FALSE; // The global palette has not been created yet - do it // SS_PAL creation requires pixel format descriptor for color bit // information, etc. (the pfd is cached in SS_PAL, since for // palette purposes it is the same for all windows) pssPal = new SS_PAL( hdc, &pfd, bTakeOverPalette ); if( !pssPal ) return NULL_RC; // Set approppriate palette manage proc if( ss_fFullScreenMode() ) pssPal->paletteManageProc = FullScreenPaletteManageProc; else // use regular palette manager proc pssPal->paletteManageProc = PaletteManageProc; gpss->pssPal = pssPal; } // Realize the global palette in this window //mf: assume we're realizing in foreground HWND hwndPal = hwnd ? hwnd : psswParent ? psswParent->hwnd : NULL; if( hwndPal ) gpss->pssPal->Realize( hwndPal, hdc, FALSE ); } if( pStretch ) { // Stretch blt mode: For every frame, we'll be doing a StretchBlt // from a DIB to the screen. Need to set up a compatible memdc. SS_BITMAP *pssbm; pssbm = &pStretch->ssbm; pssbm->hdc = CreateCompatibleDC(hdc); if( !pssbm->hdc ) return NULL_RC; ResizeStretch(); // this creates the DIB Section pfFlags = 0; pfFlags |= SS_BITMAP_BIT; if( !SSU_SetupPixelFormat( pssbm->hdc, pfFlags, &pfd ) ) { return NULL_RC; } //mf: this ppfd's palette bits must match the window's !! // If window needs palette, so does bitmap... if( gpss->pssPal ) { SS_PAL *pssPal = gpss->pssPal; extern void ssw_UpdateDIBColorTable( HDC, HDC ); ssw_UpdateDIBColorTable( pssbm->hdc, hdc ); } hgldc = pssbm->hdc; } else { hgldc = hdc; } if( pGLc->hrc ) { // Use the supplied hrc hrc = pGLc->hrc; // Set flag so we don't delete this borrowed hrc when the SSW terminates wFlags |= SS_HRC_PROXY_BIT; } else // Create a new hrc hrc = wglCreateContext(hgldc); if( !hrc || !wglMakeCurrent(hgldc, hrc) ) { SS_WARNING( "SSW::hrcSetupGL : hrc context failure\n" ); return NULL_RC; } if( !hwnd && (bDoubleBuf || pStretch) ) { // enable scissoring glEnable( GL_SCISSOR_TEST ); if( !(pGLc->pfFlags & SS_GENERIC_UNACCELERATED_BIT) ) { // MCD or ICD, possible hardware implementation - we maintain // a lastRect to handle SwapBuffer issues lastRect.x = lastRect.y = lastRect.width = lastRect.height = 0; } } SS_DBGLEVEL2( SS_LEVEL_INFO, "SSW::hrcSetupGL: wglMakeCurrent( hrc=0x%x, hwnd=0x%x )\n", hrc, hwnd ); //mf: Note that these queries are based on a single gl window screen saver. In // a more complicated scenario, these capabilities could be queried on a // per-window basis (since support could vary with pixel formats). // Query the GL version - sets support for any new (e.g. 1.1) functionality ss_QueryGLVersion(); // Query paletted texture extension ss_QueryPalettedTextureEXT(); // Query the AddSwapHintRect WIN extension ss_QueryAddSwapHintRect(); // Pull in any Func's that were already defined (for compatibility with // old mechanism) InitFunc = gInitFunc; UpdateFunc = gUpdateFunc; ReshapeFunc = gReshapeFunc; RepaintFunc = gRepaintFunc; FloaterBounceFunc = gFloaterBounceFunc; FinishFunc = gFinishFunc; DataPtr = gDataPtr; return hrc; } /**************************************************************************\ * MakeCurrent * * Call wglMakeCurrent for this window's hrc. Note: an ss client may have * more than one hrc (e.g. pipes), in which case it is the client's * responsibility to make current. \**************************************************************************/ void SSW::MakeCurrent() { if( ! wglMakeCurrent( hdc, hrc ) ) { SS_WARNING( "SSW::MakeCurrent : wglMakeCurrent failure\n" ); } } /**************************************************************************\ * InitGL * * Call the window's GL Init Func * * Priority is raised to expedite any initialization (e.g. loading and * processing textures can take a while. * * A Reshape msg is sent to the client ss, as this is required for setting * glViewport, etc. \**************************************************************************/ void SSW::InitGL() { PSSW psswChild = psswChildren; // Configure the window for GL if pGLc non-NULL if( pGLc && (! ConfigureForGL()) ) { // This is fatal for this window - if it is the main window, // the ss will terminate if( hwnd ) PostMessage( hwnd, WM_CLOSE, 0, 0l ); return; } // If window configured for GL, hrc will have been set... // Call the InitFunc if( hrc && InitFunc ) { DWORD oldPriority; // Bump up priority during initialization phase oldPriority = GetPriorityClass( GetCurrentProcess() ); SetPriorityClass( GetCurrentProcess(), HIGH_PRIORITY_CLASS ); SS_DBGLEVEL1( SS_LEVEL_INFO, "SSW::InitGL: Calling client GLInit for 0x%x\n", hwnd ); (*InitFunc)( DataPtr ); // restore original priority SetPriorityClass( GetCurrentProcess(), oldPriority ); } /* Send another Reshape, since initial one triggered by window * creation would have been received before GL init'd */ Reshape(); // Next, init any child windows. This has to be done after the parent // window initialization. while( psswChild ) { if( psswChild->hwnd ) SendMessage( psswChild->hwnd, SS_WM_INITGL, 0, 0 ); else // Must be a logical sub-window psswChild->InitGL(); psswChild = psswChild->psswSibling; } } /**************************************************************************\ * ResizeStretch * * Resize the compatible bitmap for stretch blt mode * * There are 2 sizing modes. If bRatioMode, then we set the bitmap size * by dividing the window dimensions by the supplied ratios. In this case, * the base* values set a lower limit for the bitmap dimensions. Otherwise, the * base* values determine the bitmap dimensions. * * Feb. 12, 96 : [marcfo] * \**************************************************************************/ void SSW::ResizeStretch() { RECT rc; HBITMAP hbmNew; PVOID pvBits; int width, height; int cwidth, cheight; // client area size SS_BITMAP *pssbm = &pStretch->ssbm; cwidth = size.width; cheight = size.height; if( pStretch->bRatioMode ) { width = (int) ( (float)cwidth / pStretch->widthRatio ); height = (int) ( (float)cheight / pStretch->heightRatio ); if( width < pStretch->baseWidth ) width = pStretch->baseWidth; if( height < pStretch->baseHeight ) height = pStretch->baseHeight ; } else { width = pStretch->baseWidth; height = pStretch->baseHeight; } // Limit width, height to window dimensions if( width > cwidth ) width = cwidth; if( height > cheight ) height = cheight; // If same size, get out if( (width == pssbm->size.width) && (height == pssbm->size.height) ) return; pssbm->size.width = width; pssbm->size.height = height; #if 1 // Use system palette hbmNew = SSDIB_CreateCompatibleDIB(hdc, NULL, width, height, &pvBits); #else // Use log palette hbmNew = SSDIB_CreateCompatibleDIB(hdc, gpss->pssPal ? gpss->pssPal->hPal : NULL, width, height, &pvBits); #endif if (hbmNew) { if (pssbm->hbm != (HBITMAP) 0) { SelectObject( pssbm->hdc, pssbm->hbmOld ); DeleteObject( pssbm->hbm ); } pssbm->hbm = hbmNew; pssbm->hbmOld = (HBITMAP) SelectObject( pssbm->hdc, pssbm->hbm ); } } /**************************************************************************\ * Resize * * Resize wrapper * * Called in response to WM_SIZE. * \**************************************************************************/ void SSW::Resize( int width, int height ) { size.width = width; size.height = height; if( pStretch ) { // May have to resize associated bitmap ResizeStretch(); } if( psswChildren ) { // May need to resize any children PSSW pssw = psswChildren; while( pssw ) { // Get new size/motion for the floater pssw->GetChildInfo(); pssw->SetSSWindowPos(); if( !pssw->hwnd ) { // Handle sub-window case // Need to call Reshape, since win32 system won't send WM_SIZE. pssw->Reshape(); } pssw = pssw->psswSibling; } } Reshape(); } /**************************************************************************\ * Repaint * * Repaint wrapper * * Called in response to WM_PAINT. * \**************************************************************************/ #define NULL_UPDATE_RECT( pRect ) \ ( ((pRect)->left == 0) && \ ((pRect)->right == 0) && \ ((pRect)->top == 0) && \ ((pRect)->bottom == 0) ) void SSW::Repaint( BOOL bCheckUpdateRect ) { if( !hwnd ) return; RECT rect, *pRect = NULL; if( bCheckUpdateRect ) { GetUpdateRect( hwnd, &rect, FALSE ); // mf: Above supposed to return NULL if rect is all 0's, // but this doesn't happen if( NULL_UPDATE_RECT( &rect ) ) return; pRect = ▭ } if( RepaintFunc ) (*RepaintFunc)( pRect, DataPtr ); } /**************************************************************************\ * NeedStretchedWindow * * Check if stretch mode is necessary * \**************************************************************************/ BOOL SSW::NeedStretchedWindow() { if( (pStretch->baseWidth >= size.width) && (pStretch->baseHeight >= size.height) ) { return FALSE; } return TRUE; } /**************************************************************************\ * SetSSWindowPos * * Set new size and position for an SSW * \**************************************************************************/ void SSW::SetSSWindowPos() { SetSSWindowPos( 0 ); } void SSW::SetSSWindowPos( int flags ) { if( hwnd ) { SetWindowPos(hwnd, 0, pos.x, pos.y, size.width, size.height, SWP_NOCOPYBITS | SWP_NOZORDER | SWP_NOACTIVATE | flags ); // Note: If flags does not specify SWP_NOREDRAW, this generates a WM_PAINT // msg for the entire window region } else if( psswParent && !pStretch ) { // Set viewport for new position // (mf: if pStretch, shouldn't need to do anything, as viewport should // have been already set to the bitmap) int posy = GLPosY(); glViewport( pos.x, posy, size.width, size.height ); glScissor( pos.x, posy, size.width, size.height ); glAddSwapHintRect( pos.x, posy, size.width, size.height ); } } /******************************Public*Routine******************************\ * SetAspectRatio * * Resize a child window to conform to the supplied aspect ratio. We do this by * maintaining the existing width, and adjusting the height. * * Window resize seems to be executed synchronously, so gl should be able to * immediately validate its buffer dimensions (we count on it). * * Returns TRUE if new height is different from last, else FALSE. \**************************************************************************/ BOOL SSW::SetAspectRatio( FLOAT fAspect ) { if( !psswParent ) return FALSE; int oldHeight; UINT uFlags = 0; // Check for zero fAspect if( fAspect == 0.0f ) fAspect = 1.0f; oldHeight = size.height; // Set the new height, based on desired aspect ratio size.height = (int) ((FLOAT) size.width / fAspect); // make sure new height not TOO big! ValidateChildSize(); if( size.height == oldHeight ) // no change return FALSE; // make sure current position still valid when height changes if( !bValidateChildPos() ) { // current position OK, don't need to move it uFlags |= SWP_NOMOVE; } SetSSWindowPos( uFlags ); // ! remember not to call the client's ReshapeFunc here, as SetAspectRatio // may be called by the client in response to a window resize, resulting in // an infinite loop //mf: but if there is no size change (above) we return, avoiding the // infinite loop if( !hwnd ) // Need to call Reshape, since win32 system won't send WM_SIZE. Need // to fix to avoid possible infinite loops Reshape(); return TRUE; } /**************************************************************************\ * CalcNextWindowPos * * Calculate the next position for a moving window, using the pMotion data. * If the new position would cause the window to bounce off the * edge of its parent, return TRUE. * \**************************************************************************/ BOOL SSW::CalcNextWindowPos() { POINT2D *fpos = &pMotion->pos; IPOINT2D *ipos = &pos; POINT2D *posInc = &pMotion->posInc; POINT2D *posIncV = &pMotion->posIncVary; POINT2D *posIncCur = &pMotion->posIncCur; BOOL bounce = FALSE; if( !psswParent ) return FALSE; // Compute the next window position. fpos->x += posIncCur->x; fpos->y += posIncCur->y; ipos->x = (int) fpos->x; ipos->y = (int) fpos->y; if ( (ipos->x + size.width) > psswParent->size.width) { // Right hit ipos->x = psswParent->size.width - size.width; fpos->x = (float) ipos->x; posIncCur->x = - ss_fRand( posInc->x - posIncV->x, posInc->x + posIncV->x ); if( posIncCur->x > -0.5f ) posIncCur->x = -0.5f; bounce = TRUE; } else if (ipos->x < 0) { // Left hit ipos->x = 0; fpos->x = 0.0f; posIncCur->x = ss_fRand( posInc->x - posIncV->x, posInc->x + posIncV->x ); if( posIncCur->x < 0.5f ) posIncCur->x = 0.5f; bounce = TRUE; } if ( (ipos->y + size.height) > psswParent->size.height) { // Bottom hit ipos->y = psswParent->size.height - size.height; fpos->y = (float) (ipos->y); posIncCur->y = - ss_fRand( posInc->y - posIncV->y, posInc->y + posIncV->y ); if( posIncCur->y > -0.5f ) posIncCur->y = -0.5f; bounce = TRUE; } else if (ipos->y < 0) { // Top hit ipos->y = 0; fpos->y = 0.0f; posIncCur->y = ss_fRand( posInc->y - posIncV->y, posInc->y + posIncV->y ); if( posIncCur->y < 0.5f ) posIncCur->y = 0.5f; bounce = TRUE; } return bounce; } /**************************************************************************\ * MoveSSWindow * * This is the function that moves the OpenGL window around, causing it to * bounce around. Each time the window is moved, the contents of the * window are updated from the hidden (or back) buffer by SwapBuffers(). * * The bRedrawBg flag determines whether the area that was covered by the old * position should be updated by the parent window. * \**************************************************************************/ void SSW::MoveSSWindow( BOOL bRedrawBg ) { BOOL bounce; int flags = SWP_NOSIZE; // Synchronize with OpenGL. Flush OpenGL commands and wait for completion. glFinish(); // Move the window bounce = CalcNextWindowPos(); if( bounce && FloaterBounceFunc ) // The window bounced off one of the sides // ! This function should *not* be used for rendering - for // informational purposes only (.e.g. changing the spin of a // rotating object). (*FloaterBounceFunc)( DataPtr ); if( !bRedrawBg ) flags |= SWP_NOREDRAW; SetSSWindowPos( flags ); } /**************************************************************************\ * UpdateWindow * * Update the window * * Ccurrently this assumes all windows are being animated (i.e. not showing * a static image) * * Things *must* happen in the order defined here, so they work on generic as * well as hardware implementations. * Note: Move must happen after SwapBuf, and will cause some encroaching on * the current display, as the parent window repaints after the move. Therefore * apps must take care to leave an empty border around their rendered image, * equal to the maximum window move delta. * \**************************************************************************/ void SSW::UpdateWindow() { // update any children first PSSW pssw = psswChildren; while( pssw ) { pssw->UpdateWindow(); pssw = pssw->psswSibling; } //mf: semi-kluge // If this window is a subWindow in a non-generic implementation, the // background of the parent may be invalid (this may eventually be // useful for regular windows, which is why we don't && !hwnd) if( psswParent && psswParent->bValidateBg && pGLc && !(pGLc->pfFlags & SS_GENERIC_UNACCELERATED_BIT) ) { // Clear the entire parent window // mf: I think this is only needed for double-buffered schemes, since // the windowing system should repaint the front buffer in this case. glDisable( GL_SCISSOR_TEST ); glClear( GL_COLOR_BUFFER_BIT ); glEnable( GL_SCISSOR_TEST ); psswParent->bValidateBg = FALSE; } if( !UpdateFunc ) return; // bDoubleBuf and pStretch should be mutually exclusive... if( bDoubleBuf || pStretch ) { UpdateDoubleBufWin(); } else { //mf: ? where's the clearing here ? (true, no one uses this path...) if( pMotion ) MoveSSWindow( TRUE ); (*UpdateFunc)( DataPtr ); } } /**************************************************************************\ * UpdateDoubleBufWin * * This is used when moving a double buffered window around. It will * work for all configurations. * \**************************************************************************/ void SSW::UpdateDoubleBufWin() { if( !hwnd ) { UpdateDoubleBufSubWin(); return; } RECT updateRect; // Move the window if( pMotion ) { // Save child update rect before move GetSSWindowRect( &updateRect ); // Move window, without repainting exposed area MoveSSWindow( FALSE ); } // Update the back buffer (*UpdateFunc)( DataPtr ); if( pMotion ) { // (pMotion will be NULL if this window has no parent) if( hwnd ) { // Paint the exposed area with bg brush (the current image will // be partially erased momentarily, until the SwapBuffers() call // comes through) // (This rect should be clipped to our new window position...) DrawGdiRect( psswParent->hdc, gpss->hbrBg, &updateRect ); } else { //mf: currently this path not possible, since if !hwnd, we use one of the // UpdateDoubleBufSubWin* functions SS_WARNING( "SSW::UpdateDoubleBufWin: no hwnd\n" ); // sub-window case : need to do our own clipping RECT newRect; GetSSWindowRect( &newRect ); DrawGdiDeltaRect( psswParent->hdc, gpss->hbrBg, &updateRect, &newRect ); } } // Swap to the new window position SwapSSBuffers(); } /**************************************************************************\ * UpdateDoubleBufSubWin * * Used for generic double buffered gl sub-windows. * \**************************************************************************/ void SSW::UpdateDoubleBufSubWin() { GLRECT curRect, newRect; // AddSwapHintRect for current position glAddSwapHintRect( pos.x, GLPosY(), size.width, size.height ); if( pMotion ) { // Save current rect curRect.x = pos.x; curRect.y = GLPosY(); curRect.width = size.width; curRect.height = size.height; // Move window, without repainting exposed area MoveSSWindow( FALSE ); // Get new rect newRect.x = pos.x; newRect.y = GLPosY(); newRect.width = size.width; newRect.height = size.height; DrawGLDeltaRect( &curRect, &newRect ); // Have to consider previous rect for ICD or MCD if( !(pGLc->pfFlags & SS_GENERIC_UNACCELERATED_BIT) ) { DrawGLDeltaRect( &lastRect, &newRect ); lastRect = curRect; } // Reset scissor to new rect (this *was* set by MoveSSWindow, but // DrawGLDeltaRect sets scissor to do its clearing glScissor( newRect.x, newRect.y, newRect.width, newRect.height ); } // Update the back buffer (*UpdateFunc)( DataPtr ); // Swap to the new window position SwapSSBuffers(); } /******************************Public*Routine******************************\ * RandomWindowPos * * Sets a new random window position and motion * \**************************************************************************/ void SSW::RandomWindowPos() { if( psswParent ) { if( !hwnd ) { // sub-window : manually clear old window rect if( bDoubleBuf ) { glClear( GL_COLOR_BUFFER_BIT ); } else { RECT oldRect; GetSSWindowRect( &oldRect ); DrawGdiRect( psswParent->hdc, gpss->hbrBg, &oldRect ); } } // Calc and set new position pos.x = ss_iRand2( 0, (psswParent->size.width - size.width) ); pos.y = ss_iRand2( 0, (psswParent->size.height - size.height) ); SetSSWindowPos( SWP_NOSIZE ); // Reset motion if( pMotion ) ResetMotion(); } } /**************************************************************************\ * ResetMotion * * Calculate a random position and motion vector for the floater window * Note that a floating point position is maintained for DDA window movement * \**************************************************************************/ void SSW::ResetMotion() { if( !psswParent || !pMotion ) // Only child windows can be reset return; // Set floating point pos also, for DDA pMotion->pos.x = (float) pos.x; pMotion->pos.y = (float) pos.y; // also reset the window motion directions if( ss_iRand(2) ) // 0 or 1 pMotion->posIncCur.x = - pMotion->posIncCur.x; if( ss_iRand(2) ) pMotion->posIncCur.y = - pMotion->posIncCur.y; } /**************************************************************************\ * ValidateChildSize * * Make sure it's not bigger than its parent * \**************************************************************************/ void SSW::ValidateChildSize() { if( !psswParent ) return; SS_CLAMP_TO_RANGE2( size.width, 0, psswParent->size.width ); SS_CLAMP_TO_RANGE2( size.height, 0, psswParent->size.height ); } /**************************************************************************\ * bValidateChildPos * * Make sure that with the current window position, none of the floating * window extends beyond the parent window. * \**************************************************************************/ BOOL SSW::bValidateChildPos() { BOOL bRet = FALSE; if( !psswParent ) return FALSE; if ( (pos.x + size.width) > psswParent->size.width) { pos.x = psswParent->size.width - size.width; bRet = TRUE; } if ( (pos.y + size.height) > psswParent->size.height) { pos.y = psswParent->size.height - size.height; bRet = TRUE; } return bRet; } /**************************************************************************\ * GetSSWindowRect * * Return window position and size in supplied RECT structure * * mf: this rect is relative to the parent \**************************************************************************/ void SSW::GetSSWindowRect( LPRECT lpRect ) { lpRect->left = pos.x; lpRect->top = pos.y; lpRect->right = pos.x + size.width; lpRect->bottom = pos.y + size.height; } /**************************************************************************\ * GLPosY * * Return y-coord of window position in GL coordinates (a win32 window position * (starts from top left, while GL starts from bottom left) * \**************************************************************************/ int SSW::GLPosY() { if( !psswParent ) return 0; return psswParent->size.height - size.height - pos.y; } /**************************************************************************\ * SwapStretchBuffers * * Swaps from the stretch buffer to the GL window, using StretchBlt * \**************************************************************************/ void SSW::SwapStretchBuffers() { SS_BITMAP *pssbm = &pStretch->ssbm; if( (size.width == pssbm->size.width) && (size.height == pssbm->size.height) ) // buffers same size { BitBlt(hdc, 0, 0, size.width, size.height, pssbm->hdc, 0, 0, SRCCOPY); } else { StretchBlt(hdc, 0, 0, size.width, size.height, pssbm->hdc, 0, 0, pssbm->size.width, pssbm->size.height, SRCCOPY); } GdiFlush(); } /**************************************************************************\ * SwapBuffers * * Wrapper for SwapBuffers / SwapStretchBuffers * \**************************************************************************/ void SSW::SwapSSBuffers() { if( pStretch ) SwapStretchBuffers(); else if( bDoubleBuf ) { SwapBuffers( hdc ); } } /**************************************************************************\ * Reshape * * Reshape wrapper * Sends reshape msg to screen saver * This is the size of the surface that gl renders onto, which can be a bitmap. * \**************************************************************************/ void SSW::Reshape() { // Point to size of window, or bitmap if it has one ISIZE *pSize = &size; if( pStretch ) pSize = &pStretch->ssbm.size; // If the window has an hrc, set default viewport if( hrc ) { if( hwnd ) glViewport( 0, 0, pSize->width, pSize->height ); else if ( psswParent ) { // sub-window (only 1 level of sub-windowing supported) //mf: klugey ? - should take into account non-GL and single buffer... #if 1 // clear entire window to black glDisable( GL_SCISSOR_TEST ); glClear( GL_COLOR_BUFFER_BIT ); glEnable( GL_SCISSOR_TEST ); #endif // Convert win32 y-coord to GL glViewport( pos.x, GLPosY(), pSize->width, pSize->height ); } } if( ReshapeFunc ) { (*ReshapeFunc)( pSize->width, pSize->height, DataPtr ); } } /******************************Public*Routine******************************\ * GdiClear * * Clears window using Gdi FillRect \**************************************************************************/ void SSW::GdiClear() { if( !hdc ) return; RECT rect; //mf: this should use GetClientRect GetSSWindowRect( &rect ); FillRect( hdc, &rect, gpss->hbrBg ); GdiFlush(); } /******************************Public*Routine******************************\ * MyAddSwapHintRect * \**************************************************************************/ static void _stdcall MyAddSwapHintRect(GLint xs, GLint ys, GLint xe, GLint ye) { return; } /******************************Public*Routine******************************\ * QueryAddSwapHintRectWIN * \**************************************************************************/ static void ss_QueryAddSwapHintRect() { glAddSwapHintRect = (PFNGLADDSWAPHINTRECTWINPROC) wglGetProcAddress("glAddSwapHintRectWIN"); if (glAddSwapHintRect == NULL) { glAddSwapHintRect = MyAddSwapHintRect; } } /******************************Public*Routine******************************\ * DrawGdiDeltaRect * * Draw the exposed area by transition from rect1 to rect2 \**************************************************************************/ static void DrawGdiDeltaRect( HDC hdc, HBRUSH hbr, RECT *pRect1, RECT *pRect2 ) { if( (pRect1 == NULL) || (pRect2 == NULL) ) { SS_WARNING( "DrawGdiDeltaRect : one or both rects are NULL\n" ); return; } // Draw 2 rects RECT rect; // Rect exposed in x-direction: rect.top = pRect1->top; rect.bottom = pRect1->bottom; if( pRect2->left > pRect1->left ) { // moving right rect.left = pRect1->left; rect.right = pRect2->left; } else { // moving left rect.left = pRect2->right; rect.right = pRect1->right; } FillRect( hdc, &rect, hbr ); // Rect exposed in y-direction: rect.left = pRect1->left; rect.right = pRect1->right; if( pRect2->bottom > pRect1->bottom ) { // moving down rect.top = pRect1->top; rect.bottom = pRect2->top; } else { // moving up rect.top = pRect2->bottom; rect.bottom = pRect1->bottom; } FillRect( hdc, &rect, hbr ); GdiFlush(); } /******************************Public*Routine******************************\ * DrawGLDeltaRect * * Draw the exposed area by transition from rect1 to rect2 \**************************************************************************/ static void DrawGLDeltaRect( GLRECT *pRect1, GLRECT *pRect2 ) { if( (pRect1 == NULL) || (pRect2 == NULL) ) { SS_WARNING( "DrawGLDeltaRect : one or both rects are NULL\n" ); return; } // Draw 2 rects : //mf: !!! this assumes rect1 and rect2 have same dimensions ! GLRECT rect; // Rect exposed in x-direction: rect.height = pRect1->height; rect.y = pRect1->y; if( pRect2->x > pRect1->x ) { // moving right rect.width = pRect2->x - pRect1->x; rect.x = pRect1->x; } else { // moving left rect.width = pRect1->x - pRect2->x; rect.x = pRect2->x + pRect2->width; } glScissor( rect.x, rect.y, rect.width, rect.height ); glClear( GL_COLOR_BUFFER_BIT ); // Rect exposed in y-direction: rect.width = pRect1->width; rect.x = pRect1->x; if( pRect2->y > pRect1->y ) { // moving up rect.height = pRect2->y - pRect1->y; rect.y = pRect1->y; } else { // moving down rect.height = pRect1->y - pRect2->y; rect.y = pRect2->y + pRect2->height; } glScissor( rect.x, rect.y, rect.width, rect.height ); glClear( GL_COLOR_BUFFER_BIT ); }