Here is the latest step in the reaction diffusion process (full process here). I now can produce 3D models of the system and can extract sequential sections, I just need to figure out how they fit together. At the moment it’s still not quite architectural, but I did this in order to help me inspect what’s going on at each level.

The model was made in processing, and the animation itself done in grasshopper and then composited in after effects.

This post continues on from my tests with reaction diffusion (full process here). Like I said before, I was going to begin to look extrapolating the form into 3 Dimensions, so this is an early result of that.

Trying to visualise spaces out of some of these forms is quite a difficult task. However it reminds me of a TED Talk done by Michael Hansmeyer in which he talks about imagining impossible spaces through computational methods. The spaces that are created follow a defined logic, but the process and the end result is virtually imperceptible by the human condition. So the goal in going through this process is to try and rationalise a form out of it.

I’ve iterated out almost 30 of these reaction diffusion forms in 3D and so my next step is going to be to take either horizontal or vertical sections through them to try and rebuild a layering effect in after effects which will hopefully aid this process of visualising spaces.

Here are several early sections which I’ve rendered out. These are all sequences of the same model.

This animation was created by sending a perlin noise wave through a bounding box and returning the wave front at a certain threshold (design process here). Perlin Noise is a mathematical pattern which simulates random wave generation, however factors in regular cresting and troughing of the waves, which is why the voxels return as a rational looking mesh. Unfortunately, the lighting seemed to mess up at times, resulting in the uneven lighting result. I believe this may have something to do with the amount of faces facing the camera, and hence reflecting more or less light into the ‘camera lens’, resulting in the light flickering at times.

Here are some snapshots of individual frames.

What also resulted in an interesting set of forms was changing the scale of the perlin wave. In doing so, the resulting form gets ever increasingly complex and unpredicatble. There are also issues with the orientation of individual mesh faces that create improper but interesting results. The standard set of mesh fixing and flipping algorithms don’t seem to work on this array of meshes.

The last render is essentially an equivalent of utter geometric noise.

Today I did some brief experiments with rendering water textures in v-ray for rhino. There are several fundamental things to achieving the right effect. I didn’t test these under proper lighting conditions, just using default scene lights, but the main idea is transferable.

For starters, water is going to be generated with a displacement map. So, make sure the surface you are applying the water texture to won’t exceed the boundaries it’s supposed to fit in.

Secondly, the reflection can be a bit tricky to get right. It all depends on what you’re going for. I think I washed it out a little too much below.

Next is the size and frequency of your waves. These are adjusted in the displacement settings. In order to get the wave effect, I tend to stick with the stock noise maps as they’re generally pretty reliable and give you far more variable control than if you were to try and create them yourself in photoshop.

The colour that the water gives off is not through the diffuse map, but rather inside the refraction tab of the material, it is added as a fog colour, and the colour multiplier along with the transparency of the refraction map affect the strength of the output. This water was achieved with a pale blue-ish colour. Also, make sure you set your refractive indexes to 1.33 (the refractive index of water), as well as in your reflection under the fresnel map.

A few final tweaks, and here’s the resulting water. An HDRI background map always ensures to give you better reflections in your scenes too.

If you want to use my water texture you can download it from my google drive

Every now and again I get back into python to do a little bit of scripting. Over the weekend I wrote a fractal script (for my design project).The input takes one rectangle, and then proceeds to rotate and translate that geometry however many times you deem appropriate in a recursive manner.  Here’s the result.

Although you can achieve recursion in grasshopper using a plugin like hoopsnake, it is preferable to do it in a python scripting component – it doesn’t clog your grasshopper canvas, and it’s more efficient in terms of CPU processing. Plus, I really want to learn a scripting language.

Sometimes accidents happen. And sometimes they look like this:

This is using a similar script to that which I am using in my processing experiments, probably will not be keeping this iteration, but it’s rather interesting to see what can happen sometimes. The form reminds me of some bizarre Cthulhu-like creature. I hope you don’t have nightmares after seeing this. 😉

(Obviously I just had to render these out when they came up in my viewport)

Made a quick tensile structure in grasshopper and kangaroo while I was bored and waiting for other renders to finish. I decided to do a brief look into tensile structures as it has been a topic of conversation amongst some of my peers in my design paper at uni (see design process here), and also Frei Otto won the 2015 Pritzker Prize award. What amazes me is that he was conducting these kinds of studies into tensile structures in the 60’s and 70’s, and it was all done manually, but now we have the ability to produce, analyse, and optimise these forms in a matter of minutes!

I also did a second render pass where I applied a checkerboard modifier over the mesh, because why not.. Result below.

This is my first series of renders for uni this year. My project for the first semester is called processing (see design process here). The main premise at the moment is to try and understand a material process which happens in nature, and then to try and use that process as a form driver for architecture.

My initial idea is to try and replicate a process of organisation. Nothing in the natural world happens accidentally or randomly, everything is defined by a strict set of physical properties and underlying rules which are fundamental to how our world works. So my approach to this was how can a process be applied to a seemingly random pool of initial data, and from that apply a logic which results in a locally organised end condition.

Here’s the series.

These are a few of the results which I liked or were perhaps the most interesting. Some of these are end states of the organisation algorithm, others are states of suspended animation, but the logic which is applied has a clear end goal. Perhaps this is a problem however, because this means that ultimately there isn’t going to be a lot of variation in the tests, and the point of this paper is mass iteration through a program like grasshopper, as that is what it is most useful for, testing and re-testing slight variations of a similar idea.

Here is the grasshopper script I wrote to create the end result anyhow, Components used are python, kangaroo, millipede and weaverbird. (click on image for larger preview)