ReasonML graphics library inspired by Processing
Branch: master
Clone or download
Latest commit 385e482 Jan 19, 2019

README.md

Reprocessing

Build Status Build status

This is a high-level drawing library, inspired by Processing, allowing you to write code that'll run on the web (using WebGL) and natively (using OpenGL).

Example

The interactive docs are the simplest way to try reprocessing. (They are generated using redoc!).

The 2nd simplest way to try is to clone reprocessing-example.

See below for projects using Reprocessing!

Getting Started

npm install reprocessing

Note: on linux, you may need to also install some libraries):
apt install libsdl2-dev fcitx-libs-dev libibus-1.0-dev

Code Example

Clone reprocessing-example and follow instructions there to setup a new project.

open Reprocessing;

let setup = (env) => {
  Env.size(~width=200, ~height=200, env);
};

let draw = (_state, env) => {
  Draw.background(Constants.black, env);
  Draw.fill(Constants.red, env);
  Draw.rect(~pos=(50, 50), ~width=100, ~height=100, env)
};

run(~setup, ~draw, ());

Build

npm run build

This will draw a simple red square on a black background. Compare this to reglexampleproject, which takes 200+ lines to do the exact same thing. This difference is even more notable on bigger projects. Check out the code for a draggable red square.

Demo

There are a couple demos inside examples. Run npm i to install all deps and npm run build to build to JS (default). Open index.html in safari (or use python -m SimpleHTTPServer 8000 to spawn a static server and go to localhost:8000 in chrome).

Run npm run build:bytecode to build to a bytecode executable and run ./lib/bs/bytecode/index.byte.

Run npm run build:native to build to a native executable and run ./lib/bs/native/index.native.

See below for examples!

FAQs

Where do I find x function?

There are a few modules in Reprocessing that store most functions you will want to use. The best way to find one is to use the search on the docs site: https://schmavery.github.io/reprocessing/

In general:

  • Draw contains functions that draw to the screen (and affect drawing), like rect and image.
  • Env contains functions involving the environment (or window) you are running in. For example, mouse and size.
  • Utils contains many static helper functions from Processing such as lerp and dist.
  • Constants contains some mathematical and color-related constants, like pi and green.

Why do some functions have an "f" at the end?

Several utility functions that would otherwise accept either an integer or a float in Processing expose a version with an f suffix, which supports floats. Ex: random vs randomf. This lets you use whichever you prefer without needing to convert all the time.

When do I run loadImage or loadFont?

It is best to run these functions in the setup function. They are fairly expensive to run and setup is usually the easiest place to load your assets once. Then you can keep a reference to them in your state and draw them as many times as you want!

How do I use different fonts when drawing text?

There is a default font in Reprocessing that will be automatically used if you use Draw.text without providing a font. However, you frequently want to have your own font!

The story for using fonts in your Reprocessing app is still under some development to make it nicer. Right now we have support for writing text in a font defined in the Angel Code font format. This is basically a bitmap of packed glyph textures along with a text file that describes it.

★★★ Check out font-generator for a tool that can take any truetype or opentype font and output font files that Reprocessing can use.

In order to use a font once you have the files:

let font = Draw.loadFont(~filename, env);
Draw.text(~font, ~body="Test!!!", ~pos=(10, 10), env);

Why is there no support for 3D drawing?

The original goal for reprocessing was to make something extremely easy to use and build real (2d) games and experiences with in ReasonML. Processing's 2D API does an amazing job at making graphics approachable. It would be really neat to be able to extend this to 3D creations but I do tend to feel that the 3D API is significantly more complex in some ways. It adds several new concepts such as 3d shapes, texture/materials/lighting, and we'd need to extend several functions to optionally support a third dimension. It also doesn't let you avoid the matrix functions which can be counterintuitive and camera logic gets more involved. We may consider trying to add support in the future but it currently isn't on the roadmap.

Some Differences from Processing

  • For state management, we encourage the use of the state value that Reprocessing manages for the user. To use this, decide on a datatype representing the state and return the initial value from setup. This will be persisted behind the scenes and passed to every callback (such as draw and mouseDown). Each callback should return the new value of the state (or the old value if it doesn't change).

  • There are no built-in variables like width and mouseX. Instead, these are functions that are called, passing in an environment object that is always provided.

open Reprocessing;
let draw = (state, env) => {
  let w = Env.width(env);
  print_endline("The current width is:" ++ string_of_int(w))
};
  • The builtin map function is called remap instead to avoid confusion with the well-known List.map function which maps over a list of values. As, according to the Processing docs, this function "Re-maps a number from one range to another.", this naming seems appropriate.

  • Points are expressed as tuples. Instead of exposing a mouseX and mouseY, there is a mouse, which is a tuple of x and y values.

open Reprocessing;
let draw = (state, env) => {
  let (x, y) = Env.mouse(env);
  print_endline("The current mouse position is:" ++ (string_of_int(x) ++ string_of_int(y)))
};

Projects using Reprocessing

Talks and articles about Reprocessing

Please open a PR to add any cool projects, talks or articles about Reprocessing that are missing above!