Discrete Morphologies

Discrete morphologies

Ar7043 Advanced Digital Design Techniques 08037518 Ashley kirk

Tutors: George Tsakiridis and Arrash Fakouri Module Leader: Jonas Lundberg Thank you for an inspiring and insightful journey into ‘the’ digital.

Ashley Kirk 2019

2

Abstract

4-5

1.0

Introduction - What is Discrete?

Precedent Studies

6-9 10-13

2.0 Component Studies

Final Development

14-30 31-47

3.0

Gamescapes - Unity 3D

48-65

Postface

66-67

Bibliography

68-69

70-83

Appendix

This report should be read in conjunction with the digital files, experiments, presentation which can be found within the official module Google Drive folder: https://drive.google.com/drive/folders/1neza8M3NO5bfI 08uv2c4DsyGu7my3O_e?usp=sharing

3

abstract Through the first digital turn our field harnessed the capabilities of parametric design, the ability to encode and control the relationship between a number of parts using a set of rules to control how they behave. Arguably the centre of this movement was the spline - an infinitely smooth curve at any scale. Which can be described with this mathematical equation Y = f(x), a compact, economical, small-data shorthand we use to replace what is in fact an extraordinarily long list of numbers.”¹ The resulting architecture of the spline achieved differentiation through variation – each component different to the next. Realisation of these designs became possible through mass-customization, yet manufacture of these geometries often required lower-resolution panelisation strategies to allow tools to conform to the infinite smoothness of a spline.² Advances in computing has seen a rejection of these small-data methodologies as dealing with big data becomes increasingly accessible, which has given rise to the imperfect. “The messy point-clouds and volumetric units of design and calculation that result from these processes are today increasing shown in their apparently disjointed and fragmentary state; and the style resulting from this mode of computation is often called voxelization, or voxelation.” ³

Voxels need not be subject to geometric simplification for manufacture, instead the grain, or resolution, can be set to a particular requirement or desired outcome. For example, large-format building components could be described as a collection of low-resolution voxels, each of several metres in size but in turn, could be manufactured from high-resolution printed pieces. Unlike splines voxelised creations achieve differentiation through pattern rather than variation of parts, thus lending themselves to mass production techniques.

Minecraft, a video game based on voxel building blocks, where-by players can create worlds using just voxels, however, arguably the most attractive feature of this game is its participatory element - the ability to collaborate with others to create worlds. Once a vision this participatory turn seems to have been rejected by the architecture and design and this provides a valuable lesson for us to learn from. Furthermore, Minecraft can be played in immersive VR which is at the centre of a global participatory movement known as Block by Block where by communities around the world are engaged with the urban design process through the simple platform of the voxel-based game.

1. Carpo, M. The Second Digital Turn: Design Beyond Intelligence. MIT Press 2017. P65 2. Sanchez, J. Polyomino – reconsidering serial repetition in combinatorics. ACADIA 2014 3. Carpo, M. The Second Digital Turn: Design Beyond Intelligence. MIT Press 2017. P70 4. Ibidem P132.

4

Immersive design tools such as Google Tilt Brush remove boundaries of traditional architectural illusions (drawings or 2D images), and provide a design canvas concurrently with design feedback – experience. With experience comes a greater level of understanding and potentially a greater power to participate. This is a therefore a very powerful media for architectural representation and equally an opportunity for a new way of designing - to experience concurrently with design.

However, where Tilt brush and similar applications offer an infinite realm of possibility, I am intrigued by the pre-determined conditions that a combinatorial system can offer. This is particularly useful with the involvement of unskilled users. Furthermore, it allows the designer some form of control over the particular language and behaviors seen in the outputs.

The notion of fragmented geometry is also interesting as are the possibilities of experience and making design decisions within immersive environment. My research will look to design a discrete unit(s) of small scale (approx.

1m3) and an immersive platform in which to create, interact and experience the resulting system.

5

1.0 6

What is discrete?

7

“Our opportunity, as designers, is to learn how to handle the complexity, rather than shy away from it, and to realize that the big art of design is to make complicated things simple.�

- Tim Parsey

Y = f(x)

1

Architecture of the spline - Heydar Aliyev Center by Zaha Hadid Architects

1. Heyder Aliyev Centre, Zaha Hadid: http://static.dezeen.com/uploads/2013/07/dezeen_Heydar-Aliyev-Centre-by-Zaha-Hadid-Architects_3_1000.gif

8

1

Discreteness is a term used in mathematics and the sciences used to describe something that is individual, or separate. A discrete component is a singular unit, a standard house brick is discrete, yet the mortar that binds them together is continuous.2 You could argue that the singular brick is now part of a continuous form, and you would be right. However, the discrete component is still there.

Why does Discreteness hold relevance now?

The automotive industry fights everyday for economies - automation, repetition, component parts etc. Yet the architecture industry is, in the most part, at polar opposites from this notion. But in the problems we are facing with current issues of over population, housing shortfalls, financial struggles - why are we, architects, not taking a lesson from industry?

POSSIBILITIES Discrete systems could be employed for a vast number of interventions. To again reference the brick, its scale is relatively small compared to the building it creates. Yet the ‘components’ could be much larger scale. Perhaps whole apartments stacked?

In this design project the possibilities of a small component (1m3) will be explored through visual coding and game development in the attempt to bring about a participatory platform for people to interact, create and experience.

Discrete components offer opportunities in mass production, lightweight parts, economy, self build, participatory involvement. All because the unit (discrete component) is standardised, or at least a kit of standard parts.

END OF THE SPLINE For the last decade we have seen the rise and dominance of the Spline, an infinitely smooth curve at any scale.

Splines achieve differentiation through variation of parts to create the smoothness. Whilst this is achievable now with mass customisation and digital design and manufacture, it is still very expensive.

Unlike splines discrete systems achieve differentiation through pattern, rather than variation of parts, thus lending themselves to mass production techniques.

3

1. TAB 2017 Urban Installation in Tallinn, Gilles Retsin: https://cdnimd.worldarchitecture.org/extuploadc/digitalbuildingblocksgillesretsinta.jpg 2. Retsin, G. AD, 02 Vol 89, DISCRETE. Wiley 2019. P8 3. Radical Urban Planning, The Bartlett, UCL: https://images.squarespace-cdn.com/content/5862810cff7c506c994f91bb/1544592002312-KX94F0JAQEKPMQ605HBN/IMG_6257-1. jpg?format=1000w&content-type=image%2Fjpeg 9

1

case study - kengo kuma - yure pavilion This temporary installation in Paris by Kengo Kuma uses a rectilinear discrete component in the form of timber battens, each with a sectional dimension of 90x 180 mm.

There are two lengths of batten which are combined to make a unit which in turn creates the larger system. Two smaller battens are fixed to a larger diagonal batten. This then is copied through 90 degrees again several times, differing throughout the system, creating variation.

The system steps are seen in the diagram below. My explorations are seen right. >>> This is an example of a simple discrete component which, through this combinatory configuration creates both sculpture and pavilion with both artistic and spatial conditions. The porous structure dapples the light within the small space it creates.

2

1. https://www.archdaily.com/776541/kengo-kuma-designs-sculptural-pavilion-in-paris/5642463ae58ecee8fb00001d-kengo-kuma-designs-sculptural-pavilion-in-paris-photo 2. Assembly Diagrams - from AD vol89 2019 10

Modeled in rhino, rendered and post production - photoshop

Images from Rhino model explorations

11

1

case study - polyomino III A project developed by Jingbo Yan, Xinran Ding, Wansu Zhang & Dechen Zeng under tuition from Jose Sanchez within his Research Cluster at The Bartlet School of Architecture, UCL. It is one of the projects that first stood out to me and perhaps the reason I was intrigued to learn more about the field of discrete combinatory systems.

A disregard for perfect packing makes for a porosity that changes with the voids left between components on each variation. These changing conditions intrigue the viewer, perhaps the occupant if this were at pavilion scale. But that’s it - these images at least, have no scale and could be equally convincing as buildings or as small models.

My explorations into the ‘plane’ is seen right. >>>

The created pieces illustrate many more moments than the Kengo Kuma pavillion. Through creating a number of combinations with the same component they create a kit of parts consisting of mini-systems within the whole.

This provides the opportunity for more conditions, arches, plates, cantilevers for example.

2

1. Polyomino 3 - https://images.squarespace-cdn.com/content/v1/582f98dbb3db2be72dc14252/1479688325705-VD9M2MIA3ERK5XML3USF/ke17ZwdGBToddI8pDm48kFAonjahnhx-fb8iNiRCEMp7gQa3H78H3Y0txjaiv_0fDoOvxcdMmMKkDs yUqMSsMWxHk725yiiHCCLfrh8O1z4YTzHvnKhyp6Da-NYroOW3ZGjoBKy3azqku80C789l0s2R59z2HWVKMNU9GXmUK4UgMjTvwYN7hN4bXKHX5lIeBces2etgvgd1JwkJgxHn7w/image-asset.jpeg?format=1000w 2. Assembly Diagram - https://images.squarespace-cdn.com/content/582f98dbb3db2be72dc14252/1496353729897-V33N18BJO7X2H5PUQJUU/?format=1000w&content-type=image%2Fjpeg 12

Explorations of the ‘slab’ condition created by replicating the two unit combination shown.

13

2.0 14

Component studies

15

Early studies

Rhino 3D modeling software was used to sketch out some initial concept ideas which were based around a rectilinear form. These components combined to make some initial tests.

Looking back at the precedent studies and feedback from the presentation it was clear, both the number of components, and the variation of connection needed more explorations.

PERFECT PACK? Initial shape studies looked at octahedrons and dodecahedrons which pack together perfectly. This perfect packing is not an objective - because it provides little porosity of the whole. This porosity is what is alluring in the creations - a quality seen in the precedent studies..

These explorations should start with working out the initial pairings between two components and move forward from this point.

Dodecahedrons

Early studies of ‘c’ and ‘v’ components.

16

V component

An initial study into the ‘v’ component followed the route of a 2D plane. This developed a mix of combinations including perfect packing and more open structure.

Combining with a second unit a more 3-dimensional form was tested. It was becoming more sculptural but lacked architectural meaning.

Both of these studies have shown some inaccuracies with the original geometry which produces anomalies with the packing.

1 unit

2 units

17

Compound components

Whilst the sculptural results seen prior lacked 1 unit architectural qualities the compound component provided some interesting forms and to better understand this, a larger component was developed offsetting the ‘v’ to its neighbor and copying a second row before mirroring this element The result below used rotations of this component to produce an open ended sculpture.

700 units

18

20 units

C Component 1 unit 2D

+ 1 rotation

Revisiting an initial concept to study further the possibilities for combinations,. The first series is based around 2-dimensional aggregation, later a rotation was added to then develop a 3- dimensional opportunity for ‘growth’.

Sketching connections

19

The geometry here moves further away from perfect packing, and whilst that was the aim, these combinations and results do not offer any order which can generate spatial conditions desired..

20

wasp for grasshopper

https://www.food4rhino.com/app/wasp

It was not until further into the exploration of aggregated components that I discovered a Grasshopper plugin that could be used to test ideas.

INPUT In summary it requires three elements as input: Geometry you want to aggregate.

Connection nodes (points) Axis of rotation (defined by the direction of a curve) OPTIONS: You can define options for colliders - shapes will not generate where they clash with others.

Rules The next step is to set up rules for connections to take place. Depending on the number of nodes depends on the number of rules you will need to create.

For example if you only have two nodes, only two possible combinations / rules can be defined - 0 to 1 and 1 to 0.

For the example shown there are three, and therefore multiplying the number of rules to 6 Here the rules have been set up with number sliders to change the connections quickly. However, panels could be used instead.

The rules are then merged and fed into the aggregation component.

21

Aggregate The component takes the geometry, rules and an input for the number of aggregations you wish to make.

Reset button is used if parameters are adjusted.

created with wasp, render and photoshop

22

prism component study

Taking inspiration from the Polyomino II projects, a non rectilinear component was tested. Evolving from sketches into a prism with sloping sides, one end triangular, the other a quad.

The intention was to achieve rotations with these sloped sides, instead of actually ‘bending’ the extrusion as with the rectilinear components.

Prism component with Wasp 1 unit Nodes + Rotation

Different rules were applied as follows:

rules: 1 to 0

Warning - could not create all parts.

This was found to be that the collider discovery was turned on. With this arrangement overlapping would occur and therefore the definition could not create 100 components as they would clash with already aggregated components.

23

rules: 0-1; 2-2

rules: 0-2; 1-2; 2-2; 2-2; 2-1; 2-0

rules: 0-1; 2-1

24

rules: 0-2; 1-2; 2-2; 2-2; 2-1; 2-0

The anticipated results are not quite as expected. It is possible to achieve the rotations and develop a spiral amongst other forms.

A further test was creating a spiral combination and then to use that as a component to ‘pack’. The geometry is not valid for packing.

25

WASP DEVELOPMENT

Rules generator It is also possible, instead of processing rules manually to use the Rules Generator component within Wasp to generate the possible connections from the input parameters (points).

With a panel you can view the connection possibilities generated for the 4 points shown.

The generator requires additional options, you must determine:

• •

‘Self - P : this controls the possibility for connections between the same part - must be set to true if you only have one part , as this example..

‘Self-C: this allows connection between nodes with the same ID, for example 0 to 0, 1 to 1 etc.

To further explain we can use a panel to view the connection calculations with different settings: Self - p true Self - C False

full definition

26

Self - p true Self - C False

Self - p false Self - C true / false just to test!

v Component with Wasp 1 unit Nodes + Rotation

Self - p true Self - C False

x 100

x 500

x 1000

27

C Component with Wasp 1 unit Nodes + Rotation

x 100

x 500

x 1000

28

Self - p true Self - C False

Analysis Wasp is allowing quicker and more precise explorations of What it tells us about this ‘C’ component is important for the next steps. The component offers interesting the discrete components and consequently is revealing what the geometry has to offer in terms of: sculptural patterns with an open structure, although as you increase the number of aggregations the density • solid / void increases. What it lacks, like the other examples is an • density architectural condition for space or orientation for • porosity example.

• grids • directions • patterns 29

geometry inaccuracies

There seemed to be a reoccurring issue which, should have been more obvious. There were some inaccuracies with the packing of some of the elements, namely the ‘V’ component.

0

After some analysis and review, whilst the shape had been created with a square section , the ends had different face shapes to the other faces.

0

1

0

0

1

0 0

0

0

0

0

0

0 0 0

30

0

0

0

0

0

0

0

0

0

0

final Developments

31

V2.0 Component Studies - 2D 1 unit

With the revised geometry of V2.0 studies of combinations commenced with 2D arrangements.

These produced interesting and promising results, the balance between perfect and imperfect packing produced variation and porosity but also moments of solid.

The potential for architectural conditions is high.

32

Nodes

combinations

Self-P true Self-C False.

55 connections

x 100

x 500

x 1000

33

V2.0 Component Studies - 3D1 1 unit

Nodes + rotation

The parameters set create very similar conditions to those of the initial studies, primarily because they have centralised connections and are not dissimilar in form.

centralised connections

However, due to the revised geometry there are more organised / non overlapping connections seen previously.

The resulting combinations are, without direction or orientation which is something desired.

34

Self-P true Self-C False 55 connections

x 100

x 500

x 1000

35

V2.0 Component Studies - 3D2 1 unit

Nodes + rotation

Self-P true Self-C false 55 connections

By mixing centralised and de-centralised connections its possible to gain yet more variety with the combinations. and it achieves a higher mix of both perfect packing elements and open structure.

centralised connections

de-centralised connections

The architectural conditions of ground plane, landscape, boundaries and verticality all are visible.

36

x 100

x 500

x 1000

37

Testing Self-C True / False

x 1000

38

x 1000

The fundamental difference between these are the number of vertical elements (as you look at the image here). Self-C false creates more ‘ground’ than self-c true.

39

x 5000 40

41

Transform Component

Now the base definitions are set to great the combined geometries it became an interest to use the transform component tool within Wasp to great a field of parts.

MOVE It works by taking the Part defined as with all the previous definitions. Then you apply a move action with a factor and vector.

The moved component is then merged with the original to effectively create two start locations for aggregation.

Rotation A rotation can be added defined by an angle using a number slider and setting the angle on the Rot3D component. Lastly the axis of rotation.

This rotates both original part and the moved part together.

Separate Rotations To rotate these separately you have to do apply the rotation before merging and then routing back to aggregate.

Full definition

42

2d planes with rotation

2d plane with 3D offset height

43

44

45

x 60,200 46

47

3.0 48

gamescapes

49

Why Games?

Games are universally used, enjoyed and shared. They do Building Blocks not require language or particular communication skills for people to interact with them, play them and have fun. Discrete components, like the ones in question are ideal for this platform. Players would choose from A global movement known as Block by Block has either a singular component / voxel and start building. been engaging communities worldwide through Alternatively a kit of parts can be generated which the users could interact with and build. games. Communities in need of change, architectural interventions such as community centres, play parks, areas of regeneration for example. Block by Block uses Minecraft, a voxel based game to add the communities into participation.

The game mechanics of Minecraft are taught to the people after which they will use it themselves to model the existing context, and then start to propose designs. It is a very intuitive and easy to use platform.

The members of the community, regardless of language can now participate in the design process.

1

2

3

4 1. Involving Locals: https://static1.squarespace.com/static/5a2ed5d18c56a8af94f22a6f/5ac68ee6f950b7dbff2aa296/5ac68ee76d2a733cc9e4408a/1523029353513/Dandora_2-1-1024x1024.jpg?format=500w 2. Design Ideas from Community: https://static1.squarespace.com/static/5a2ed5d18c56a8af94f22a6f/5ac690e9aa4a99ed1aa67a40/5ac690e9562fa7e9614b5f23/1523029451818/Silanga_1-1-1024x1024.jpg?format=1000w 3. Logo: https://static1.squarespace.com/static/5a2ed5d18c56a8af94f22a6f/t/5a79f3760d9297e49c4296fb/1564083644257/?format=1500w 4. Neighborhoods modeled in Minecraft: https://static1.squarespace.com/static/5a2ed5d18c56a8af94f22a6f/5ac6944f6d2a733cc9e575c4/5ac6961588251bfbef2ef7cd/1523028887471/Jerusalem+Minecraft.png?format=1000w 50

tools

1

2

To build the game Unity 3D will be used as a platform.

coding in visual studio

why unity?

• • • • •

Unity ships with a code writer which is OK. Visual studio, however, is a bit more professional, has more It has multiple tools for developing both 2D and 3D functionality. For example when writing a line of code, it games accross a number of platforms. will automatically suggest options for completing it - this It supports Java and C# coding languages amungst is very useful for reducing time when writing. others It has built in functions like collison detection, rendering, material creation, standard assets Vast asset store and gitHub repository - lots of developers are writing for Unity which boosts its popularity.

It is a blank canvas when it comes to game design you can build what you want with your style.

Unity 3D interface

learning C# in Unity To learn the mechanics of a game and the notion of aggregating components we built a octahedron in Rhino 3D, exported as FBX, placed within the Unity Assets folder.

From here we bought it into the game play area and then started to write code for aggregating them.

The method used was via raycasting and mouse clicks to create new objects.

The following pages explain the journey through developing this initial setup, problems, developments and further trials.

Visual Studio 2017 interface

1. Unity Logo: https://unity3d.com/files/images/ogimg.jpg?1 2. Visual Studio Logo: https://www.pngkey.com/png/detail/126-1260500_visual-studio-2013-logo-microsoft-visual-studio-team.png 3. Unity Interface 51

raycasting

First steps: Variables – these appear throughout the script. Public variables like these are then visible within unity to adjust.

Ray casting – a method of emitting a ray in a direction of the mouse which is able to ‘hit’ other objects and then be used as a trigger.

Other methods could be used to interact such as preselection where the user selects the object with the mouse and then follow with a command, much like 3D modelling software. Raycasting was chosen is a more intuitive and fun method To start the line renderer component on ‘Play’,.

Define where to start and end the raycast including line width:

52

To continue seeing the raycast as a ‘pointer’ it needs to be rendered continuously:

Via setting layers in Unity and then calling those in the script its possible for the raycast to determine what you are hitting and therefore separate out an object or group.

An Octa Layer was created inside unity and then the script uses a line to look for that particular layer.

We then ask the script to report in the debug log “you are hitting an object” if this layer is hit:

53

instantiating

For a simple instantiation on a shape such as an octahedron it is possible to use face normals and scaling to inform the position of the new, instantiated component.

Once ‘hitting’ and object, on click, a new vector will be created at a position relating to the normal direction of the face being hit:

This references scale factors:

These are used to create the new vector separate from the initial one, scale is used to create the new vector in a location scaled from the original.

The values are publicly floated for easy access in the Unity UI. It is also necessary to determine the rotation of the new vector:

INSTANTIATE!

and also still draw the raycaster even if we don’t hit and object:

54

SCale factor By adjusting the scale factor you can see the different results (right). It is possible, if you create the original geometry mathematically that you can calculate the exact scale factor values to use.

all aggregations in the same location...

wrong position / scale factor...

correct!

55

problem solving

script errors This was caused by incorrect parenthesis placement and terms used within the definition.

Static Raycaster The raycaster would not follow the mouse / cursor position correctly. This was solved by, instead of casting from the cameras position, creating a child game object which follows the camera. Then casting from that game object. raycaster too short Very simply, the values which determine the length were too small.

TESTING INSTANTIATE METHODS This was a test to instantiate from nothing, without a mouse click, almost as a automation. It worked but the player became trapped in the infinity of components.

56

Working Definition

57

DESTROY GAME OBJECT

You can only go so far with a design by simply creating, it is necessary that the user can delete components at their will.

A simple destroy command was added to the script. The mouse input was initially tested using the debug log and adding ‘CREATE’ or ‘DESTROY’ depending on which mouse button was clicked. 0 (left) for create, 1 (right) for destroy.

This destroyed the original game object. At first it was not clear why, but it was because the original game object is known as ‘obj’ and thus is deleted using this arrangement.

intended to destroy top left 58

original destroyed despite raycast target

MESH COLLIDER After some research it was discovered that the mesh collider of the components can be called upon in the script as to destroy the component that is the target.

This worked successfully deleting the game object .

clones still remain It was noticed that the instantiated components (clones) would remain listed in the Hierarchy, even after being destroyed. At first, this was not clear but using logic it was due to the destroy command only destroying the game object within the mesh collider.

So whilst you could not see the game objects, they were in fact still in the game.

hierarchy with clones still visible

no components in game 59

Rotation

Rotation was the next item required to give the user more The answer is thought to lie with a different method of options. instantiating:>>> The option to be able to rotate the game object after instantiating was desired. So, a similar technique to that of the destroy was used - to look for a mesh collider and then on middle mouse button click rotate the hit object 45 degrees around the Y axis (up). However, when instantiating new voxels on rotated ones they have the same rotation as the original.

starting location

60

45o on Y axis (up)

Instantiate without normals

To instantiate with another game object rather than using face normals would give better functionality, especially when using non semmetrical or perfect packing shapes.

This method should allow you to place new units based on the empty game object (child) rather than calculating normal distances.

An empty game object as a child to main unit was created, a gizmo with a colour script was used to visualise the empty game object.

starting location

45o on Y axis (up)

61

refinement The piviot point method was refined from the previous version.

The components seem to instatiate correctly!

62

reporting Mesh Faces

The method of using game object / pivot point to instantiate is working, however to intantiate in different directions / from different sides the ID of the mesh face being hit by the Raycast is required.

This was the attempt at reporting this information:

To test, a debug log string was added.

Something is working:

63

UNITY GAME SCREEN / UI A simple User Interface (UI) in the game would give about the number of components and the number of rotations.

64

65

postface

The project mostly achieved what it set out to do, albeit with some incomplete elements and development. The explorations into the discrete component have been extensive, especially with help from digital tools such as Wasp were discovered.

Another area I feel this could develop is into the construction of the component itself - perhaps taking the form of a ply or engineered timber component which can be manufactured, on mass, easily. Physical model studies would be an interesting activity initially.

The refined geometry that became the final component produced a number of architectural conditions sought.

Ground planes, steps, landscape, solid, voids were all present and the resulting systems made for compelling imagery and speculation into the future of our architectural vernacular.

What the project has done, is expose an area of study unknown at the commencement of the module.

Development of skills, knowledge and understanding into discreteness, grasshopper, Unity 3D and Visual studio. It is also the first exposure to C# coding.

The game side of the project has potential to keep developing. The status of the game is not where it was intended to be at this stage, however, largely the mechanics of a simple aggregation platform are in place and I feel it is close to being a working prototype.

66

This will continue to be a subject area of fascination and will shape future endeavours.

67

Bibliography

Texts Cited: AD, 2019. Discrete: Reappraising the Digital in Architecture. Wiley.com, AD 89.

Mario Carpo, author, 2017. The second digital turn: design beyond intelligence / Mario Carpo., Writing architecture. The MIT Press, 2017, Cambridge, Massachusetts.

Sanchez, J., 2017. Combinatorial Commons: Social Remixing in a Sharing Economy. Architectural Design, AD 87, 16–21. https://doi.org/10.1002/ad.2190 Images: Block By Block Logo [WWW Document], n.d. URL https://static1.squarespace.com/static/5a2ed5d18c56a8af94f22a6f/t/5a79f3760d9297e49c4296fb/1564083644257/?format =1500w (accessed 7.29.19).

Design By the Community [WWW Document], n.d. URL https://static1.squarespace.com/static/5a2ed5d18c56a8af94f22a6f/5ac690e9aa4a99ed1aa67a40/5ac690e9562fa7e96 14b5f23/1523029451818/Silanga_1-1-1024x1024.jpg?format=1000w (accessed 7.29.19). dezeen_Heydar-Aliyev-Centre-by-Zaha-Hadid-Architects_3_1000.gif (1000×485) [WWW Document], n.d. URL http://static.dezeen.com/uploads/2013/07/dezeen_HeydarAliyev-Centre-by-Zaha-Hadid-Architects_3_1000.gif (accessed 7.29.19). digitalbuildingblocksgillesretsinta.jpg (1200×600) [WWW Document], n.d. URL https://cdnimd.worldarchitecture.org/extuploadc/digitalbuildingblocksgillesretsinta.jpg (accessed 7.29.19).

Gallery of Kengo Kuma Designs Sculptural Pavilion in Paris - 11 [WWW Document], n.d. . ArchDaily. URL https://www.archdaily.com/776541/kengo-kuma-designs-sculpturalpavilion-in-paris/5642463ae58ecee8fb00001d-kengo-kuma-designs-sculptural-pavilion-in-paris-photo (accessed 6.17.19).

Involving Locals [WWW Document], n.d. URL https://static1.squarespace.com/static/5a2ed5d18c56a8af94f22a6f/5ac68ee6f950b7dbff2aa296/5ac68ee76d2a733cc9e440 8a/1523029353513/Dandora_2-1-1024x1024.jpg?format=500w (accessed 7.29.19).

Jerusalem+Minecraft.png (1000×595) [WWW Document], n.d. URL https://static1.squarespace.com/static/5a2ed5d18c56a8af94f22a6f/5ac6944f6d2a733cc9e575c4/5ac69615 88251bfbef2ef7cd/1523028887471/Jerusalem+Minecraft.png?format=1000w (accessed 7.29.19). ogimg.jpg (1200×630) [WWW Document], n.d. URL https://unity3d.com/files/images/ogimg.jpg?1 (accessed 7.29.19).

Polyomino 3 [WWW Document], n.d. URL https://images.squarespace-cdn.com/content/v1/582f98dbb3db2be72dc14252/1479688325705-VD9M2MIA3ERK5XML3USF/ ke17ZwdGBToddI8pDm48kFAonjahnhx-fb8iNiRCEMp7gQa3H78H3Y0txjaiv_0fDoOvxcdMmMKkDsyUqMSsMWxHk725yiiHCCLfrh8O1z4YTzHvnKhyp6DaNYroOW3ZGjoBKy3azqku80C789l0s2R59z2HWVKMNU9GXmUK4UgMjTvwYN7hN4bXKHX5lIeBces2etgvgd1JwkJgxHn7w/image-asset.jpeg?format=1000w (accessed 7.28.19).

Polyomino assembly [WWW Document], n.d. URL https://images.squarespace-cdn.com/content/582f98dbb3db2be72dc14252/1496353729897-V33N18BJO7X2H5PUQJUU/?f ormat=1000w&content-type=image%2Fjpeg (accessed 7.26.19).

Wasp logo [WWW Document], n.d. URL https://static.food4rhino.com/s3fs-public/styles/thumbnail/public/users-files/andrea-rossi/app/logo01hexabkg.jpg?itok=LuWDWH7V (accessed 7.27.19).

Research: Autonomous Assembly: Designing for a New Era of Collective Construction, 2017. . Wiley.com, AD 87.

Carpo, M., 2013. The digital turn in architecture 1992-2012 / edited by Mario Carpo., AD reader. Wiley, Chichester.

Digital Property: Open-source Architecture, 2016. . Wiley.com, AD 86.

MagicaVoxel [WWW Document], n.d. URL https://ephtracy.github.io/ (accessed 7.29.19).

Plethora Project [WWW Document], n.d. . Plethora Project. URL https://www.plethora-project.com/ (accessed 7.29.19).

Polyomino II [WWW Document], n.d. . Plethora Project. URL https://www.plethora-project.com/polyomino-ii (accessed 7.29.19).

Polyomino III [WWW Document], n.d. . Plethora Project. URL https://www.plethora-project.com/polyomino-iii (accessed 7.29.19).

ZHA CODE Lecture, The building Centre, London, 2018.

Learning: Community [WWW Document], n.d. . Unity. URL https://unity3d.com/community (accessed 7.29.19).

Creating Custom Pivots in Unity - YouTube [WWW Document], n.d. URL https://www.youtube.com/watch?v=itIh8PYGP7w (accessed 7.29.19).

IMG_6257-1.jpg (1000×667) [WWW Document], n.d. URL https://images.squarespace-cdn.com/content/5862810cff7c506c994f91bb/1544592002312KX94F0JAQEKPMQ605HBN/IMG_6257-1.jpg?format=1000w&content-type=image%2Fjpeg (accessed 7.29.19).

68

Learning Continued: The best place for answers about Unity - Unity Answers [WWW Document], n.d. URL https://answers.unity.com/index.html (accessed 7.29.19).

The Nature of Code [WWW Document], n.d. URL https://natureofcode.com/book/ (accessed 11.13.18).

Unity - Scripting API: [WWW Document], n.d. URL https://docs.unity3d.com/ScriptReference/ (accessed 7.29.19).

Video Tutorials [WWW Document], n.d. . Plethora Project. URL https://www.plethora-project.com/education (accessed 7.28.19).

69

Appendix - Seminar Presentation

Through the first digital turn our field harnessed the capabilities of parametric design, the ability to encode and control the relationship between a number of parts using a set of rules to control how they behave.

Arguably the centre of this movement was the spline - an infinitely smooth curve at any scale. Which can be described with this mathematical equasion, a compact, economical, small-data shorthand we use to replace what is in fact an extraordinarily long list of numbers.”¹ The resulting architecture of the spline achieved differentiation through variation – each component different to the next. Realisation of these designs became possible through mass-customization, yet manufacture of these geometries often required lower-resolution panelisation strategies to allow tools to conform to the infinite smoothness of a spline.²

70

Advances in computing has seen a rejection of these small-data methodologies as dealing with big data becomes increasingly accessible, which has given rise to the imperfect. “The messy point-clouds and volumetric units of design and calculation that result from these processes are today increasing shown in their apparently disjointed and fragmentary state; and the style resulting from this mode of computation is often called voxelization, or voxelation.â€?Âł

Voxels need not be subject to geometric simplification for manufacture, instead the grain, or resolution, can be set to a particular requirement or desired outcome. For example, large-format building components could be described as a collection of low-resolution voxels, each of several metres in size but in turn, could be manufactured from high-resolution printed pieces. Unlike splines voxelised creations achieve differentiation through pattern rather than variation of parts, thus lending themselves to mass production techniques.

71

Minecraft, a video game based on voxel building blocks, where-by players can create worlds using just voxels, however, arguably the most attractive feature of this game is its participatory element - the ability to collaborate with others to create worlds. Once a vision this participatory turn seems to have been rejected by the architecture and design and this provides a valuable lesson for us to learn from. Furthermore, Minecraft can be played in immersive VR. Mine craft is at the centre of a global participatory movement known as Block by Block where by communities around the world are engaged with the urban design process through the simple platform of the voxel-based game.

VIDEO Immersive design tools such as Google Tilt Brush remove boundaries of traditional architectural illusions (drawings or 2D images), and provide a design canvas concurrently with design feedback – experience. With experience comes a greater level of understanding and potentially a greater power to participate. This is a therefore a very powerful media for architectural representation and equally an opportunity for a new way of designing - to experience concurrently with design.

72

VIDEO However, where Tiltbrush and similar applications offer an infinite realm of possibility I am intrigued by the pre-determined conditions that a combinatorial system can offer. This is particularly useful with the involvement of unskilled users.

Furthermore it allows the designer some form of control over the particular language and behaviours seen in the outputs.

The notion of fragmented geometry is also interesting as are the possibilities of experience and making design decisions within immersive environment. My research will look to design a discrete unit(s) of small scale (approx. 1m3) and an immersive platform in which to create, interact and experience the resulting system.

Daniel Widrig – appears to utilise a kit of parts of the same geometric language.

73

Jose Sanchez – Polyomino Illustrates expandability and connectivity between voxels.

Jose Sanchez – Polyomino II An initial shape was developed / expanded into a group of components. These components have then produced an overall larger system.

74

Polyomino III Again, a selection of parts were used to create groups and a impressive mixture of spatial conditions and porosity.

I have noticed a common thread. The resulting creations are somewhat pre determined though the inherit geometry of the shapes used to create them but the number of combinations is vast, far different from traditional construction which often only has one way of fitting together.

Theory and context reading

75

Tools Rhino – creating geometry Unity – game environment Visual Studio – coding HTC Vive for first person interaction

First steps: Variables – these appear throughout the script. Public variables like these are then visible within unity to adjust.

Ray casting – a method of emitting a ray in a direction of the mouse which is able to ‘hit’ other objects and then be used as a trigger.

Other methods could be used to interact such as pre-selection where the user selects the object with the mouse and then follow with a command, much like 3D modelling software. Raycasting was chosen is a more intuitive and fun method.

Using layers is one way in which to determine what you are hitting and therefore separate out an object or group.

An Octa Layer was created inside unity and then the script uses a line to look for that particular layer.

76

3. Instantiating With this we are telling unity to, if we hit an object on the octas layer to create a new vector offset from the trigger game object by a scale factor which is a multiplication of the hit face normal to the centre of said object.

Because the normal distances were not know I made the scale factors public so we could edit them without having to go back into the script. The images here show the failed attempts at the normal offset distances.

Issues Static raycaster and inaccurate mouse tracking – seemed to be solved by using a cube that follows the camera to raycast from.

Automatic creation of cubes without click of mouse Script errors – incorrect parenthesis placement and terms used.

Raycaster too short – solved by increasing the ray caster distance.

77

it works

I wanted to be able to Destroy voxels.

First attempt killed the initial game object not the one you pointed at. This is because the command was simply telling the game object ‘OBJ’ to destroy. The new objects are ‘clones’ of the original.

78

VIDEO So by asking it to look for a mesh collider and check if a null reference. Therefore, on a ‘hit’ you can interact with the cloned objects.

Rotation was the next item I wanted to add to give the user more options.

I wanted the option to be able to rotate the game object after instantiating. So I employed a similar technique to that of the destroy, to look for a mesh collider and then on middle mouse button click rotate the hit object 45 degrees around the Y axis (up). However, when instantiating new voxels on rotated ones they have the same rotation as the original!

79

Unit designs 1 This first attempt I proceeded to try in Unity whilst it was an interesting test it was clear the aggregation parameters needed more work to optimise this shape.

Unit designs 2 This I feel has some potential and relatively simple connection conditions.

80

Unit design 3 Concerned about the expandability / variation this offers but like the voids created.

Unit design 4 Lots of variation, complex joining strategies – needs to be developed further.

81

Dodecahedron Semi perfect packing – leaves holes but little variation.

Empty game object as a child to main unit and added a gizmo colour script so I can more easily place them.

This method should allow you to place new units based on the empty game object (child) rather than calculating normal distances.

82

I have discovered that the destroyed game objects are not deleted from the hierarchy. I believe this to be because the actual game objects are within a prefab. So the prefab still remains in the scene and hierarchy but the game object is deleted.

Also if the original object is destroyed you can no longer instantiate.

I tried destroy immediate as that would remove any time influences on the command instead of just destroy but that worked the same despite where I clicked.

83