Metadata-Version: 1.1
Name: glfw
Version: 1.9.1
Summary: A ctypes-based wrapper for GLFW3.
Home-page: https://github.com/FlorianRhiem/pyGLFW
Author: Florian Rhiem
Author-email: florian.rhiem@gmail.com
License: MIT
Description: pyGLFW
        ======
        
        This module provides Python bindings for `GLFW <http://www.glfw.org/>`__
        (on GitHub: `glfw/glfw <http://github.com/glfw/glfw>`__). It is a
        ``ctypes`` wrapper which keeps very close to the original GLFW API,
        except for:
        
        -  function names use the pythonic ``words_with_underscores`` notation
           instead of ``camelCase``
        -  ``GLFW_`` and ``glfw`` prefixes have been removed, as their function
           is replaced by the module namespace
           (you can use ``from glfw.GLFW import *`` if you prefer the naming
           convention used by the GLFW C API)
        -  structs have been replaced with Python sequences and namedtuples
        -  functions like ``glfwGetMonitors`` return a list instead of a pointer
           and an object count
        -  Gamma ramps use floats between 0.0 and 1.0 instead of unsigned shorts
           (use ``glfw.NORMALIZE_GAMMA_RAMPS=False`` to disable this)
        -  GLFW errors are reported as ``glfw.GLFWError`` exceptions if no error
           callback is set (use ``glfw.ERROR_REPORTING=False`` to disable this)
        -  instead of a sequence for ``GLFWimage`` structs, PIL/pillow ``Image``
           objects can be used
        
        Installation
        ------------
        
        pyGLFW can be installed using pip:
        
        .. code:: sh
        
            pip install glfw
        
        Windows
        ~~~~~~~
        
        The GLFW shared library and Visual C++ runtime are included in the Python wheels.
        
        To use a different GLFW library, you can set ``PYGLFW_LIBRARY`` to its location.
        
        macOS
        ~~~~~
        
        The GLFW shared library for 64-bit is included in the Python wheels for macOS.
        
        If you are using a 32-bit Python installation or otherwise cannot use the
        library downloaded with the wheel, please follow the steps for Linux below, to
        build and install GLFW yourself, then place it in one of the library search
        paths or set ``PYGLFW_LIBRARY`` to the location of the library.
        
        Linux
        ~~~~~
        
        You will need to install the GLFW shared library yourself and should
        `compile GLFW from source <http://www.glfw.org/docs/latest/compile.html>`__
        (use ``-DBUILD_SHARED_LIBS=ON``).
        
        pyGLFW will search for the library in a list of search paths (including those
        in ``LD_LIBRARY_PATH``). If you
        want to use a specific library, you can set the ``PYGLFW_LIBRARY`` environment
        variable to its path.
        
        Example Code
        ------------
        
        The example from the `GLFW
        documentation <http://www.glfw.org/documentation.html>`__ ported to
        pyGLFW:
        
        .. code:: python
        
            import glfw
        
            def main():
                # Initialize the library
                if not glfw.init():
                    return
                # Create a windowed mode window and its OpenGL context
                window = glfw.create_window(640, 480, "Hello World", None, None)
                if not window:
                    glfw.terminate()
                    return
        
                # Make the window's context current
                glfw.make_context_current(window)
        
                # Loop until the user closes the window
                while not glfw.window_should_close(window):
                    # Render here, e.g. using pyOpenGL
        
                    # Swap front and back buffers
                    glfw.swap_buffers(window)
        
                    # Poll for and process events
                    glfw.poll_events()
        
                glfw.terminate()
        
            if __name__ == "__main__":
                main()
        
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Environment :: MacOS X
Classifier: Environment :: X11 Applications
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 3
Classifier: Topic :: Multimedia :: Graphics
Classifier: Topic :: Scientific/Engineering :: Visualization
