Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/kikito/love-loader
Threaded resource loading for LÖVE
https://github.com/kikito/love-loader
lua
Last synced: 4 days ago
JSON representation
Threaded resource loading for LÖVE
- Host: GitHub
- URL: https://github.com/kikito/love-loader
- Owner: kikito
- License: mit
- Created: 2012-01-29T00:26:13.000Z (almost 13 years ago)
- Default Branch: master
- Last Pushed: 2023-10-15T15:33:32.000Z (about 1 year ago)
- Last Synced: 2024-10-20T10:23:33.263Z (16 days ago)
- Topics: lua
- Language: Lua
- Homepage: http://love2d.org
- Size: 8.39 MB
- Stars: 131
- Watchers: 12
- Forks: 16
- Open Issues: 6
-
Metadata Files:
- Readme: README.md
- License: MIT-LICENSE.txt
Awesome Lists containing this project
- awesome-love2d - love-loader - Threaded resource loading. (Utilities)
README
love-loader
===========This is an utility lib for [LÖVE](http://love2d.org) that loads
resources (images, sounds) from the hard disk on a separate thread.This allows for "doing stuff" while resources are being loaded; for
example, playing an animation. The fact that the blocking calls happen
in a separate thread ensures that the animation is fluid, without
blocking calls dropping the framerate.Version 2.0.0 of this lib only works with LÖVE 0.9.x. If you need to
work with LÖVE 0.8 or before, please use earlier versions of this lib.This repository is maintained by Tanner Rogalsky (https://github.com/TannerRogalsky).
Example
=======```lua
local loader = require 'love-loader'local images = {}
local sounds = {}local finishedLoading = false
function love.load()
loader.newImage( images, 'rabbit', 'path/to/rabbit.png')
loader.newSource( sounds, 'iiiik', 'path/to/iiik.ogg', 'static')
loader.newSource( sounds, 'music', 'path/to/music.ogg', 'stream')loader.start(function()
finishedLoading = true
end)
endfunction love.update(dt)
if not finishedLoading then
loader.update() -- You must do this on each iteration until all resources are loaded
end
endfunction love.draw()
if finishedLoading then
-- media contains the images and sounds. You can use them here safely now.
love.graphics.draw(images.rabbit, 100, 200)
else -- not finishedLoading
local percent = 0
if loader.resourceCount ~= 0 then percent = loader.loadedCount / loader.resourceCount end
love.graphics.print(("Loading .. %d%%"):format(percent*100), 100, 100)
end
end
```You can also see a working demo in the
[demo branch of this repo](https://github.com/kikito/love-loader/tree/demo).Interface
=========* `loader.newImage(holder, key, path)`. Adds a new image to the list
of images to load.
* `loader.newSource(holder, key, path, sourceType)`. Adds a new source
to the list of sources to load.
* `loader.newFont(holder, key, path)`. Adds a new font to the list of
fonts to load.
* `loader.start(finishCallback, loadedCallback)`. Starts doing the
loading on a separate thread. When it finishes, it invokes
`finishCallback` with no parameters. Every time it loads a new
resource, it invokes `loadedCallback`. `finishedCallback` admits no
parameters, and `loadedCallback`'s signature is
`function(kind, holder, key)`. `kind` is a string ("image", "source"
or "stream"). Neither `loadedCallback` or `finishedCallback` are
mandatory.
* `loader.loadedCount` integer returning the number of resources
loaded. When `loader.start` gets invoked, it's 0.
* `loader.resourceCount` integer containing the total number of
resources to be loaded. It can be used in conjunction with
`loader.loadedCount` to show progressbars etc.Installation
============Just copy the love-loader.lua file somewhere in your projects (maybe
inside a /lib/ folder) and require it accordingly.Remember to store the value returned by require somewhere! (I suggest a
local variable named `loader` or `love.loader`)```lua
local loader = require 'love-loader'
```The second step is making sure that your "game loop" calls
`loader.update`, at least while there are resources to load.License
=======This library is distributed under the MIT License.
Credits
=======I took a lot of inspiration from Michael Enger's Stealth2D project. I
learned the basic internals of threads from his loading state code.https://github.com/michaelenger/Stealth2D
Tanner Rogalsky (https://github.com/TannerRogalsky) ported the library
to LÖVE 0.9.0.