boids simulation

Instructor/Course: Arsiliath - Intro to Compute Shaders

Tools: Unity (C++/GLSL)

Boids is an artificial life program which simulates the flocking behavior of birds. It's effect is achieved by simulating the interaction of individual agents which adhere to a simple set of rules. Typically these rules are as follows:

separation steer to avoid crowding local flockmates (agents)

alignment steer towards the average heading of local flockmates

cohesion steer to move towards the average position of local flockmates

My implementation builds on this concept by introducing multiple species, some of which follow a physarum (slime mold) simulation which adds another level of complexity to the system. Implementing on the GPU instead of CPU also allows an enormous numbers of agents (up to 5M in my case) to run in real time and further ramp up the complexity of the visuals.

Instructor/Course: Arsiliath - Intro to Compute Shaders

Tools: Unity (C++/GLSL)

Boids is an artificial life program which simulates the flocking behavior of birds. It's effect is achieved by simulating the interaction of individual agents which adhere to a simple set of rules. Typically these rules are as follows:

separation steer to avoid crowding local flockmates (agents)

alignment steer towards the average heading of local flockmates

cohesion steer to move towards the average position of local flockmates

My implementation builds on this concept by introducing multiple species, some of which follow a physarum (slime mold) simulation which adds another level of complexity to the system. Implementing on the GPU instead of CPU also allows an enormous numbers of agents (up to 5M in my case) to run in real time and further ramp up the complexity of the visuals.

cotton candy

Instructor: Entagma

Tools: Houdini

Original Inspiration: on__andon

A relatively straightforward vellum simulation using Entagma's techniques and based on the original simulations from on__andon. By combining Houdini's glue and hair constraints to a group of lines and animating their separation you can achieve a pretty convincing Cotton Candy effect.

Instructor: Entagma

Tools: Houdini

Original Inspiration: on__andon

A relatively straightforward vellum simulation using Entagma's techniques and based on the original simulations from on__andon. By combining Houdini's glue and hair constraints to a group of lines and animating their separation you can achieve a pretty convincing Cotton Candy effect.

physarum simulation

Instructor/Course: Arsiliath - Intro to Compute Shaders

Tools: Unity (C++/GLSL)

Further reading: Coding Adventure (Ant and Slime Simulations), Agent Based Modelling

Physarum (or Slime Mold) simulations are a type of Agent based system which simulates the interactions of a large number of agents. What's awesome about this type of simulation is that even very simple rules for how these agents interreact can achieve very complex results. This phenomena is known as emergence.

My simulation employs a group of agents (0.1-5 million) on a 2D plane which read and write from a shared "trail" layer. Every frame, each agent denotes it's current location on the trail layer while adjusting it's heading based on the location of other agents (which is determined based on the values on the trail layer). Using a trail layer instead of reading the location of each agent directly reduces the complexity of the simulation from O(n^2) to O(n). To further simplify the simulation, each agent only samples select points in the trail layer looking to it's right, left, and ahead. Finally, I added an animated noise function which increases / decreases agents field of view (how many degrees from center their right and left trail layer sample is taken) and the distance from themselves that the sample is taken. As a result, agents will momentarily have a largely increased field of view / view distance causing the collapse of the network as they become attracted to other agent clusters that we're previously invisible to them.

Instructor/Course: Arsiliath - Intro to Compute Shaders

Tools: Unity (C++/GLSL)

Further reading: Coding Adventure (Ant and Slime Simulations), Agent Based Modelling

Physarum (or Slime Mold) simulations are a type of Agent based system which simulates the interactions of a large number of agents. What's awesome about this type of simulation is that even very simple rules for how these agents interreact can achieve very complex results. This phenomena is known as emergence.

My simulation employs a group of agents (0.1-5 million) on a 2D plane which read and write from a shared "trail" layer. Every frame, each agent denotes it's current location on the trail layer while adjusting it's heading based on the location of other agents (which is determined based on the values on the trail layer). Using a trail layer instead of reading the location of each agent directly reduces the complexity of the simulation from O(n^2) to O(n). To further simplify the simulation, each agent only samples select points in the trail layer looking to it's right, left, and ahead. Finally, I added an animated noise function which increases / decreases agents field of view (how many degrees from center their right and left trail layer sample is taken) and the distance from themselves that the sample is taken. As a result, agents will momentarily have a largely increased field of view / view distance causing the collapse of the network as they become attracted to other agent clusters that we're previously invisible to them.

chaos fabrics

Instructor/Course: Arsiliath - Intro to Compute Shaders

Tools: Unity (C++/GLSL),Cinema4D. Octane

Further reading: Cellular Automata, Edge of Chaos Paper

Based on the concept of cellular automata, edge of chaos generates an image a single pixel row at a time where each pixel in a new row determines its value based on the pixels in the previous row. For example, a rule could be that if the pixel above a cell is black, the pixel below would be white and vice versa. This would generate a checkerboard pattern. More complex rules which involve the state of more pixels above each new pixel (e.g., directly above, above to the right, above to the left) will develop more complex patterns.

Increasing the number of pixels in the previous row that are checked also increases the number of rules you'll need to come up with and can quickly become tedious. For instance, in a black and white image, sampling 5 pixels would mean 32 possible states to determine a new pixels value. The fun comes when you randomly generate these states. Chris Langton's Edge of Chaos paper provides much more detail on this approach (linked above)

My implementation uses the images generated using the Edge of Chaos approach as diffuse and displacement maps in 3D materials to generate convincing fabrics. This technique could prove useful in generated uniquely / interesting fabric materials rapidly.

Instructor/Course: Arsiliath - Intro to Compute Shaders

Tools: Unity (C++/GLSL),Cinema4D. Octane

Further reading: Cellular Automata, Edge of Chaos Paper

Based on the concept of cellular automata, edge of chaos generates an image a single pixel row at a time where each pixel in a new row determines its value based on the pixels in the previous row. For example, a rule could be that if the pixel above a cell is black, the pixel below would be white and vice versa. This would generate a checkerboard pattern. More complex rules which involve the state of more pixels above each new pixel (e.g., directly above, above to the right, above to the left) will develop more complex patterns.

Increasing the number of pixels in the previous row that are checked also increases the number of rules you'll need to come up with and can quickly become tedious. For instance, in a black and white image, sampling 5 pixels would mean 32 possible states to determine a new pixels value. The fun comes when you randomly generate these states. Chris Langton's Edge of Chaos paper provides much more detail on this approach (linked above)

My implementation uses the images generated using the Edge of Chaos approach as diffuse and displacement maps in 3D materials to generate convincing fabrics. This technique could prove useful in generated uniquely / interesting fabric materials rapidly.

COMPOUNDS EYES

Tools: HOUDINI, REDSHIFT

Procedural system i made to generate the compound eyes found on some insects and CrustaceanS. The hex shape of each lens is created by running vdb advect on scattered spheres in a solver. Houdini’s connectivity function is then used to assign colors (based on a noise function) to each of the lenses afterwards.

Tools: HOUDINI, REDSHIFT

Procedural system i made to generate the compound eyes found on some insects and CrustaceanS. The hex shape of each lens is created by running vdb advect on scattered spheres in a solver. Houdini’s connectivity function is then used to assign colors (based on a noise function) to each of the lenses afterwards.

multi neighbor cellular automata

Instructor: Arsiliath - Intro to Compute Shaders

Tools: Unity (C++/GLSL)

Further reading: Cellular Automata, Understanding Multiple Neighborhood Automata

Another exploration based on the principles of Cellular Automata, Multi Neighborhood Cellular Automata (MNCA) increases the range each cell queries (from what is typically only neighboring cells/pixels in single-neighbor cellular automata) to determine each cells next state and therefore allowing for much greater diversity in results. For example, on a 2D implementation, a pixel may sample the value in every cell within 2 steps of it in each direction to determine it's next state. Slackermanz has a fantastic post about this (linked above) which shows some of the incredible systems he has found. Some of the systems on this page are mine but most are just my implementation of systems he has found.

Instructor: Arsiliath - Intro to Compute Shaders

Tools: Unity (C++/GLSL)

Further reading: Cellular Automata, Understanding Multiple Neighborhood Automata

Another exploration based on the principles of Cellular Automata, Multi Neighborhood Cellular Automata (MNCA) increases the range each cell queries (from what is typically only neighboring cells/pixels in single-neighbor cellular automata) to determine each cells next state and therefore allowing for much greater diversity in results. For example, on a 2D implementation, a pixel may sample the value in every cell within 2 steps of it in each direction to determine it's next state. Slackermanz has a fantastic post about this (linked above) which shows some of the incredible systems he has found. Some of the systems on this page are mine but most are just my implementation of systems he has found.

GLOBBY CERAMICS

RENDER WEEKLY CHALLENGE s6 W14: Design and render a jar set

Tools: HOUDINI

FEATURED POST: RENDER WEEKLY INSTAGRAM

RENDER WEEKLY CHALLENGE s6 W14: Design and render a jar set

Tools: HOUDINI

FEATURED POST: RENDER WEEKLY INSTAGRAM

organic networks

Instructor/Course: Javier Ruiz - Fabrics 1.0

Tools: Houdini

My implementation of a Houdini fabric technique developed by Javier Ruiz which uses noise functions and connecting point functions to generate a wide variety of organic looking networks. My approach builds on this by applying this techniques to an existing network of points along multiple spirals to create a hypnotic / spiderweb effect. Animating the movement of some of these curves allows for very organic connection breaks and builds.

Instructor/Course: Javier Ruiz - Fabrics 1.0

Tools: Houdini

My implementation of a Houdini fabric technique developed by Javier Ruiz which uses noise functions and connecting point functions to generate a wide variety of organic looking networks. My approach builds on this by applying this techniques to an existing network of points along multiple spirals to create a hypnotic / spiderweb effect. Animating the movement of some of these curves allows for very organic connection breaks and builds.

FILAMENT TABLE LAMP

Render weekly s4 w12: Design and render an object where the main form gesture is built using a sweep command. A sweep consists of one or more 2d profiles moved along an open or closed path

Tools: houdini

Render weekly s4 w12: Design and render an object where the main form gesture is built using a sweep command. A sweep consists of one or more 2d profiles moved along an open or closed path

Tools: houdini

section

OVERVIEW

SOFTWARE / LANGUAGES

LABORATORY

EXPLORATIONS INTO GENERATIVE DESIGN, EMERGENCE, BIOMIMICRY AND ANYTHING THAT CATCHES MY EYE

HOUDINI, CINEMA 4D, UNITY, C++, OPENGL, REDSHIFT, OCTANE

boids simulation

Instructor/Course: Arsiliath - Intro to Compute Shaders

Tools: Unity (C++/GLSL)

Boids is an artificial life program which simulates the flocking behavior of birds. It's effect is achieved by simulating the interaction of individual agents which adhere to a simple set of rules. Typically these rules are as follows:

separation steer to avoid crowding local flockmates (agents)

alignment steer towards the average heading of local flockmates

cohesion steer to move towards the average position of local flockmates

My implementation builds on this concept by introducing multiple species, some of which follow a physarum (slime mold) simulation which adds another level of complexity to the system. Implementing on the GPU instead of CPU also allows an enormous numbers of agents (up to 5M in my case) to run in real time and further ramp up the complexity of the visuals.

Instructor/Course: Arsiliath - Intro to Compute Shaders

Tools: Unity (C++/GLSL)

Boids is an artificial life program which simulates the flocking behavior of birds. It's effect is achieved by simulating the interaction of individual agents which adhere to a simple set of rules. Typically these rules are as follows:

separation steer to avoid crowding local flockmates (agents)

alignment steer towards the average heading of local flockmates

cohesion steer to move towards the average position of local flockmates

My implementation builds on this concept by introducing multiple species, some of which follow a physarum (slime mold) simulation which adds another level of complexity to the system. Implementing on the GPU instead of CPU also allows an enormous numbers of agents (up to 5M in my case) to run in real time and further ramp up the complexity of the visuals.

cotton candy

Instructor: Entagma

Tools: Houdini

Original Inspiration: on__andon

A relatively straightforward vellum simulation using Entagma's techniques and based on the original simulations from on__andon. By combining Houdini's glue and hair constraints to a group of lines and animating their separation you can achieve a pretty convincing Cotton Candy effect.

Instructor: Entagma

Tools: Houdini

Original Inspiration: on__andon

A relatively straightforward vellum simulation using Entagma's techniques and based on the original simulations from on__andon. By combining Houdini's glue and hair constraints to a group of lines and animating their separation you can achieve a pretty convincing Cotton Candy effect.

physarum simulation

Instructor/Course: Arsiliath - Intro to Compute Shaders

Tools: Unity (C++/GLSL)

Further reading: Coding Adventure (Ant and Slime Simulations), Agent Based Modelling

Physarum (or Slime Mold) simulations are a type of Agent based system which simulates the interactions of a large number of agents. What's awesome about this type of simulation is that even very simple rules for how these agents interreact can achieve very complex results. This phenomena is known as emergence.

My simulation employs a group of agents (0.1-5 million) on a 2D plane which read and write from a shared "trail" layer. Every frame, each agent denotes it's current location on the trail layer while adjusting it's heading based on the location of other agents (which is determined based on the values on the trail layer). Using a trail layer instead of reading the location of each agent directly reduces the complexity of the simulation from O(n^2) to O(n). To further simplify the simulation, each agent only samples select points in the trail layer looking to it's right, left, and ahead. Finally, I added an animated noise function which increases / decreases agents field of view (how many degrees from center their right and left trail layer sample is taken) and the distance from themselves that the sample is taken. As a result, agents will momentarily have a largely increased field of view / view distance causing the collapse of the network as they become attracted to other agent clusters that we're previously invisible to them.

Instructor/Course: Arsiliath - Intro to Compute Shaders

Tools: Unity (C++/GLSL)

Further reading: Coding Adventure (Ant and Slime Simulations), Agent Based Modelling

Physarum (or Slime Mold) simulations are a type of Agent based system which simulates the interactions of a large number of agents. What's awesome about this type of simulation is that even very simple rules for how these agents interreact can achieve very complex results. This phenomena is known as emergence.

My simulation employs a group of agents (0.1-5 million) on a 2D plane which read and write from a shared "trail" layer. Every frame, each agent denotes it's current location on the trail layer while adjusting it's heading based on the location of other agents (which is determined based on the values on the trail layer). Using a trail layer instead of reading the location of each agent directly reduces the complexity of the simulation from O(n^2) to O(n). To further simplify the simulation, each agent only samples select points in the trail layer looking to it's right, left, and ahead. Finally, I added an animated noise function which increases / decreases agents field of view (how many degrees from center their right and left trail layer sample is taken) and the distance from themselves that the sample is taken. As a result, agents will momentarily have a largely increased field of view / view distance causing the collapse of the network as they become attracted to other agent clusters that we're previously invisible to them.

chaos fabrics

Instructor/Course: Arsiliath - Intro to Compute Shaders

Tools: Unity (C++/GLSL),Cinema4D. Octane

Further reading: Cellular Automata, Edge of Chaos Paper

Based on the concept of cellular automata, edge of chaos generates an image a single pixel row at a time where each pixel in a new row determines its value based on the pixels in the previous row. For example, a rule could be that if the pixel above a cell is black, the pixel below would be white and vice versa. This would generate a checkerboard pattern. More complex rules which involve the state of more pixels above each new pixel (e.g., directly above, above to the right, above to the left) will develop more complex patterns.

Increasing the number of pixels in the previous row that are checked also increases the number of rules you'll need to come up with and can quickly become tedious. For instance, in a black and white image, sampling 5 pixels would mean 32 possible states to determine a new pixels value. The fun comes when you randomly generate these states. Chris Langton's Edge of Chaos paper provides much more detail on this approach (linked above)

My implementation uses the images generated using the Edge of Chaos approach as diffuse and displacement maps in 3D materials to generate convincing fabrics. This technique could prove useful in generated uniquely / interesting fabric materials rapidly.

Instructor/Course: Arsiliath - Intro to Compute Shaders

Tools: Unity (C++/GLSL),Cinema4D. Octane

Further reading: Cellular Automata, Edge of Chaos Paper

Based on the concept of cellular automata, edge of chaos generates an image a single pixel row at a time where each pixel in a new row determines its value based on the pixels in the previous row. For example, a rule could be that if the pixel above a cell is black, the pixel below would be white and vice versa. This would generate a checkerboard pattern. More complex rules which involve the state of more pixels above each new pixel (e.g., directly above, above to the right, above to the left) will develop more complex patterns.

Increasing the number of pixels in the previous row that are checked also increases the number of rules you'll need to come up with and can quickly become tedious. For instance, in a black and white image, sampling 5 pixels would mean 32 possible states to determine a new pixels value. The fun comes when you randomly generate these states. Chris Langton's Edge of Chaos paper provides much more detail on this approach (linked above)

My implementation uses the images generated using the Edge of Chaos approach as diffuse and displacement maps in 3D materials to generate convincing fabrics. This technique could prove useful in generated uniquely / interesting fabric materials rapidly.

multi neighbor cellular automata

Instructor: Arsiliath - Intro to Compute Shaders

Tools: Unity (C++/GLSL)

Further reading: Cellular Automata, Understanding Multiple Neighborhood Automata

Another exploration based on the principles of Cellular Automata, Multi Neighborhood Cellular Automata (MNCA) increases the range each cell queries (from what is typically only neighboring cells/pixels in single-neighbor cellular automata) to determine each cells next state and therefore allowing for much greater diversity in results. For example, on a 2D implementation, a pixel may sample the value in every cell within 2 steps of it in each direction to determine it's next state. Slackermanz has a fantastic post about this (linked above) which shows some of the incredible systems he has found. Some of the systems on this page are mine but most are just my implementation of systems he has found.

Instructor: Arsiliath - Intro to Compute Shaders

Tools: Unity (C++/GLSL)

Further reading: Cellular Automata, Understanding Multiple Neighborhood Automata

Another exploration based on the principles of Cellular Automata, Multi Neighborhood Cellular Automata (MNCA) increases the range each cell queries (from what is typically only neighboring cells/pixels in single-neighbor cellular automata) to determine each cells next state and therefore allowing for much greater diversity in results. For example, on a 2D implementation, a pixel may sample the value in every cell within 2 steps of it in each direction to determine it's next state. Slackermanz has a fantastic post about this (linked above) which shows some of the incredible systems he has found. Some of the systems on this page are mine but most are just my implementation of systems he has found.

organic networks

Instructor/Course: Javier Ruiz - Fabrics 1.0

Tools: Houdini

My implementation of a Houdini fabric technique developed by Javier Ruiz which uses noise functions and connecting point functions to generate a wide variety of organic looking networks. My approach builds on this by applying this techniques to an existing network of points along multiple spirals to create a hypnotic / spiderweb effect. Animating the movement of some of these curves allows for very organic connection breaks and builds.

Instructor/Course: Javier Ruiz - Fabrics 1.0

Tools: Houdini

My implementation of a Houdini fabric technique developed by Javier Ruiz which uses noise functions and connecting point functions to generate a wide variety of organic looking networks. My approach builds on this by applying this techniques to an existing network of points along multiple spirals to create a hypnotic / spiderweb effect. Animating the movement of some of these curves allows for very organic connection breaks and builds.