Radical Reuse

everything is interconnected

Private influences public,

Salt reminds you of sugar,

Absence creates presence.

Although modern cities claim to have 24 hour access, the great majority of residents only experience city life during daylight hours.

Gentrification is written about by its winners and rarely through the eyes of the humans who truly experience an “urban” living.

In this assignment, I am focusing on the considerations of these frequently ignored people.

What happens when the city sleeps? What happens to the objects we forget?

NPR’s “Plastic” (left) + ArcGIS “City of Los Angeles Trash Collection Days Map” (right)

visualization of “access” for vulnerable populations

Variables:

• store access
• free supplies generated from “trash” (quality of use and optimization of plastic material)
• resting locations
• street advice

The plan from here:

Controlling the end result (aka the constellation of objects) to resemble a DIY housing unit made up of ingredients from the streets or typically, seen-as-useless materials.

This “house” will be located at the corner of the simulation while the main focus will be the traveling agent through the streets of downtown LA collecting various types of refuse based on city planning / vendor type.

public class Fractal : MonoBehaviour {
public Mesh[] meshes;
public Material material;
public int maxDepth;
public float spawnProbability;
public float childScale;
public float maxRotationSpeed;
public float maxTwist;
private int depth;
private float rotationSpeed;
private void Start()
{
rotationSpeed = Random.Range(-maxRotationSpeed, maxRotationSpeed);
transform.Rotate(Random.Range(-maxTwist, maxTwist), 0f, 0f);
if (materials == null)
{
InitializeMaterials();
}
gameObject.AddComponent<MeshFilter>().mesh =
meshes[Random.Range(0, meshes.Length)];
gameObject.AddComponent<MeshRenderer>().material = materials[depth, Random.Range(0,2)];
if (depth < maxDepth)
{
StartCoroutine(CreateChildren());
}
}
private Material[,] materials;
private void InitializeMaterials()
{
materials = new Material[maxDepth + 1,2];
for (int i =0; i <= maxDepth; i++)
{
float t = i / (maxDepth - 1f);
t *= t;
materials[i,0] = new Material(material);
materials[i,0].color = Color.Lerp(Color.white, Color.yellow, t);
materials[i, 1] = new Material(material);
materials[i, 1].color = Color.Lerp(Color.white, Color.cyan, t);
}
materials[maxDepth,0].color = Color.magenta;
materials[maxDepth, 1].color = Color.red;
}
private IEnumerator CreateChildren()
{
for (int i=0; i<childDirections.Length;i++)
{
if (Random.value < spawnProbability)
{
yield return new WaitForSeconds(Random.Range(0.1f,0.5f));
new GameObject("Fractal Child").AddComponent<Fractal>().
Initialize(this,i);
}
}
}
private void Initialize (Fractal parent, int childIndex)
{
meshes = parent.meshes;
materials = parent.materials;
maxDepth = parent.maxDepth;
depth = parent.depth + 1;
childScale = parent.childScale;
transform.parent = parent.transform;
transform.localScale = Vector3.one * childScale;
transform.localPosition = childDirections [childIndex] * (0.5f + 0.5f * childScale);
transform.localRotation = childOrientations[childIndex];
spawnProbability = parent.spawnProbability;
maxRotationSpeed = parent.maxRotationSpeed;
maxTwist = parent.maxTwist;
}
private static Vector3[] childDirections =
{
Vector3.up,
Vector3.right,
Vector3.left,
Vector3.forward,
Vector3.back
};
private static Quaternion[] childOrientations =
{
Quaternion.identity,
Quaternion.Euler (0f,0f,-90f),
Quaternion.Euler(0f,0f,90f),
Quaternion.Euler(90f, 0f, 0f),
Quaternion.Euler(-90f,0f,0f)
};
private void Update()
{
transform.Rotate(0f, rotationSpeed * Time.deltaTime, 0f);
}
}