For the full package use glut376dlls_fixed.zip from Michael Wimmer,Thank you!
WimmerGL.zip has also Enhanced WGLInfo-Utility (Wglinfo.zip) - both included.
All GLUT 3.7.6 files are from glut376dlls_fixed.zip (April 22, 2003 - latest)
GLut for viewing already installed for this driver, these are to code/compile
glut376dlls_fixed.zip GLUT.dll / GLUT32.dll is inside this Driver main folder
Something extra needed?Use package glut376dlls_fixed.zip / glut-3.7.6-bin.zip

CHANGES on April 22, 2003
-------------------------

- FIX: glut.h now works with VC.NET

- FIX: always find a valid HDC (didn't work for multi-display drivers before)

- FIX: do not adjust coordinates for game mode windows

- FIX: extension string is now saved in a static for drivers which deallocate the string

- FIX: do not crash if no extensions are available

Small addition on April 3, 2002: 

- fixed a typo in win32_glx.c which caused GLUT to crash if the WGL_pixel_format extension
  was not present.

CHANGES on March 5, 2002
------------------------

This new version of the GLUT fixes builds upon GLUT version 3.7.6. No previous GLUT
versions are supported.

- CHANGE: the pixelformat index is now consistently stored in the dwDamageMask member 
  instead of dwReserved (which is used for layer planes by Windows)
  
- FEATURE: using glutInitDisplayString, the swap-mode can now be selected using
  "swapmode=1" for buffer flipping (PFD_SWAP_EXCHANGE) or "swapmode=2" for 
  blitting (PFD_SWAP_COPY). Default is don't care (which is buffer flipping usually)
  
- FEATURE: multisample support is now available also for WIN32. Had to massage some
  function to allow for the new WGL_ARB_pixelformat extension to be used. Usage is
  identical to SGI/X
  
- FEATURE: PBuffer support is now available (for WIN32 only). 

  DESCRIPTION: 
  PBuffers are offscreen render buffers in video memory.
  Use the new entry point glutCreateBuffer(), (the name will be ignored). PBuffers are
  almost similar to normal windows (i.e. glutSetWindow() and glutGetWindow() and
  glutDestroyWindow() works on them), but they will never call any callbacks. Support
  is a bit preliminary so be sure not to call any Windows-specific stuff (like
  glutPostRedisplay, glutSetWindowSize, ...) The new Tag
  GLUT_DISPLAY_MODE_POSSIBLE_PBUFFER was added to query whether a selected PBuffer can
  be created, and GLUT_PBUFFER_SUPPORTED can be queried by glutGet().

- FIX: in glut_gamemode.c, the DEVMODE structure was not initialized correctly.
  The docs say that dwSize should be set to sizeof(DEVMODE), not doing this
  might lead to problems.
  
- FIX: completely removed memory leaks associated with fbmode enumeration.
  Framebuffer modes and associated Pixelformats are now deleted immediately
  after use.

- NOTE: from GLUT 3.7.6, WIN32 GLUT builds with a workspace instead of with makefiles.
  I have added glutwin32.mak and makefile.win for convenience.
  
  
CHANGES on December 17, 2001
----------------------------

- BUG: stereo mode cannot be used with glutInitDisplayString (win32_glx.c)
  FIX: corrected the check so the necessary value is 1 and not 2



GLUT 3.7 and 3.7.3 fixes and additions
======================================

WHAT IT IS

Theses files contain some fixes and additions to GLUT I have found useful while
working with it. Some require rebuilding with the included glut.h, for others
it suffices to replace glut32.dll.

The current win32-version of GLUT is 3.7.3 and can be found at
http://www.xmission.com/~nate/glut.html

INSTALLATION

Files for GLUT 3.7 are contained in the directory GLUT37, files for GLUT 3.7.3
are contained in the directory GLUT373.

If you want to use glutCloseFunc and glutUpdateAllWindows, replace
glut.h (whereever you have it) by the one in this package. Then make sure your
application uses the new glut32.dll.

To build your own glut:

Copy the files from lib/glut to your GLUT distribution to lib/glut and build
glut32.dll and glut32.lib as usual.

To just use the precompiled files:

Use glut32.dll and glut32.lib from the appropriate directory. The
debug-directory contains a debug-build with a .pdb-file, the release-directory
contains an optimized version with no debug information.

NEW FEATURES

- FEATURE: support for hardware/software-rendering selection (glut_dstr.c)

  DESCRIPTION:
  To support selection between hardware-accelerated and software-rendering
  visuals, glutInitDisplayString() accepts the "hw"-tag.

  Example:
    glutInitDisplayString("hw=0");
  will force software rendering, while
    glutInitDisplayString("hw=1");
  will force hardware rendering.

  IMPLEMENTATION:
  The default is hardware rendering. Hardware is detected by checking for
  PFD_GENERIC_ACCELERATED (MCD-driver) or !PFD_GENERIC_FORMAT (ICD-driver).

  To support selecting a specific pixelformat, I save the pixelformat index in
  the bReserved-member of the VisualInfo-structure (otherwise, GLUT would
  always use ChoosePixelFormat to select the nearest pixelformat, and not the
  one we
  selected so tediously before).

- FEATURE: Close callback function for each window

  DESCRIPTION:
  To avoid the annoying GLUT behavior of closing the whole application when
  accidentally clicking onto the close button of any open GLUT-window, a per-
  window callback has been implemented that delegates the decision on what to
  do to the application.

  Example:
  void myCloseFunc() { exit(3); }
  glutCloseFunc(myCloseFunc);

  The default behavior if no close callback is specified is to exit the
  application (as it was before).

  NOTE: this is similar to the exitFunc from GLUT 3.7.3, but with more control
  and visible to the application.

- FEATURE: allow glutMainLoop() to be called externally

  DESCRIPTION: This basically implements the fix from
  http://web2.airmail.net/sjbaker1/software/glut_hack.html.
  The problem is twofold:
  * in order to integrate GLUT with another framework (that has its own
  mainloop), the GLUT mainloop must be accessible externally
  * more importantly, some applications require serial interactions with GLUT
  windows (e.g., create a window, render something, read the framebuffer, close
  the window, all within one subroutine) - but GLUT only executes window
  commands in its mainloop.

  Therefore, a function glutUpdateAllWindows() has been implemented. It
  executes the relevant parts of the main loop.

  NOTE: glutUpdateAllWindows() is exactly the same as processWindowWorkLists()
  from glut_event.c in GLUT 3.7.3, but exposed to the application.

- FEATURE: WIN32 makefile updated to produce debug information

  DESCRIPTION: somehow, the supplied makefile did not produce any debug
  information usable by VC++. I brute-forced the debug information by changing
  the link-string in the file "makefile". If you want to use the original
  makefile, use "makefile.win".

CONTAINED FIXES

- BUG: visuals not reloaded on display mode change
  FIX: reload visuals each time they are queried (glut_dstr.c)
  This fixes a problem with Win32 because the list of availabe Visuals
  (Pixelformats) changes after a change in displaymode. The problem occurs when
  switching to gamemode and back.
  NOTE: This fix was folded into GLUT 3.7.6

- BUG: pixelformats enumerated incorrectly (win32_glx.c, line 48)
  FIX: the check tests whether OpenGL is supported OR the visual draws to
  window. Corrected to check for AND.
  NOTE: This fix was folded into GLUT 3.7.6

- BUG: pixelformats enumerated incorrectly - 2 (win32_x11.c)
  FIX: passing 0 as a pixelformat index to DescribePixelFormat gives
  unpredictible results (e.g., this fails on the Voodoo opengl32.dll and always
  reports 0 as the last available pixelformat index).
  In GLUT 3.7, the loop also ignored that indices were 1-based instead of 0-
  based, which resulted in the last pixelformat being ignored.
  NOTE: This fix was folded into GLUT 3.7.6

NOTES

- the makefile for GLUT 3.7.3 contains a reference to the file glut_fbc.c which
does not exit - just delete this reference.


DISCLAIMER

Usual disclaimers apply, and of course GLUT is copyright Mark Kilgard.

CONTACT

For any questions, you can reach me at

wimmer@cg.tuwien.ac.at

Michael Wimmer
Vienna University of Technology
July, 2001

-------------------------------------

Original file name glut-3.7.6-bin.zip

 GLut for viewing already installed for this driver, if needed then
 rename/use glut.dll/glu.dll/opengl.dll, files at c:\windows\system
 From this GLUT3.7.6 package only glut32.dll was taken,now glut.dll
 This is original readme.txt,newer Michael Wimmer GLut 3.7.6 in use
 I
 

                GLUT for Win32 README
                ---------------------


    VERSION/INFO:

    This is GLUT for Win32 version 3.7.6 as of Nov 8th 2001.
    See the COPYRIGHT section for distribution and copyright notices.
    Send all bug reports and questions for this version of GLUT to 
    Nate Robins [nate@pobox.com].

    For more information about GLUT for Win32, see the web page:
    www.pobox.com/~nate/glut.html or subscribe to the GLUT for Win32 
    mailing list by sending e-mail to majordomo@perp.com with 
    "subscribe glut" in the body of the message.

    For general information about GLUT, see the GLUT web page:
    http://reality.sgi.com/opengl/glut3/glut3.html and be sure to
    check the GLUT FAQ first for any questions that you may have:
    http://reality.sgi.com/opengl/glut3/glut-faq.html


COMPILING/INSTALLATION:

    o  Precompiled versions of the DLL and import library can be
       found on the GLUT for Win32 web page mentioned above.

    o  Microsoft Developer Studio 6 workspace and project files have
       been included in the source code distribution.
       
       To build the glut dll: 
       First, open Microsoft Developer Studio.
       Then, select File -> Open Workspace and find the glut.dsw file
       in the file dialog and double-click on it.  
       Finally, select Build -> Build glut32.dll.
       When the build is finished, it will copy:
       glut32.dll to %WinDir%\System, 
       glut32.lib to $(MSDevDir)\..\..\VC98\lib, and 
       glut.h     to $(MSDevDir)\..\..\VC98\include\GL.
       
       Additional workspace files have been included in the progs, test
       and lib directories to build the progs, tests and libs respectively.


BORLAND NOTES:

    From what I understand, Borland supplies a utility that
    converts Microsoft Visual C++ .libs into Borland compatible
    files.  Therefore, the best method for Borland users is
    probably to get the precompiled versions of the library and
    convert the library.  To create an import library for Borland 
    from the DLLs, use the following command (from a command prompt):
          IMPLIB glut32.lib glut32.dll
    If IMPLIB crashes when called this way, try
          IMPLIB glut32.lib glut32.def
    using the glut32.def file in this distribution.


FORTRAN NOTES:

    Bill Mitchell [william.mitchell@nist.gov] has put considerable
    effort into getting GLUT to work with different compilers for
    Fortran 90.  He indicates that you should copy the f90glut.h
    file to your $(MSDevDir)\..\..\VC98\include\GL directory.  
    Then, just build GLUT as usual.  The Fortran 90 interface, f90gl, 
    can be obtained at http://math.nist.gov/f90gl and contains 
    installation instructions and usage examples.


MISC NOTES:

    o  Overlay support is not implemented, nor are there any plans to 
       implement it in the near future.

    o  To customize the windows icon, you can use the resource name
       GLUT_ICON.  For example, create an icon named "glut.ico", and
       create a file called glut.rc that contains the following:
       GLUT_ICON ICON glut.ico
       then compile the glut.rc file with the following:
       rc /r glut
       and link the resulting glut.res file into your executable
       (just like you would an object file).
       Alternatively, you can simply add the glut.rc file to your
       project if you are using Microsoft Developer Studio.


IMPLEMENTATION DEPENDENT DIFFERENCES:

    There are a few differences between the Win32 version of GLUT
    and the X11 version of GLUT.  Those are outlined here.  Note
    that MOST of these differences are allowed by the GLUT
    specification.  Bugs and unsupported features are outlined in
    the UNSUPPORTED/BUGS section.

    o  glutInit:
       The following command line options have no meaning (and are
       ignored) in GLUT for Win32:
       -display, -indirect, -direct, -sync.

    o  glutInitWindowPosition, glutPositionWindow:
       Win32 has two different coordinate systems for windows.
       One is in terms of client space and the other is the whole
       window space (including the decorations).  If you
       glutPositionWindow(0, 0), GLUT for Win32 will place the
       window CLIENT area at 0, 0.  This will cause the window
       decorations (title bar and left edge) to be OFF-SCREEN, but
       it gives the user the most flexibility in positioning.
       HOWEVER, if the user specifies glutInitWindowPosition(0, 0),
       the window is placed relative to window space at 0, 0.
       This will cause the window to be opened in the upper left
       corner with all the decorations showing.  This behaviour is
       acceptable under the current GLUT specification.

    o  glutSetIconTitle, glutSetWindowTitle:
       There is no separation between Icon title and Window title
       in Win32.  Therefore, setting an icon title in Win32 has
       no effect.

    o  glutSetCursor:
       As indicated in the GLUT specification, cursors may be
       different on different platforms.  This is the case in GLUT
       for Win32.  For the most part, the cursors will match the
       meaning, but not necessarily the shape.  Notable exceptions
       are the GLUT_CURSOR_INFO & GLUT_CURSOR_SPRAY which use the
       crosshair cursor and the GLUT_CURSOR_CYCLE which uses the
       'no' or 'destroy' cursor in Win32.

    o  glutVisibilityFunc:
       Win32 seems to be unable to determine if a window is fully
       obscured.  Therefore, the visibility of a GLUT window is
       only reflected by its Iconic, Hidden or Shown state.  That
       is, even if a window is fully obscured, in GLUT for Win32,
       it is still "visible".

    o  glutEntryFunc:
       Window Focus is handled differently in Win32 and X.
       Specifically, the "window manager" in Win32 uses a "click to
       focus" policy.  That is, in order for a window to receive
       focus, a mouse button must be clicked in it.  Likewise, in
       order for a window to loose focus, a mouse button must be
       clicked outside the window (or in another window).
       Therefore, the Enter and Leave notification provided by GLUT
       may behave differently in the Win32 and in X11 versions.
       There is a viable workaround for this.  A program called
       "Tweak UI" is provided by Microsoft which can be used to
       change the focus policy in Win32 to "focus follows mouse".
       It is available from the Microsoft Web Pages:
       http://www.microsoft.com/windows/software/PowerToy.htm

    o  glutCopyColormap:
       GLUT for Win32 always copies the colormap.  There is never
       any sharing of colormaps.  This is probably okay, since
       Win32 merges the logical palette and the physical palette
       anyway, so even if there are two windows with totally
       different colors in their colormaps, Win32 will find a
       (hopefully) good match between them.

    o  glutIdleFunc + menus:
       The glut idle function will NOT be called when a menu is
       active.  This causes all animation to stop when a menu is
       active (in general, this is probably okay).  Timer
       functions will still fire, however.  If the timer callback
       draws into the rendering context, the drawing will not show
       up until after the menu has finished, though.


UNSUPPORTED/BUGS:

    o  glutAttachMenu:
       Win32 only likes to work with left and right mouse buttons.
       Especially so with popup menus.  Therefore, when attaching
       the menu to the middle mouse button, the LEFT mouse button
       must be used to select from the menu.

    o  glutSpaceball*, glutButtonBox*, glutTablet*, glutDials*:
       None of the special input devices are supported at this
       time.

    o  When resizing or moving a GLUT for Win32 window, no updating
       is performed.  This causes the window to leave "tracks" on
       the screen when getting bigger or when previously obscured
       parts are being revealed.  I put in a bit of a kludgy
       workaround for those that absolutely can't have the weird
       lines.  The reshape callback is called multiple times for
       reshapes.  Therefore, in the reshape callback, some drawing
       can be done.  It should probably be limited to a color buffer 
       clear.

    o  The video resizing capabilities of GLUT 3.3+ for X11 is
       currently unimplemented (this is probably ok, since it
       really isn't part of the spec until 4.0).  I doubt that
       this will ever be part of GLUT for Win32, since there is no
       hardware to support it.  A hack could simply change the
       resolution of the desktop.


THANKS:

    Special thanks to the following people for extensive testing, 
    suggestions, fixes and help:

    Alexander Stohr
    Shane Clauson
    Kenny Hoff
    Richard Readings
    Paul McQuesten
    Philip Winston
    JaeWoo Ahn
    Joseph Galbraith
    Paula Higgins
    Sam Fortin
    Chris Vale
    Bill Mitchell

    and of course, the original author of GLUT:
    Mark Kilgard.

    and many others...


COPYRIGHT:

The OpenGL Utility Toolkit distribution for Win32 (Windows NT &
Windows 95) contains source code modified from the original source
code for GLUT version 3.3 which was developed by Mark J. Kilgard.  The
original source code for GLUT is Copyright 1997 by Mark J. Kilgard.
GLUT for Win32 is Copyright 1997 by Nate Robins and is not in the
public domain, but it is freely distributable without licensing fees.
It is provided without guarantee or warrantee expressed or implied.
It was ported with the permission of Mark J. Kilgard by Nate Robins.

THIS SOURCE CODE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OR MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.

OpenGL (R) is a registered trademark of Silicon Graphics, Inc.