Created in January 2017 by Sasha Vinogradova, Gods of Egypt is a print series that reimagines Egyptian gods as more contemporary characters. The figures themselves – Anubis, Hathor, and Horus, in order – are sculpted and rendered using Maxon Cinema 4D and Zbrush, then manipulated with photo editing software for the final print.
Anubis and Horus from Vinogradova’s “Gods of Egypt”
I’ve always been interested in mythology and ancient world religions, so to see them reimagined into something more modern while keeping the original context in mind is really admirable. Vinogradova achieves this with an incredible degree of photorealism that I initially thought this was straight photography and photomanipulation. It’s a really interesting and satisfying blend of mediums that Vinogradova includes here, with small graphical elements bringing out the quality of the sculpture.
This project along with Vinogradova’s other work can be found on both her website and Behance.
Jonathan Zawada is a graphic designer who is responsible for the cover artwork and graphics for Flume’s “Skin” album. He creates these moving 3D animations using algorithms.
If you have not seen these incredibly amazing graphics, here is a video of what they can do:
Zawada in a short video explains his process of using little algorithms to create the appearance of each petal and the fractal growth factor that really makes this not just some nature advertisement.
The thing I found so cool about this project is how he states how easy it would be if he were just to paint these, but he feels that this is cheating.
“There is something real about plugging in the numbers and that feels real.”
Something about his process makes these look so real but so unimaginably complex and mesmerizing.
I can truly see the artist’s feelings and concept of reality manifesting in the artwork. It is interesting to take the flowers out of a musical context and relate to what is actually happening in the artist life.
“Nature and Algorithm” is a 100-day consecutive project created by a multidisciplinary artist and programmer Liu Chang. Throughout the 100 days, she collected textural landscape photos and transformed them into dimensional, abstract productions through an algorithm she developed independently.
Day 035Day 048Day 012
What was drawn to me the most was her consistency with her choice of medium, as well as her juxtaposition between the original landscape images and computer-generated “landscapes” — the latter one especially intriguing, since the transformation was applied with similar color tone, shadows, and even pattern, but the image is no longer the same, and only functions as a representation of the image. I was also curious about why the artist describes the project as “a question to the relationship between nature and AI.” Unfortunately, she did not mention the softwares and algorithms used for this project, but relating to this comment, I think she is inquiring for a line between authenticity and artificiality, and how how we can incorporate learned AI into reality but still different from reality.
You could view more of her 100-day work here: http://www.liuchang.work/#/natureandalgorithm/
I found this post in the CGSSociety website, which is a large platform for creative digital artists. After browsing the pages, I found this Time Travelers House most attractive to me.
This set of renderings are most inspiring to me because as an architecture student, I am well aware of the difficulty of 3D renderings. First, the author needs to build a 3D model in SketchUp or Rhino even though the result is only a 2D image. When she was trying to render the model the materials are really hard to find or choose. After rendering the model, you need to render the background using Photoshop. It is so amazing that I could not find any flaw in these renderings. It really inspires me to learn photoshop and vray well so that one day, I can do the renderings as cool as she does.
I think the purpose of those photo-realistic renderings are that, first, they can give people to realistic overall sense towards the context of the house- the imitated experience of being there. Then, good renderings for household can really attract more buyers to purchase the house. Finally, I feel like every rendering has its own emotion as well. It conveys to audience some feeling, sometimes regretness, sometimes sadness, and sometimes curiosity. I think this one gives me the feeling of curiosity, which matches with its theme Time Travelers House as well.
It is quite amazing that the 3D rendering technologies nowadays are so advanced that 3D computer graphics are able to create images that sometimes even seem more realistic than photograph.
The 3D graphics project that I chose to discuss is “Walking City” by Universal Everything. The project is an evolving video sculpture which slowly and constantly changes its form through many permutations. The only thing that remains constant in the video are the colors, and the core motion/act of walking. The project references the utopian visions of 1960’s architecture practice, Archigram. The video aims to capture the patterns seen in the radical architectural transformations. Though 3D motion graphics usually bore me, I am pretty captivated by the delicate transitions from form to form. I really appreciate how the artist actually made me anticipate each transformation, and how much character each “version” gave to the walking figure. I am really not sure how the creators rendered or generated this work, but I assume that it is some 3D modeling program combined with mathematical algorithms to create the perfectly geometrical shapes. The artist’s sensibilities are manifested in the work seeing the way that it is so uniquely clean, monochromatic, and geometric.
Pedro Conti is a freelance character designer from São Paulo. His most recent work is for Walt Disney Animation Studios on the movie Moana. Conti mainly worked on creating the two barges in the movie and the trash on them. It was a total of 140 shots which he had to code to create. The attention to detail is immediately transparent. Hundreds of tiny objects had to be coded. Not only did all of the tiny objects have to be coded, but they had to be textured as well. One of the biggest challenges was that of making the barges look realistic. Conti started with the bigger graphic elements and worked his way down in layers to smaller objects to reach a final image without any intersecting lines.
//Scarlet Tong
//sntong@andrew.cmu.edu
//Section A
// Project 5: Wallpaper
//x and y coordinates the tip of the tear drops
var x = 0;
var y = 0;
// scale
var Large = 25;
var Medium = Large-1;
var Small = Large-5;
// for loop coordinates
var transY = 0;
var transX = 30;
function setup() {
createCanvas(480, 480);
background (243,117,117);//hot pink!
}
function draw() {
//array the pattern on the odd rows
for (var transY = 0; transY < width; transY+= Large*6+15) {
for (var transX = 0; transX < width+30; transX+= Large*2+10) {
pattern(transX,transY);
}
}
// array the pattern for even rows and offset them so they fill the gap
for (var transY = -Large*3-8; transY < width; transY+= Large*6+15) {
for (var transX = Large+5; transX < width; transX+= Large*2+10) {
pattern(transX,transY);
}
}
noLoop();
}
function pattern(transX,transY){
stroke(255);
strokeWeight(1);
//deep blue tear drop, aka large drop
push();
translate(transX,transY);
fill(48,78,109,200);
beginShape();
curveVertex(x,y);
curveVertex(x,y);
curveVertex(Large,Large*3);
curveVertex(x,Large*4);
curveVertex(x-Large, y+Large*3);
curveVertex(x,y);
curveVertex(x,y);
endShape();
pop();
//pale orange tear drop, medium drop
push();
translate(transX,transY+Large*6);
fill(237,168,131,100);
angleMode(DEGREES);
rotate(180);
beginShape();
curveVertex(x,y);
curveVertex(x,y);
curveVertex(Medium,Medium*3);
curveVertex(x,Medium*4);
curveVertex(x-Medium, y+Medium*3);
curveVertex(x,y);
curveVertex(x,y);
endShape();
// teal tear drop, small drop
fill(43,188,177,120);
beginShape();
curveVertex(x,y+10);
curveVertex(x,y+10);
curveVertex(Small,Small*3+10);
curveVertex(x,Small*4+10);
curveVertex(x-Small, y+Small*3+10);
curveVertex(x,y+10);
curveVertex(x,y+10);
endShape();
//yellow circle
fill(253,185,74,200);
ellipse(x,Small*5,Large,Large);
//small dark blue circle on the tip of the shape
fill(48,78,109);
ellipse(0,0,10,10);
pop();
}
I was inspired by the the features of a peacock when making this pattern. Using the tear drop shape as the base, I was able to rotate and scale the shape accordingly to generate the pattern before I array it to make the wallpaper using for loops and nested loops. I used Rhino to help me to generate the line work before going into Illustrator to add in the color. As I was coding I also played with the alpha channels to manipulate the opacity of the colors to see the layers of tear drops that make up the pattern.
//Jihee Kim
//15-104 MWF 9:30
//jiheek1@andrew.cmu.edu
//project5 WallPaper
//section D
function setup() {
createCanvas(480, 480);
noStroke();
}
function draw() {
background(0);
// make a grid of colorful ellipses
//draw small ellipses on top of grid to make crescent shapes
//the position of smaller ellipses changes the orientation of the crescent
//form a heart shape with the crescents in the middle of canvas
//other black voids should look like fish
drawGrid();
// form crescents on left half of canvas
// draw smaller circles that cover up bottom right of the bigger circles
for (var y = 25; y < height+40; y += 40) { // offset center by 5
for (var x = 25; x < width/2; x += 40) {
fill (0);
ellipse(x, y, 30, 30); // draw smaller circles
}
}
// draw rectangles that look like eyes for the fish on left
for (var y = 20; y < height+40; y += 40) { // offset center by 5
for (var x = 20; x < width/2-40; x += 40) {
fill (255);
rect(x, y, 3, 3); // draw rectangles
}
}
// form crescents on right half of canvas
// draw smaller circles that cover up bottom left of the bigger circles
for (var y = 25; y < height+40; y += 40) { //offset center by -5
for (var x = width/2 + 15; x < width+40; x += 40) {
fill (0);
ellipse(x, y, 30, 30); // draw smaller circles
}
}
// draw rectangles that look like eyes for the fish on right
for (var y = 20; y < height+40; y += 40) { // offset center by 5
for (var x = width/2 + 60; x < width; x += 40) {
fill (255);
rect(x, y, 3, 3); // draw rectangles
}
}
// each heart is where fish lay eggs. draw arrays of dots
// if needed divide up the line and treat the heart as item with two sides
// arrays converge in the middle
for (var y = 13; y < height + 30; y += 40) {
// line 1 (left)
for (var x = width/2 - 19; x < width/2 - 10; x += 6) {
fill(255); //white dots
ellipse(x, y, 1, 1);
}
}
for (var y = 13; y < height + 30; y += 40) {
// line 1 (right)
for (var x = width/2 + 12; x < width/2 + 19; x += 6) {
fill(255);
ellipse(x, y, 1, 1);
}
}
for (var y = 16; y < height + 30; y += 40) {
// line 2 (left)
for (var x = width/2 - 25; x < width/2 - 3; x += 6) {
fill(255);
ellipse(x, y, 1, 1);
}
}
for (var y = 16; y < height + 30; y += 40) {
// line 2 (right)
for (var x = width/2 + 6; x < width/2 + 27; x += 6) {
fill(255);
ellipse(x, y, 1, 1);
}
}
for (var y = 19; y < height + 30; y += 40) {
// line 3 (left)
for (var x = width/2 - 25; x < width/2 -1; x += 6) {
fill(255); //white dots
ellipse(x, y, 1, 1);
}
}
for (var y = 19; y < height + 30; y += 40) {
// line 3 (right)
for (var x = width/2 + 6; x < width/2 + 26; x += 6) {
fill(255);
ellipse(x, y, 1, 1);
}
}
for (var y = 22; y < height + 30; y += 40) {
// line 4 (left)
for (var x = width/2 - 24; x < width/2; x += 6) {
fill(255);
ellipse(x, y, 1, 1);
}
}
for (var y = 22; y < height + 30; y += 40) {
// line 4 (right)
for (var x = width/2 + 5.5; x < width/2 + 26; x += 6) {
fill(255);
ellipse(x, y, 1, 1);
}
}
for (var y = 25; y < height + 30; y += 40) {
// line 5 (left)
for (var x = width/2 - 29; x < width/2; x += 6) {
fill(255);
ellipse(x, y, 1, 1);
}
}
for (var y = 25; y < height + 30; y += 40) {
// line 5 (right)
for (var x = width/2 + 4.5; x < width/2 + 31; x += 6) {
fill(255);
ellipse(x, y, 1, 1);
}
}
for (var y = 28; y < height + 30; y += 40) {
// line 6 (left)
for (var x = width/2 - 28; x < width/2; x += 6) {
fill(255);
ellipse(x, y, 1, 1);
}
}
for (var y = 28; y < height + 30; y += 40) {
// line 6 (right)
for (var x = width/2 + 3.5; x < width/2 + 32; x += 6) {
fill(255);
ellipse(x, y, 1, 1);
}
}
for (var y = 31; y < height + 30; y += 40) {
// line 7 (left)
for (var x = width/2 - 26; x < width/2; x += 6) {
fill(255);
ellipse(x, y, 1, 1);
}
}
for (var y = 31; y < height + 30; y += 40) {
// line 7 (right)
for (var x = width/2 + 2; x < width/2 + 29; x += 6) {
fill(255);
ellipse(x, y, 1, 1);
}
}
for (var y = 34; y < height + 30; y += 40) {
// line 8
for (var x = width/2 - 24; x < width/2 + 26; x += 6) {
fill(255);
ellipse(x, y, 1, 1);
}
}
for (var y = 37; y < height + 30; y += 40) {
// line 9
for (var x = width/2 - 21; x < width/2 + 24; x += 6) {
fill(255);
ellipse(x, y, 1, 1);
}
}
for (var y = 40; y < height + 30; y += 40) {
// line 10
for (var x = width/2 - 12; x < width/2 + 17; x += 6) {
fill(255);
ellipse(x, y, 1, 1);
}
}
for (var y = 43; y < height + 30; y += 40) {
// line 11
for (var x = width/2 - 8; x < width/2 + 10; x += 5) {
fill(255);
ellipse(x, y, 1, 1);
}
}
for (var y = 46; y < height + 30; y += 40) {
// line 12
for (var x = width/2 - 4; x < width/2 + 7; x += 4) {
fill(255);
ellipse(x, y, 1, 1);
}
}
for (var y = 49; y < height + 30; y += 40) {
// line 13
for (var x = width/2 - 2; x < width/2 + 4; x += 4) {
fill(255);
ellipse(x, y, 1, 1);
}
}
for (var y = 52; y < height + 30; y += 40) {
// line 14
for (var x = width/2; x < width/2 + 2; x += 2) {
fill(255);
ellipse(x, y, 1, 1);
}
}
for (var y = 55; y < height + 30; y += 40) {
// line 15
for (var x = width/2; x < width/2 + 2; x += 2) {
fill(255);
ellipse(x, y, 1, 1);
}
}
noLoop();
}
function drawGrid() {
//cover canvas with grid of ellipses
for (var y = 20; y < height+40; y += 40) {
for (var x = 20; x < width + 40; x += 40) {
fill(249 - x/2, 145, 145); // apply a color gradient to the circles
ellipse(x, y, 40, 40);
}
}
}
For this project, I wanted to apply learned concepts and use grids and loops. Using the same shape(ellipses) at different scales and varying the position of them, I created a flowing pattern that takes advantage of both positive and negative spaces. I basically created crescents by using two different ellipses and by putting them in a grid, I made it so that the negative space( in black) would read as fish shapes and hearts. The heart-shaped spaces in the middle are filled with fish eggs!
Danilton: The Brutal Deluxe is a computational art project that was created by visual artist, Daniel Brown. The project is basically a rendered image that was first based on some photographs that were manipulated with an algorithmic program that the author created himself. There is not much information on the specifics of this program that he made, but considering the known fact that he did not 3D model each building components, one can assume that he could have used a plug-in similar to Grasshopper.
end product
To generate the parasitic, massive buildings, Brown first plugged in random numbers to the program that produces the masses through fractal mathematics. He then searches for a particular area or geometries that he finds interesting within the randomly generated field, or 3D graph and adds to that particular shape. He basically gets the general from through algorithms and make the shapes even more complex and interesting by applying images of apartments from the 1970s and having the computer to generate infinite patterns, thereby creating a giant, maze-like cityscape that looks both retro and futuristic to a certain extent.
Brown has always been exploring with mathematical space before and after Danilton (2016), trying to create unlimited, boundless environments without constraints of physical building and modeling each component. The particular project and his other works clearly reflect his desire to use computational design as a means to discover and explore areas that were perhaps intangible. It is interesting how computer programs made something like creating a hyper-realistic image with tremendous amount of detail more plausible for artists.
More information on the project and other computational art by Daniel Brown can be found on his website: Daniel Brown
More images are available here: Daniel Brown Flickr
Ian cheng is a contemporary artist who uses 3d animation and Artificial Intelligence to create “live simulations” that are infinite in duration and composed of both man-made and algorithmically generated content that together produce emergent behavior and sound.
The visual aesthetics that Ian produces is very interesting because it is rigid and fine with details. Even though the visuals are very interesting the behaviors that each character produces in his “live simulations” is what is so interesting. The algorithms that Ian produces is based from the game called the “Sims” and that became the reference for his algorithms.
Ian is not the visual creator for his artwork but it is the algorithms and the program that create these visuals and sounds. The manifesto that the program creates in this artwork is significant since we are heading into a era where Artificial Intelligence is becoming dominant.
![[OLD FALL 2017] 15-104 • Introduction to Computing for Creative Practice](../../../../wp-content/uploads/2020/08/stop-banner.png)
