
Making Bitmaps Using a Visual Programing Language - bsella
https://github.com/bsella/Emergence/
======
quadcore
In the same category, substance:
[https://www.allegorithmic.com/products/substance-
designer](https://www.allegorithmic.com/products/substance-designer)

~~~
FraKtus
The link gives me a 502 on iOS.

------
veli_joza
Very interesting project! I'm also building something like this. I'm also
using constructive geometry to build a scene, but I'm using tree hierarchy
instead of graph of nodes, and primitive form of ray-tracing to produce
output. Few days ago I managed to get recursion to work. Graphics programming
is insanely fun!

~~~
bsella
oh sounds good, can I take a look on the code?

~~~
veli_joza
The code is not yet presentable, but it's open:
[https://github.com/jmiskovic/arbo](https://github.com/jmiskovic/arbo)

------
pjc50
This is simultaneously quite cool - a tweakable image generation pipeline,
like shaders; and a good demonstration of why visual programming languages
remain extremely niche (Scratch, Labview): the instant descent into sphagetti.

~~~
crimsonalucard
I disagree. A textual programming language has the exact same structure. But
in text. Logically a graph of nodes represented in text is harder to read then
a graph of nodes represented in pictures. Most people think text is easier
because of habit and because creating visual languages is harder therefore a
good one hasn't been made yet.

~~~
seanmcdirmid
Actually, the truth lies somewhere in the middle. Text excels at abstractice
capability, relationships are less explicit via name and procedure bindings,
they can be even be compressed via loops and functions. On the other hand,
relationships are very much explicit and in your face in a patch/wire visual
language.

This is just a trade off, visual languages are better at being explicit but
worse at being abstract. When you think about it, that makes sense: a picture
requires the commitment of detail that an abstract textual description does
not. Incidentally, simply designing a more abstract visual notation is no easy
way out of this, because the notation will inevitably resemble text as it
becomes more abstract.

Also, most VPLs have some amount of textual language I them. A patch/wire VPL
will go text on patch names and port labeling. Scratch, in contrast, is
basically graphically edited text with some visual elements. This makes
judging the entire visual paradigm even more tricky, because it isn’t
homogenous at all.

~~~
crimsonalucard
What is text but a visual abstraction? The same abstractions can be made with
different geometry that isn't restricted to lines and left to right reading
order.

------
FraKtus
The best for me is artmatic:
[http://www.artmatic.com](http://www.artmatic.com) There are presets of trees
that makes it easy to generate fine visuals and the primitive themselves are
finetuned to generate impressive results. This is catch with that type of
generators, giving the right sets of primitives, if you are too detailed it
can take lomg to implemente something. Eric Wenger, the author of artmatic, is
both an artist and a coder, there are not many creative peoples like him.

------
SuperPaintMan
Cool project! Looks very similar to generating images with Blenders
compositor. What are the differences between this and that?

------
pzone
This is a tried and true method for processing bitmaps. It is always useful to
see intermediate composites as you work. Some other software implementing
node-based compositing and generation:

\- Nuke

\- Fusion

\- Substance Designer

\- Houdini

\- Blender

\- Natron

\- Autodesk Smoke

I am a fan of Houdini which gives you the ability to drop into a C-like DSL
called Vex if you ever feel like tossing some traditional code instructions
into the mix.

