Metadata-Version: 2.1
Name: piefish
Version: 0.1.9a0
Summary: A 2D graphics API that mimics the Processing API
Home-page: http://github.com/pb2002/PyVis
Author: Pepijn Bakker
Author-email: bakker.pepijn@gmail.com
License: MIT
Description: # PieFish
        
        PieFish is a 2D graphics API that mimics the Processing API.
        
        ## Installation
        
        1. [Download the repository as a .zip file.](https://github.com/pb2002/PyVis/archive/master.zip)  
        OR use pip to install it from PyPI (and skip all other installation steps, unless you want to try out the example):
        
            ```Terminal
            pip install piefish
            ```
        
        2. Make sure you've got all of the required pip packages installed:
            * pygame
            * colorama
        
        ## How to use
        
        ### Main script setup
        
        First of all, you need to import piefish:
        
        ```Python
            import piefish
        ```
        
        Note: since all functions for drawing are part of the piefish namespace, you might
        want to use `import piefish as pf` instead.
        
        After that, you can initialize PieFish by calling the 'init()' method:
        
        ```Python
            piefish.init()
        ```
        
        The nice thing about PieFish is that the update loop is already setup for you.
        The only thing you need to do is add your functions to the update loop by adding them
        to a _function pool_.
        
        _Function pools_ are lists of functions that get called
        at a certain point in the kernel loop. For example, the _"draw"-pool_ gets called
        every frame, whilst the _"setup"-pool_ only gets called at the start of the program.
        
        You can add functions to a function pool as follows:
        
        ```Python
        @piefish.kernel.pool("draw", 1)
        def yourFunction():
            # Do something
        
        ```
        
        The number after the name of the draw pool indicates the priority of that function in the pool.
        Functions with a higher priority will be executed before others.
        
        To start the kernel loop, add this line at the end of your main script:
        
        ```Python
        piefish.kernel.run()
        ```
        
        Your final script should look like this:
        
        ```Python
        import piefish as pf
        
        pf.init()
        
        @pf.kernel.pool("setup",1)
        def onSetup():
            # do something
        
        @pf.kernel.pool("draw",1)
        def onDraw():
            # do something
        
        pf.kernel.run()
        ```
        
        All functionality is included in the example, and you can use it as a reference to create your
        own application.
        
        ---
        ## PieFish 0.1.9a
        
        ### Change log
        * Changed all occurences of pyvis to piefish. That's all.
        
        ## PieFish 0.1.8a
        
        ### Change log
        
        * PieFish is now a PyPI package!
        * Renamed package to PieFish to remove name conflicts (I had to come up with something..)
        * Some other minor stuff
        
        ### Hotfixes
        
        1. 0.1.8a1
            * updated this file
        2. 0.1.8a2-a4
        	* very minor details including this file
        
        ## PieFish 0.1.5a
        
        ### Change log
        
        * Further improvements in kernel loop.
        * Added splash screen.
        * Expanded functionality in fps monitoring.
        * Improved and added log messages.
        * Command line colors! :D
        
        ---
        
        ## PieFish 0.1.3a
        
        ### Change log
        
        * Improved kernel loop performance.
        * Fullscreen now works properly.
        
        ---
        
Platform: UNKNOWN
Description-Content-Type: text/markdown
