Lmst

Coding in the train #openrndr
#kotlin #creativeCoding #madeWithCode

Code generated design made by subdividing rectangles. Gradients are applied to the blocks, which have rounded corners.
The color palette is created by interpolating between 4 colors.

Ten offset hobby contours converted to meshes and colorized using the normal of each vertex.

This is a tool I need for another project, to make things flow along contours.

#OPENRNDR #CreativeCoding #Kotlin #Math #rainbow #madeWithCode

A software generated 2D design featuring 10 wobbly curves. One curve is the base, and the other 9 are added by offsetting the most recent curve. They have thinner and thicker parts. The background is dark and the curves are colorful, colors based on the orientation of each segment. One curve is more opaque and saturated, the others seem to fade progressively into the background. I guess the curves may imply motion, making our eyes try to follow the contours to find out if they are closed shapes or not.

This iteration has been a big challenge: Generate shapes, get their concave hull, pack those hulls, calculate the transformation matrices mapping the original hulls to the packed ones. Apply those transformation matrices to the original shapes. Finally play with a 2D camera to find the right shot.

And I still have an interesting rounding bug which doesn't fit in this description :)

#CreativeCoding #OPENRNDR #Kotlin #madeWithCode #generative #noAI

Code generated design made out of a few non-overlapping shapes, which are made out of hundreds of non-crossing curves curves. The lines obviously follow rules, but the rules are not obvious. There seem to be core lines, and other lines emerging from those. Very few curves are highlighted with two different colors. The color palette was sampled from old maps.

This version shows a close up of about 7 or 8 shapes, some of them cropped on the edges of the window.

I minimal program that draws a circle then grows 150 distorted copies of it.

The core part of the program is about 10 lines of code.

#CreativeCoding #generative #madeWithCode #OPENRNDR #Kotlin

Code generated design. Start by adding a circle to a collection, then repeat 150 times: add a slightly distorted copy of the last shape in the collection.

Close up version in which the largest shapes are partially out of the visible area. Due to the progressive distortion the result might resemble a close-up of a coral.

Code generated design. Black curves on white background. Start by adding a circle to a collection, then repeat 150 times: add a slightly distorted copy of the last shape in the collection.

In this version one can see the full resulting shape. The numerous curves with varying distance produce shades of gray. Most part look smoothly shaded, but in certain parts there are folds and apparent discontinuities.

I took a walk and collected some textures to use in this one.

#CreativeCoding #generative #abstract #MadeWithCode #OPENRNDR #Kotlin #pareidolia

Code generated design. Geometric blocks are connected with each other on the edges. The background and the blocks have textures so they look less digital and more organic. The vertices on the block edges have been slightly displaced also to look less perfect.

In this variation there are two vertical shapes, as if standing next to each other and interacting.

Some kind of buggy symmetry which probably makes it more interesting than properly working symmetry 😃

#CreativeCoding #OPENRNDR #Kotlin #blockchain #madeWithCode #abstract #AbstractArt

Code generated design made out of colorful blocks (yellow triangles, green squares, bluegreen pentagons, blue hexagons, brown 180 degree arcs and dark red 90 degree arcs) touching each other on the sides, which have all the same length.

The composition is grown from a central piece, and the child pieces are usually of the same type.

This one looks like a bird with a tail and a crest standing on two legs telling someone to come.

Not sure what this one looks like. Maybe a person using a very strange vacuum cleaner full of contraptions.

I can see some kind of human on this one, like running towards a small arc and a weird thing on the head.

In this next iteration I thought of adding curved shapes. The trick is to filter out the curved segments of such shapes and only allow connecting on the straight ones.

See, the arc has two curves and two straight segments connecting those curves.

Does it happen to you that you should be doing something else, but you have an idea and don't want to wait to try it out? 😁 And then you immediately have the idea for the next step? XD

#creativeCoding #OPENRNDR #Kotlin
#MadeWithCode #geometry

Code generated design made of over 50 shapes. There are 4 types of shapes: triangles, squares, pentagons and 90 degree arcs. The straight segments in all shapes are the same length, allowing to connect them with each other. Gray background, white shapes with black contour.

The final shape has been grown out of a central piece, connecting shapes to previous shapes, in a chaotic branching structure.

Child shapes connected to a parent shape are all of the same type.

Another short #grid based #Kotlin program

#OPENRNDR #MadeWithCode #CreativeCoding #abstract

import org.openrndr.application
import org.openrndr.extra.noise.primitives.random
import org.openrndr.extra.noise.simplex
import org.openrndr.extra.noise.uniform
import org.openrndr.extra.shapes.operators.roundCorners
import org.openrndr.extra.shapes.primitives.grid
import org.openrndr.math.IntVector2
import org.openrndr.math.map
import org.openrndr.shape.ShapeContour
import kotlin.math.pow
import kotlin.random.Random

fun main() = application {
configure {
width = 1920
height = 400
position = IntVector2(0, 1080 - height)
}

program {
extend {
val r = Random(5120)
drawer.contours(drawer.bounds.grid(40.0, 40.0).flatten().filter {
Boolean.random(0.9, r)
}.map { rect ->
val scale = simplex(7168, rect.center * 0.001).map(-1.0, 1.0, 0.1, 1.0)
ShapeContour.fromPoints(rect.contour.segments.map {
it.position(Double.uniform(0.0, scale, r).pow(2.0))
}, true).roundCorners(5.0)
})
}
}
}

A short #grid based #Kotlin program

#OPENRNDR #MadeWithCode #CreativeCoding

A screenshot showing code at the top and the visual result at the bottom. The code is written in Kotlin using OPENRNDR. The main 3 lines are these:

drawer.contours(drawer.bounds.grid(40.0, 40.0).flatten().map { rect ->
val scale = simplex(7168, rect.center * 0.001).map(-1.0, 1.0, 0.2, 1.0)
ShapeContour.fromPoints(rect.contour.segments.map { it.position(Double.uniform(scale)) }, true).roundCorners(5.0)
})

The result is a grid of white shapes with rounded corners on black background. The maximum dimensions of each shape are 40 pixels wide and tall. For each grid rectangle, 4 points on the edges are samples and joined to form a polygon, resulting in shapes smaller than the original rectangle. Simplex noise is used to decide how much the shapes are reduced. Some areas are almost rectangular, while others are smaller and more irregular, revealing more black background.

Less order and more chaos.

#CreativeCoding #OPENRNDR #Kotlin #GLSL #madeWithCode #organic #growth

Code generated image with a palette of 3 main hues turquoise, yellow and red. Looking like growing slimy organisms. The pattern looks closer to a brain structure than to a tree root. No straight lines. Could remind me of pouring two liquids of different viscosity on a cup, stirring and waiting for a while.

Between order and chaos

#CreativeCoding #OPENRNDR #Kotlin #GLSL #madeWithCode

Image generated by code. Simulation of 3 types of particles moving and interacting with each other. The pattern reveals some order originating from the starting point of the simulation, where all particles were placed in a grid.

This created a regular grid, then evolved becoming more organic, with diagonal and curved lines appearing and sometimes replacing the horizontal and vertical ones.

By abusing the color correction effect I could get unexpected looks with the same program I used to create previous images.

#CreativeCoding #OPENRNDR #Kotlin #madeWithCode #GLSL

Iterating on those agents. Three types of them. Type G are friendly: they like everyone. Type R are unfriendly, they don't like anyone, even themselves. Type B are picky. They like G and B, but not R.

#CreativeCoding #OPENRNDR #Kotlin #madeWithCode