A personal generative playground. Finally on github after multiple requests.
Table of Contents
This is a long-lived project containing a collection of generative techniques that I've been working on recently. Its purpose is to help me explore code-driven art and procedural generation, as well as related topics. The structure of the project may be unconventional and the documentation lacking, but please keep in mind that all this has been hidden away in a private repository for a long time, intended for personal use only. However, after several requests, I've decided to make the code public (I've done some work on cleaning up the code, but here and there you might just find strange reminders and messages that I wrote to myself).
Since this is just a sandbox project (i.e, my personal playground), there's no user interface. Instead, the project contains many "main" files, each dedicated to a specific concept. Each main file is associated with multiple "sketches" that run related ideas. For now, the source code has to be edited in order to change the settings. A short usage guide can be found under usage.
I realize this is more of a library now than anything else, although a scattered and incoherent one. Explore at your own peril. If you find anything (a class, a module, whatever) you like, feel free to use it in your own projects.
Samples from my experiments are published on my instagram. Occasionally, I also make blog posts describing some parts of my process.
Here are a few sample images:
More can be found under output.
The project is built with the aid of Processing. However, the code is not formatted as a processing sketch. Instead, the processing core is imported as a library to ensure that I could use a regular IDE (like IntelliJ IDEA) for organizing the code. More about installation/prerequisites under getting started.
(A parenthesis about using Processing with any IDE: this is a great blog post explaining how it can be done.)
I suggest setting up the project in a popular IDE for easy use since there's no installation script (and as mentioned, no user interface). I'll go through how to run the project using IntelliJ IDEA, but the process shouldn't be very different from other IDE's.
- JDK 11 (or newer)
- Processing 3.5.4 (or newer)
- Install JDK 11 or newer.
- Install processing 3.5.4 or newer.
- Clone this repository
git clone https://github.com/palmdrop/sandbox.git
- Setup a java project (below follows some steps for setting up an IntelliJ IDEA project, but any IDE might be used)
- Open the
sandboxrepository you've just cloned as a project. - Under
Project structure -> Projectpick Java 11 as the Project SDK (also make sure the language level is at least 11). - Under
Project structure -> SDKschoose11(for Java 11) and then clickclasspath. Press+and navigate to where you installed Processing. Pickprocessing-3.5.X/core/library/core.jar.
- Open the
- Run desired main class (all can be found directly under
src).
There are many main classes in the project, all dedicated to exploring different concepts. Try running one of them. A window will be spawned and after it finishes loading, you'll hopefully see something exciting on the screen.
Here's a short description of the purpose of each main class:
ColorMain: for generating color palettes and playing around with color spaces.ImageMain: for mixing images together and analyzing image data.NebulaMain: for creating organic shapes and landscapes.OrganicMain: for algorithms simulating plant growth.ChaoticOrganicMain: a more chaotic take onOrganicMain.TextMain: for analyzing font letters and using them to visualize images or heightmaps.Texturemain: similar toNebulaMain, but specifically designed to produce interesting textures using noise and domain warping.VisionMain: for analyzing any type of raw data and visualizing it in a (hopefully) unconventional way.VisualizeMain: for simple visualizations of noise variations (doesn't use the sketch structure).
Most main classes instantiate a Sketch class which is responsible for envisioning a particular idea, experiment, or concept. Each sketch is in turn an instantiation of a Drawer which takes a PGraphics object (native to Processing). This object is drawn to, and then the main class shows the result to the screen. I suggest studying the Processing documentation to find out more about how this works.
The sketches can be found in the sketch package. The names of the subpackages correspond to the different main files. Usually, it's possible to comment out the currently used sketch and instantiate another one from the corresponding package.
To change the settings of a particular sketch, you'll have to edit the values and instantiated objects contained within the sketch itself. Unfortunately, I will not add any detailed instructions for how to use each one. If you're interested in running any of them, you'll have to do some experimentation on your own. As mentioned, this project was initially intended for personal use and nothing else. Maybe in the future, I'll create a user interface for some of the sketches.
General source data used by some of the sketches can be found under sourceData. Source images specifically can be found under sourceImages. You may have to change the paths used in certain sketches since I have excluded many of the source files from this repository due to privacy and copyright conerns.
I do not expect any contributions to this project. However, if you do find an especially interesting configuration, or happen to use some of this code for a project of your own, feel free to share.
📬 Email (the most reliable way of reaching me)
📷 Instagram (where I showcase a lot of my work)
💻 Blog (where I occasionally write posts about my process)