Jihee Kim_SectionD_Project-10-Landscape

jiheek1_project10_sketch

//Jihee Kim
//15-104 MWF 9:30
//jiheek1@andrew.cmu.edu
//Project 10 Landscape
//section D


var stars = []; // an array of all stars
var clouds = []; // an array of all clouds


function setup() {
    createCanvas(480, 380);
    // initialize stars
    for (var s = 0; s < 750; s++){ // loop through stars
        var starPositionX = random(width); // the x position of the cloud is
                                           // random along the width of canvas
                                           // the randomness is later set
                                           // in the replaceClouds() function
        var starPositionY = random(0, height-120);
        stars[s] = makeStars(starPositionX, starPositionY);
    }
    // initialize clouds
    for (var i = 0; i < 5; i++){ // loop through clouds
        var cloudPositionX = random(width); // the x position of the cloud is
                                            // random along the width of canvas
                                            // the randomness is later set
                                            // in the replaceClouds() function
        var cloudPositionY = random(height/3, height*2/3);
        clouds[i] = makeCloud(cloudPositionX, cloudPositionY);
    }
}


function draw() {
    //WATER
    fill(11, 19, 71);
    rect(0, height-100, width, 100); // set the very bottom of the canvas as
                                     // water
    //gradient background
    // draw the gradient background for the pink, night sky
    var top = color(198, 96, 113); // pink
	  var bottom = color(11, 19, 71); // deep blue
    Gradient(0, width, top, bottom);
    //STARS
    animateStars();
    hideStars();
    addStars();
    //MOON
    drawMoon();
    //CLOUDS (draw the clouds using functions: animate, hide, and add)
    animateClouds();
    hideClouds();
    addClouds();

}


//BACKGROUND
function Gradient (a, b, top, bottom) {
	  // top to bottom gradient (background)
    for (var i = a; i <= height-100; i++) {
        var mappedC = map(i, a, a+b, 0, 1);
        var c = lerpColor(top, bottom, mappedC);
        stroke(c);
        strokeWeight(2);
        line(a, i, a+b, i);
	  }
}


//STARS
function drawStars() {
	  noStroke();
	  // make stars seem like they're shining by manipulating transparency
	  var transparency = random(30, 100);
	  fill(255, transparency);
	  ellipse(this.x, this.y, 1.2, 1.2);
}


function animateStars() {
    for (var s = 0; s < stars.length; s++) {
        stars[s].move();
        stars[s].draw();
    }
}


function hideStars() {
    // make the clouds that are actually within the canvas to stay
    // if not, hide them
    var starsOnCanvas = [];
    for (var s = 0; s < stars.length; s++){ // go through all clouds
        // if the star is on the canvas
        if (0 < stars[s].x < width) {
            starsOnCanvas.push(stars[s]); // draw the stars that are on the
                                          // canvas
        }
    }
    stars = starsOnCanvas; // update the stars to the ones that are actually
                           // on the canvas
}


function addStars() {
    var randomValStar = 0.01; // a really small chance of stars randomly
                                // being added/generated
    if (random(0,1) < randomValStar) { // because it is not that likely for a
                                      // randomly chosen value to be less than
                                      // 0.0001, this will be a rare occasion
        var starPositionX = random(0, width);
        var starPositionY = random(0, height-120);
        stars.push(makeStars(starPositionX, starPositionY)); // generate new
                                                             // stars along
                                                             // the canvas
    }
}


function starMove() {
	//move stars by updating x coordinate
	this.x += this.speed;
}


function makeStars(starPositionX, starPositionY) {
	  var star = {x: starPositionX,
				       y: starPositionY,
				       speed: -random(0, .005),
				       move: starMove,
			         draw: drawStars}
	  return star;
}


//MOON
function drawMoon() {
    ellipseMode(CENTER);
    noStroke();
    fill(252, 202, 202, 80);
    ellipse(width/2+100, 150, 80); // overlay another ellipse for slight volume
    fill(234, 139, 139, 80);
    ellipse(width/2+100, 150, 75); // draw moon
}

// CLOUDS
function animateClouds() {
    for (var i = 0; i < clouds.length; i++){ // loop through all clouds
        clouds[i].move(); // update the clouds' positions on canvas
        clouds[i].display(); // display the clouds
    }
}


function hideClouds(){
    // make the clouds that are actually within the canvas to stay
    // if not, hide them
    var cloudsOnCanvas = [];
    for (var i = 0; i < clouds.length; i++){ // go through all clouds
        if ((clouds[i].x > 0) + (clouds[i].breadth > 0)) { // if the cloud is
                                                      // on the canvas
            cloudsOnCanvas.push(clouds[i]); // draw the clouds that are on the
                                            // canvas
        }
    }
    clouds = cloudsOnCanvas; // update the clouds to the ones that are actually
                           // on the canvas
}


function addClouds() {
    var randomVal = 0.005; // a really small chance of clouds randomly
                           // being added/generated
    if (random(0,1) < randomVal) { // because it is not that likely for a
                                   // randomly chosen value to be less than
                                   // 0.005, this will be a rare occasion
        var cloudPositionX = random(0, width);
        var cloudPositionY = random(height/3, height-50);
        clouds.push(makeCloud(cloudPositionX, cloudPositionY)); // generate new
                                                                // clouds along
                                                                // on canvas
    }
}


function cloudMove() { // update position of cloud each frame
    this.x += this.cloudSpeed;
}


function cloudDisplay() { // draw clouds
    var cloudHeightFactor = 7; // factor that determines cloud height
    var cloudHeight = this.nFloors * cloudHeightFactor;
    ellipseMode(CENTER);
    fill(242, 209, 214, this.transparency);
    noStroke();

    // higher line of clouds (further down on canvas)
    push();
    translate(this.x, height/2-130);
    ellipse(30, -cloudHeight+120, this.breadth, cloudHeight);
    pop();
    // middle line of clouds (middle on canvas)
    push();
    translate(this.x, height/2-70);
    ellipse(150, -cloudHeight+120, this.breadth, cloudHeight/1.5);
    pop();
    // lower line of clouds (further down on canvas)
    push();
    translate(this.x, height/2);
    ellipse(110, -cloudHeight+120, this.breadth, cloudHeight);
    pop();
}

function makeCloud(cloudPositionX, cloudPositionY) {
    var cloud = {x: cloudPositionX, // x position of clouds
                y: cloudPositionY, // y position of clouds
                transparency: random(10, 80),
                breadth: random(120, 250), // width of clouds
                cloudSpeed: random(0.07, 0.3), // speed at which clouds move
                nFloors: round(random(2,10)),
                move: cloudMove,
                display: cloudDisplay}
    return cloud;
}

For my ever-changing “landscape” I decided to draw a starry night. In order to make the image dynamic, I used components such as the stars and clouds that actually move and generate on it’s own based on a logic that incorporates randomness. I used a color gradient for a more engaging background as well.
I wanted to convey tranquility and I believe that I was able to achieve that goal through employing movements that speak to that.

Concept Sketch

project-10-generativeLandscape

For this project, the first thing that came to mind for a landscape was a sky with a sun, grass and people. It was a fairly simple and straight forward idea. To embellish it, I added some clouds and mushrooms. I used simple shapes to create the various objects: people, mushrooms, clouds.

I made slight differences in the height and y placement of the people, mushrooms and ground to create more depth and also layered the light clouds and dark clouds with the sun to add more depth. There are some randomized variables such as the colors of the dresses, and various sizes of things.

sketch

//array for each set of objects
var people = [];
var mushrooms = [];
var dclouds = [];
var lclouds = [];

function setup() {
  createCanvas(480, 300);
  frameRate(5); //slow down frame rate
  for(var i = 0; i < 5; i++){ //fills array with 5 people
    people.push(makePerson());
  }
  for(var j = 0; j < 7; j++){ //fills array with 7 mushrooms
    mushrooms.push(makeMushroom());
  }
  for(var k = 0; k < 3; k++){ //fills array with 3 dark clouds
    dclouds.push(makeDarkCloud());
  }
  for(var q = 0; q < 3; q++){ //fills array with 3 light clouds
    lclouds.push(makeLightCloud());
  }
}

function draw () {
  background(203, 238, 243);
  noStroke();
  fill(133, 183, 157);
  rect(0, 200, width, 100); //ground
  for(var k = 0; k < dclouds.length; k++){ //access dark clouds array
    dclouds[k].draw(); //draws dark clouds
    dclouds[k].move(); //moves dark clouds
  }
  fill(249, 220, 92);
  ellipse(400, -40, width/2, width/2); //sun
  for(var q = 0; q < lclouds.length; q++){ //access light clouds array
    lclouds[q].draw(); //draws light clouds
    lclouds[q].move(); //moves light clouds
  }
  for(var j = 0; j < mushrooms.length; j++){ //access mushrooms array
    mushrooms[j].draw(); //draws mushrooms
    mushrooms[j].move(); //moves mushrooms
  }
  for(var i = 0; i < people.length; i++){ //access people array
    people[i].draw(); //draws people
    people[i].move(); //moves people
  } 
}

function makePerson() { //creates people
  var person = {px: random(0, 480),       //person x position
                py: 205,                  //person y position
                pheight: random(20, 50),  //person height
                pcolor: random(0, 255),   //person color
                pspeed: -10               //person speed
                }
  person.draw = drawPerson; //sets draw function
  person.move = movePerson; //sets move function
  return person; 
}

function makeLightCloud() { //creates light clouds
  var lcloud = {lx: random(0, 480),       //light clouds x position
                ly: 70,                   //light clouds y position
                lspeed: -1,               //light clouds speed
                lwidth: random(140, 180)  //light clouds width
                }
  lcloud.draw = drawLightCloud; //sets draw function
  lcloud.move = moveLightCloud; //sets move function
  return lcloud;
}

function makeDarkCloud() { //creates dark clouds
  var dcloud = {dx: random(0, 480),       //dark clouds x position
               dy: 50,                    //dark clouds y position
               dspeed: -2,                //dark clouds speed
               dwidth: random(140, 180)   //dark clouds width
               }
  dcloud.draw = drawDarkCloud; //sets draw function
  dcloud.move = moveDarkCloud; //sets move function
  return dcloud;
}

function makeMushroom() { //creates mushrooms
  var mushroom = {mx: random(0, 480),     //mushroom x position
                  my: 200,                //mushroom y position
                  mheight: random(5, 20), //mushroom height
                  mspeed: -3,             //mushroom speed
                  mwidth: random(20, 40)  //mushroom width
                  }
  mushroom.draw = drawMushroom; //sets draw function
  mushroom.move = moveMushroom; //sets move function
  return mushroom;
}

function drawPerson() { //draws people
  fill(this.pcolor);
  triangle(this.px - 10, this.py, this.px + 10, this.py, this.px, this.py - this.pheight); //body
  fill(245, 228, 215);
  ellipse(this.px, this.py - this.pheight, this.pheight - 10, this.pheight - 10); //head
}

function drawMushroom() { //draws mushrooms
  fill(255);
  rect(this.mx - 5, this.my - this.mheight - 10, 10, this.mheight + 10, 5); //stem
  fill(237, 187, 187);
  arc(this.mx, this.my - this.mheight, this.mwidth, 20, PI, 0, PIE); //head
}

function drawDarkCloud() { //draws dark clouds
  fill(184, 215, 219);
  ellipse(this.dx, this.dy, this.dwidth, 50); //cloud
}

function drawLightCloud() { //draws light clouds
  fill(212, 247, 252);
  ellipse(this.lx, this.ly, this.lwidth, 50); //cloud
}

function movePerson() { //moves people
  this.px += this.pspeed; //x position decreasing
  if(this.px < 0){ //pops up on right edge of canvas once off left edge
    this.px = width;
  }
}

function moveMushroom() { //moves mushrooms
  this.mx += this.mspeed; //x position deacreasing
  if(this.mx < 0){ //pops up on right edge of canvas once off left edge
    this.mx = width;
  }
}

function moveDarkCloud() { //moves dark clouds
  this.dx += this.dspeed; //x position decreasing
  if(this.dx < 0 - this.dwidth/2){ //starts appearing on right edge once completely off left edge
    this.dx = width + this.dwidth/2;
  }
}

function moveLightCloud() { //moves light clouds
  this.lx += this.lspeed; //x position decreasing
  if(this.lx < 0 - this.lwidth/2){ //starts appearing on right edge once completely off left edge
    this.lx = width + this.lwidth/2;
  }
}

Jihee Kim (Section D)– LookingOutwards-10

Filtered Transparencies – LISBON 2015 from Filipa Valente on Vimeo.

Filtered Transparencies is an dynamic, interactive installation that manipulates the users’ experience within a space through different sensual elements. The installation uses multiple layers of light streams and sound to surround the user inside the project and allow for a unique experience. What is interesting about this project is how the artist creates an intangible but clearly-present space. There is nothing concrete or structural in the project (even the screens that light is projected are light and transparent), yet the user feels as though there are some sort of massive elements that are surrounding them because of the illusions created by the “filters” of sensual elements. The installation is also interactive in that people could manipulate themselves the kind of environment that they are in.

user immersed in created space
tangible space
layered screens and experience

The artist, Filipa Velante is an architect and environmental designer based in the US. She did her studies in Architecture both at the undergraduate and graduate level at the Bartlett School of Architecture in London. Additionally, she completed her Masters in Media Art and Architecture Mediascapes at SciArc, LA. Based on the projects that are curated on her website, one can clearly notice her concentration on experiential design, whether in the form of architectural projects or media installations like Filtered Transparencies. Many of her projects are those that engage the public through the incorporation of environment and senses, as is manifested in this particular project, as well.

Velante originally designed the installation for the Paseo Festival in Taos, New Mexico in September 2014. Later on, a further developed version was commissioned for the WEDO User Group 2015 conference in Lisbon, Portugal.

More information on the project can be found on the Project Page

akluk-Project-10-Generative Landscape

Initially, I was going to make a generative landscape based on microscopic creatures. Such as what you would see under a microscope. However I later decided to go one layer more, and tried to portray the subatomic environment. For this project, I wanted to create a subatomic generative landscape. So the basis of in the subatomic environment, is the atom. And I had to decide how to create differing forms of atoms. Then I realized that atoms with different sizes also create different elements. I created 3 types of possible moving objects which are different sized atoms, with electrons wizzing around them. Below attached are some of my sketches.

Sketches for atoms

sketch

//Alvin Luk
//Section A
//akluk@andrew.cmu.edu
//Project 10

var atoms = [];


function setup() {
    createCanvas(480, 480); 
    
    // create an initial collection of buildings
    for (var i = 0; i < 10; i++){
        var rx = random(width);
        atoms[i] = makeAtom(rx);
    }
    frameRate(20);
}


function draw() {
    background(0); 
    
    push();
    
    stroke(0);
    fill(0); 
    rect(0,0, width, height);
    
    displayStatusString();

    updateAndDisplayAtoms();
    removeAtomsThatHaveSlippedOutOfView();
    addNewAtomsWithSomeRandomProbability(); 
    pop();
}


function updateAndDisplayAtoms(){
    // Update the building's positions, and display them.
    for (var i = 0; i < atoms.length; i++){
        atoms[i].move();
        atoms[i].display();
    }
}


function removeAtomsThatHaveSlippedOutOfView(){
    // If a building has dropped off the left edge,
    // remove it from the array.  This is quite tricky, but
    // we've seen something like this before with particles.
    // The easy part is scanning the array to find buildings
    // to remove. The tricky part is if we remove them
    // immediately, we'll alter the array, and our plan to
    // step through each item in the array might not work.
    //     Our solution is to just copy all the buildings
    // we want to keep into a new array.
    var atomsToKeep = [];
    for (var i = 0; i < atoms.length; i++){
        if (atoms[i].x + atoms[i].breadth > 0) {
            atomsToKeep.push(atoms[i]);
        }
    }
    atoms = atomsToKeep; // remember the surviving buildings
}


function addNewAtomsWithSomeRandomProbability() {
    // With a very tiny probability, add a new building to the end.
    var newAtomLikelihood = 0.02; 
    if (random(0,1) < newAtomLikelihood) {
        atoms.push(makeAtom(width));
    }
}


// method to update position of building every frame
function atomMove() {
    this.x += this.speed;
}
    

// draw the building and some windows
function objectDisplay() {
    var floorHeight = 20;
    var particle_size = 20;
    var bHeight = this.nFloors * floorHeight; 
    fill(120); 
    noStroke(0); 
    push();
    translate(this.x, this.y);
    stroke(0);
    if (this.breadth == 1){
    	fill(color(255,0,0));
    	ellipse(0, 0, particle_size, particle_size);
    	fill(color(0,0,255));
    	ellipse(particle_size/4, particle_size/4 , particle_size, particle_size);
    }
    else if (this.breadth == 2){
    	fill(color(255,0,0));
    	ellipse(-particle_size/4, -particle_size/4, particle_size, particle_size);
    	fill(color(0,0,255));
    	ellipse(particle_size/4, -particle_size/4 , particle_size, particle_size);
    	fill(color(255,0,0));
    	ellipse(-particle_size/4, particle_size/4, particle_size, particle_size);
    	fill(color(0,0,255));
    	ellipse(particle_size/4, particle_size/4 , particle_size, particle_size);
    }
    else{
    	fill(color(255,0,0));
    	ellipse(-particle_size/3, particle_size/3, particle_size, particle_size);
    	fill(color(0,0,255));
    	ellipse(0, -particle_size/3 , particle_size, particle_size);
    	ellipse(particle_size/3, particle_size/3, particle_size, particle_size);
    }

    noStroke();
    fill(color(180,180,40));
    for (var i = 0; i < this.nFloors; i++) {
        ellipse(random(-particle_size,particle_size), random(-particle_size,particle_size), 5, 5);
    }
    pop();
}


function makeAtom(birthLocationX) {
    var bldg = {x: birthLocationX,
    			y: round(random(0,height)),
                breadth: random([1,2,3]),
                speed: -1.0,
                nFloors: round(random(2,8)),
                move: atomMove,
                display: objectDisplay}
    return bldg;
}


function displayHorizon(){
    stroke(0);
    line (0,height-50, width, height-50); 
}


function displayStatusString(){
    noStroke(); 
    fill(0); 
    var statusString = "# Atoms = " + atoms.length;
    text(statusString, 5,20); 
}

mmirho – Project 10 – Inside a Submarine

This is supposed to show what it would be like to look out of a submarine!

Different color and sized fish fly by at different speeds, as you peek through the portholes.

I will admit, however, I was unable to figure out how to use objects effectively without blatantly copying the format given to me. Instead, I used loops and if statements, and I understand I did this project incorrectly. However, I hope it satisfies the requirement for a landscape! 🙂

I plan to schedule some office hours to more fully understand how objects function. Sorry!

sketch

function setup() {
    createCanvas(480, 480);
    
}

//Creates fish x location for each 
//fish to increment with speed
var fishX1 = 0;
var fishX2 = 0;
var fishX3 = 0;

//Assigns speed values for each fish
var speed1 = 0;
var speed2 = 0;
var speed3 = 0;

//Assigns vertical location values for each fish
var up1 = 0;
var up2 = 0;
var up3 = 0;


//Assigns r, g, and b values for each fish
var r1 = 0;
var r2 = 0;
var r3 = 0;
var g1 = 0;
var g2 = 0;
var g3 = 0;
var b1 = 0;
var b2 = 0;
var b3 = 0;

//Assigns size variables to each of the three fish
var big1 = 0;
var big2 = 0;
var big3 = 0;


function draw() {
    background(255);

    //This assigns random variables to each fish
    //so they are a random size, speed, location, and color
    if (fishX1 < 1) {
        speed1 = random(0.1,2);
        up1 = height/2 + random(-50,50);
        r1 = random(0,200);
        g1 = random(0,200);
        b1 = random(0,200);
        big1 = random(10,30);
    } else if (fishX2 < 1) {
        speed2 = random(0.1,2);
        up2 = height/2 + random(-50,50);
        r2 = random(0,200);
        g2 = random(0,200);
        b2 = random(0,200);
        big2 = random(10,30);
    } else if (fishX3 < 1) {
        speed3 = random(0.1,2);
        up3 = height/2 + random(-50,50);
        r3 = random(0,200);
        g3 = random(0,200);
        b3 = random(0,200);
        big3 = random(10,30);
    }

    //Moves the fish at a random speed
    fishX1 += speed1;
    fishX2 += speed2;
    fishX3 += speed3;

    //Makes each fish
    fish(fishX1, up1, big1, r1,g1,b1)
    fish(fishX2, up2, big2, r2,g2,b2)
    fish(fishX3, up3, big3, r3,g3,b3)



    //Makes the submarine inside background
    subBackground();


    porthole(width/4, height/2);
    porthole(3*width/4, height/2);

    //resets the location of the fish at 0 when it 
    //reaches the end

    if (fishX1 > width) {
        fishX1 = 0;
    } else if (fishX2 > width) {
        fishX2 = 0;
    } else if (fishX3 > width) {
        fishX3 = 0;
    }
}

function porthole(x,y) {

    //Makes a porthole, with the inside slightly blue
    //but translucent, so it acts like a window

    fill(0, 0, 200, 80);
    strokeWeight(30);
    stroke(200);
    ellipse(x,y,height/3,height/3);

}

function fish(x,y,big,r,g,b) {

    //Makes a fish with an ellipse and a triangle

    fill(r,g,b);
    noStroke();
    ellipse(x,y,big*2,big)
    triangle(x-big/2,y,   x-big*1.5,y+big/2,   x-big*1.5,y-big/2);
    fill(0);

    //adds a little eye
    ellipse(x+3*big/5, y-big/4.5, 3,3);

}

function subBackground() {

    //Fills in the outside of the portholes with
    //green, indicating the inside of the submarine

    fill(0,70,0);
    rectMode(CENTER);
    rect(width/2, height/2, 100, height);
    rect(width/2 - 237, height/2, 100, height);
    rect(width/2 + 237, height/2, 100, height);
    rect(width/2, height/2-215, width, 300);
    rect(width/2, height/2+215, width, 300);

}

mmirho – Looking Outwards 10 – perfect.city

perfect.city is a project developed by Mary Flanagan. The project is an exploration of the South Korean city of Songdo, a planned international metropolis developed by Gale International. The city is designed to be perfect. Mary modeled it in the program Sims 2, and I personally respect this because it takes the enormous scale project of building a city, and boils it down to a simple generated simulation. If the design is so “Perfect” then let’s see what happens when people are put there. It’s almost a culture test, rather than just a theoretical prediction.

Mary Flanagan is an inventor, artist, writer, and designer that creates games, installations, poetry, and essays. I’m unsure as to where she studied, but she has presented at a wide range of top universities and is very active in general with all of her writing and artistic creation.

Here’s a link to the project on her page:

[perfect.city]

Here’s the video link:

 

aboyle-Looking Outwards-10

“TRANSCENDENCE 115” is a collaboration between the digital artist LIA and the Portuguese experimental music project @c, created by Miguel Carvalhais and Pedro Tudela. It was created for the composition *Three-Body Problem* and was released in 2016. The starting point is a “system of forms and actions, an algorithm for visual composition,” which is then enhanced by the music and LIA’s interaction. You can watch it below.

I really admire this work because it seamlessly weaves together audio and visual in a way that is very difficult to do. Low heaves of noise push forward rounded lines, and high tinkling sounds fracture them into angles—it is endlessly entertaining to watch and listen to. I also love the way it uses orbits and patterns to make the entire image seem full, cohesive, and mesmerizing.

LIA, the co-creator of “TRANSCENDENCE 115”, is known for being a pioneer in software art. She is an Austrian artist who lives in Vienna and has been active since 1995. She uses a wide range of media, such as video, performance, software, installations, sculpture, projections, and digital applications. However, her primary working material is code, which she leverages for fluid and conversational interaction between human and machine. You can view more of her work at http://www.liaworks.com/.

danakim-LookingOutwards-10

Geode is a series of geologically inspired puzzles created by Jessica Rosenkrantz from Nervous System. She used agates as inspiration for the puzzles. I found it particularly interesting how she mimicked the way agates are naturally formed in the algorithm that her computer generated agates emerge from. For each generated agate, colors were derived from photos that were taken by Jessica.

Jessica Rosenkrantz is the co-founder and creative director at Nervous System. She graduated from MIT with degrees in biology and architecture. She also studied at the Harvard Graduate School of Design. She focuses on generative design methods using both algorithmic and physical tools to create innovative products and environments. She pulls inspiration from the complex and unconventional geometries in natural forms.

Jessica Rosenkrantz; Geode; 2017

katieche-project-10

katieche-10

/*
katie chen
katieche@andrew.cmu.edu
project 10
section e
*/

var terrainSpeed = 0.0002;
var terrainDetail = 0.002;
var backdetail = 0.003;
var clouds = [];
var cacti = [];
var camelfr = [];
var cam = [];

function preload() {
	var camelfile = [];
		camelfile[0] = "https://i.imgur.com/bDUcYTm.png";
		camelfile[1] = "https://i.imgur.com/6dVVrob.png";
		camelfile[2] = "https://i.imgur.com/hbSKaEk.png";
		camelfile[3] = "https://i.imgur.com/7mLCzwN.png";
		camelfile[4] = "https://i.imgur.com/ajswkv9.png";
		camelfile[5] = "https://i.imgur.com/5PYiIL8.png";
		camelfile[6] = "https://i.imgur.com/izwJZyn.png";
		camelfile[7] = "https://i.imgur.com/bHlNbyH.png";

		for(var i =0; i < 8; i++){
			camelfr[i] = loadImage(camelfile[i]);
		}
}


function setup() {
    createCanvas(480, 480);

    // making initial collection of objects
    for (var i = 0; i < 10; i++){
    	var rx = random(width);
        clouds[i] = makeCloud(rx);
        cacti[i] = makeCactus(rx);
        cam[i] = makeCam(rx);
    }

  	frameRate(10);
}
 
function draw() {
    background(185, 174, 176);
    push();
    noStroke();
    fill(188, 177, 178);
	rect (0, 140, width, height-140);
	fill(195, 180, 176);
    rect (0, 170, width, height-170);
   	fill(200, 185, 176);
    rect (0, 230, width, height-230);
    fill(207, 187, 172);
    rect (0, 260, width, height-260);
    pop();
    
    ground();

	updateAndDisplayCacti();
	cactusAdd();

	updateAndDisplayCam();
    camAdd();
    camDisplay();

    updateAndDisplayClouds();
	cloudAdd();
    
}

function ground() {
	// background
    push();
    beginShape(); 
    noStroke();
	fill(200, 164, 140); 
    for (var x = 0; x < width; x++) {
        var t = (x * backdetail) + (millis() * terrainSpeed);
        var y = map(noise(t), 0,1, 200, height-50);
        vertex(0,480);
        vertex(480,480);
        vertex(x, y); 
    }
    endShape();
    pop();

    // foreground
	push();
    beginShape(); 
    noStroke();
	fill(181, 121, 78); 
    for (var x = 0; x < width; x++) {
        var t = (x * terrainDetail) + (millis() * terrainSpeed);
        var y = map(noise(t), 0,1, 270, height);
        vertex(0,480);
        vertex(480,480);
        vertex(x, y); 
    }
    endShape();
    pop();
}

function updateAndDisplayClouds(){
    // Update the clouds' positions, and display them.
    for (var i = 0; i < clouds.length; i++){
        clouds[i].move();
        clouds[i].display();
    }
}


function cloudAdd() {
    // With a very tiny probability, add a new cloud to the end.
    var newcloudLikelihood = 0.02; 
    if (random(0,1) < newcloudLikelihood) {
        clouds.push(makeCloud(width));
    }
}

// moving the clouds
function cloudMove() {
    this.x += this.speed;

}
    
// drawing the clouds
function cloudDisplay() {
	push();
	translate(this.x, 50);
	noStroke();
	if (this.z < 30) {
		fill(225, 210, 192);
	}

	if (this.z > 30 & this.z < 50) {
		fill(222, 202, 182);
	}
	if (this.z > 50) {
		fill(218, 194, 174);
	}
	
	rect(23+this.x, 50+this.z, 100+this.l, 25+this.h, 200, 200, 200, 200);
	rect(60+this.x, 25+this.z, 50, 50, 200, 200, 200, 200);
	rect(50+this.x, 35+this.z, 30, 30, 200, 200, 200, 200);
	pop();

}

// making the clouds
function makeCloud(cx) {
    var cloud = {x: cx,
    			z: random(0, 150),
    			l: random(0,20),
    			h: random(0,20),
 				speed: -1.0,
                move: cloudMove,
                display: cloudDisplay
            }
    return cloud;
}

// CACTUS
function updateAndDisplayCacti(){
    // Update the cacti positions, and display them.
    for (var i = 0; i < cacti.length; i++){
        cacti[i].tmove();
        cacti[i].tdisplay();
    }
}

function cactusAdd() {
    // With a very tiny probability, add a new cactus to the end.
    var newcactusLikelihood = 0.02; 
    if (random(0,0.5) < newcactusLikelihood) {
        cacti.push(makeCactus(width));
    }
}

// moving the cactus
function cactusMove() {
    this.mx += this.mspeed;

}

// draw the cactus
function cactusDisplay() {
    push();
    noStroke();
    translate(this.mx, 200);
    fill(131-this.cr, 170, 124-this.cr);
    rect(50+this.mx,50+this.cacter,25+this.wid, 90+this.hei, 200, 200, 0,0);
    rect(50+this.mx+this.wid,80+this.cacter,40,10,200,200,200,200);
    rect(80+this.mx+this.wid,60+this.cacter,10,30,200,200,200,200);
    rect(30+this.mx,90+this.cacter,40,10,200,200,200,200);
    rect(30+this.mx,70+this.cacter,10,30,200,200,200,200);
    pop();
}

// making the cacti
function makeCactus(tx) {
    var cactus = {mx: tx,
 				mspeed: -2.5,
 				hei: random(-10,20), // tallness of main cactus body
 				wid: random(0,5), // fatness of main cactus body
 				cr: random(0,50), // color 
 				cacter: random(70, 180), // y value
                tmove: cactusMove,
                tdisplay: cactusDisplay
            }
    return cactus;
}

// CAMEL
function updateAndDisplayCam(){
    // Update the camel positions, and display them.
    for (var i = 0; i < cam.length; i++){
        cam[i].cmove();
        cam[i].cdisplay();
    }
}

function camAdd() {
    // With a very tiny probability, add a new camel to the end.
    var newcamLikelihood = 0.02; 
    if (random(0,1) < newcamLikelihood) {
        cam.push(makeCam(width));
    }
}

// moving the camel
function camMove() {
    this.camx += this.cspeed;

}

function camDisplay() {
    push();
    noStroke();
    scale(0.3);
    for (var i = 0; i < 10; i++) {
    var num = frameCount % 8;
        image(camelfr[num],600, 900);
    }
    pop();
}

// making the camel
function makeCam(ax) {
    var camel = {camx: ax,
 				cspeed: -1.0,
                cmove: cactusMove,
                cdisplay: cactusDisplay
            }
    return camel;
}

I had a lot of fun working on this project. I wanted to create a desert landscape, so I selected colors from an image of the grand canyon. I made the background sort of have a gradient to give more of a “never ending stretch of land” horizon line feeling. The cactuses were a fun addition that I created in p5.js before realizing that I could’ve made them in illustrator and uploaded them as image files. Upon realization, I decided to add the moving camel. The original gif is from here, but I took each frame and edited it in illustrator to make it look more uniform in my code.

BrandonHyun-LookingOutwards10

Daily tous les jours is a company that creates interactive pieces in a public setting. Mouna Andraos who founded the company Daily tous les jours and she has a principal saying that “The design studio uses technology and storytelling to explore collaboration, the future of cities and the power of humans. They are best known for their work in public spaces, where passing crowds are invited to play a critical role in the transformation of their environment and their relationships. Their projects lie at the intersection of digital arts, performance and placemaking, utilizing contemporary tools that range from sensors, cameras, mobile phones and real-time data, to musical instruments, dance choreographies, writing, food and meditation.”

Her works are mostly presented in a public setting where all types of people can interact and bring positive change to the society that they present their work in.

One of their companies project was the Market Street Prototyping and it is shown in the Video.

Daily tous les jours website

Mouna Andraos bio