Art Triangle Triangles


Project Code

This code is written and rendered using Processing (v3), a quick and easy graphical sketchbook engine written in Java
enum ShapeType {
	TRIANGLE,
	UPSIDE_DOWN_TRIANGLE
}

class Shape {
	ShapeType type;
	PVector center;
	float radius;
	float max_distance;
	
	int step = 0;
	int step_cycle = 180;
	float angle;
	
	float x1, y1;
	float x2, y2;
	float x3, y3;
	color col;
	
	Shape(ShapeType type_, PVector center_, float radius_) {
		type = type_;
		
		center = new PVector();
		center = center_.copy();
		
		radius = radius_;
		
		col = color(100);
		
		// default max distance from center to edge of sketch, set more accurately later
		setMaxDistance(dist(0, 0, (width / 2), (height / 2)));
		
		// calculate initial points
		calculatePoints(radius);
	}
	
	void setColor(color col_) {
		col = col_;
	}
	
	void setMaxDistance(float max_distance_) {
		max_distance = max_distance_;
		
		// setup starting step
		float distance_to_center = distanceToCenter();
		
		step = floor(map(
			distance_to_center,
			0,
			abs(max_distance),
			(step_cycle - 1),
			0
		));
		
		calculateColorBasedOnDistance();
	}
	
	void calculateColorBasedOnDistance() {
		float distance_to_center = distanceToCenter();
		
		col = color(map(distance_to_center, 0, max_distance, 0, 100), 100, 100);
	}
	
	void setAngle(float angle_) {
		angle = angle_;
	}
	
	float width() {
		return ((cos(radians(30)) - cos(radians(150))) * radius);
	}
	
	float height() {
		return ((sin(radians(150)) - sin(radians(-90))) * radius);
	}
	
	float distanceToCenter() {
		// calculate distance
		return dist(center.x, center.y, (width / 2), (height / 2));
	}
	
	void calculatePoints(float r_) {
		if(type == ShapeType.TRIANGLE) {
			x1 = (center.x + (cos(radians(-90 + angle)) * r_));
			y1 = (center.y + (sin(radians(-90 + angle)) * r_));
			
			x2 = (center.x + (cos(radians(30 + angle)) * r_));
			y2 = (center.y + (sin(radians(30 + angle)) * r_));
			
			x3 = (center.x + (cos(radians(150 + angle)) * r_));
			y3 = (center.y + (sin(radians(150 + angle)) * r_));
		} else if(type == ShapeType.UPSIDE_DOWN_TRIANGLE) {
			x1 = (center.x + (cos(radians(90 + angle)) * r_));
			y1 = (center.y + (sin(radians(90 + angle)) * r_));
			
			x2 = (center.x + (cos(radians(-30 + angle)) * r_));
			y2 = (center.y + (sin(radians(-30 + angle)) * r_));
			
			x3 = (center.x + (cos(radians(-150 + angle)) * r_));
			y3 = (center.y + (sin(radians(-150 + angle)) * r_));
		}
	}
	
	void calculateStepAngle() {
		int steps[];
		
		if(type == ShapeType.UPSIDE_DOWN_TRIANGLE) {
			steps = new int[2];
			steps[0] = 0;
			steps[1] = 90;
			//steps[2] = 200;
			//steps[3] = 300;
			//steps[4] = 400;
		} else {
			steps = new int[2];
			steps[0] = 0;
			steps[1] = 90;
			//steps[2] = 200;
			//steps[3] = 300;
			//steps[4] = 400;
		}
		
		
		int step_size = 45;
		int step_multiplier = 1;
		
		for(int i = 0; i < steps.length; i++) {
			if((step >= steps[ i ]) && (step <= (steps[ i ] + step_size))) {
				angle = map(step, steps[ i ], (steps[ i ] + step_size), 0, (360 * step_multiplier));
				
				break;
			}
			
			step_multiplier *= -1;
		}
		
		// trim angle
		if(angle >= 360) {
			angle = 0;
		} else if(angle <= -360) {
			angle = 0;
		}
	}
	
	color calculateAngledColor() {
		if((angle > 0) || (angle < 0)) {
			return col;
		}
		
		/*if(angle > 0) {
			float angle_amt = map(angle, 1, 359, 0, 1);
			
			//return color(map(angle, 1, 359, 0, 100), 100, 100);
			
			return lerpColor(
				color(100),
				col,
				angle_amt
			);
		} else if(angle < 0) {
			float angle_amt = map(angle, -1, -359, 0, 1);
			
			//return color(map(angle, -1, -359, 0, 100), 100, 100);
			return lerpColor(
				col,
				color(100),
				angle_amt
			);
		} else {*/
			if(type == ShapeType.UPSIDE_DOWN_TRIANGLE) {
				return color(20, 10, 10, 0);
			}
			
			return color(100);
		//}
	}
	
	void update() {
		// set next step
		step += 1;
		
		if(step > step_cycle) {
			step = 1;
		}
		
		calculateStepAngle();
		
		float step_radius = radius;
		
		if(angle != 0) {
			float middle_angle = 180;
			float radius_min = (radius * 0.3);
			
			step_radius = (radius - (radius_min * (1 - (abs(abs(angle) - middle_angle) / middle_angle))));
		}
		
		// calculate new points
		calculatePoints(step_radius);
	}
	
	void render() {
		pushMatrix();
		
		//white: fill(100);
		//distance color: fill(map(distanceToCenter(), 0, (width / 2), 100, 0), 100, 100);
		
		fill(calculateAngledColor());
		
		noStroke();
		
		triangle(x1, y1, x2, y2, x3, y3);
		
		popMatrix();
	}
}
Shape[] shapes;
int num_tris = 17;
float tri_radius = 16.0;

int nth_triangle(int t) {
	return ((int(sq(float(t))) + t) / 2);
}

float nth_triangle(float t) {
	return ((sq(t) + t) / 2);
}

float triangleWidth(float radius) {
	return ((cos(radians(30)) - cos(radians(150))) * radius);
}

float triangleHeight(float radius) {
	return ((sin(radians(150)) - sin(radians(-90))) * radius);
}

void setup() {
	size(640, 640);
	colorMode(HSB, 100);
	
	shapes = new Shape[ nth_triangle(num_tris) ];
	//shapes = new Shape[ ((nth_triangle(num_tris) * 2) - num_tris) ];
	int si = 0;
	
	PVector pos = new PVector(0.0, 0.0);
	
	pos.x += (width / 2);
	pos.y += ((height / 2) - (((triangleHeight(tri_radius) * num_tris) / 2) - (triangleHeight(tri_radius) / 2)));
	
	for(int i = 1; i <= num_tris; i++) {
		PVector tri_pos = new PVector();
		tri_pos = pos.copy();
		
		for(int t = 0; t < i; t++) {
			shapes[ si ] = new Shape(ShapeType.TRIANGLE, tri_pos, tri_radius);
			
			si++;
			
			tri_pos.add(triangleWidth(tri_radius), 0.0);
		}
		
		pos.add((triangleWidth(tri_radius) * -0.5), triangleHeight(tri_radius));
	}
	
	/*// add upside down triangles
	int lsi = 0;
	
	for(int i = 1; i < num_tris; i++) {
		for(int t = 0; t < i; t++) {
			PVector u_pos = new PVector();
			u_pos = shapes[ lsi ].center.copy();
			u_pos.add(0, (triangleHeight(tri_radius) / 2) + 4.3);
			
			shapes[ si ] = new Shape(ShapeType.UPSIDE_DOWN_TRIANGLE, u_pos, tri_radius);
			
			si++;
			lsi++;
		}
	}*/
	
	// find most distant triangle from center (bottom right) and max distance on all
	PVector last_tri_center = new PVector();
	last_tri_center = shapes[ (nth_triangle(num_tris) - 1) ].center.copy();
	float max_dist = dist(last_tri_center.x, last_tri_center.y, (width / 2), (height / 2));
	
	for(int i = 0; i < shapes.length; i++) {
		shapes[ i ].setMaxDistance(max_dist);
	}
}

void draw() {
	background(20, 10, 10);
	
	for(int i = 0; i < shapes.length; i++) {
		shapes[ i ].update();
		shapes[ i ].render();
	}
	
	if(frameCount == 50) { save("preview.png"); }
}
please visit our Contact Us page to get in touch
pyxol © 2021