openFrameworks – ページ 343 – プログラミング de 落描き

2022年1月30日

Rotating number. Draw by openFrameworks

[ Video ]

[ About ]
厚みのある数字を回転させる。

Rotate the thick figures.

[ Source ]

#pragma once
#include "ofMain.h"

class ofApp : public ofBaseApp {

public:
	void setup();
	void update();
	void draw();

	void keyPressed(int key) {};
	void keyReleased(int key) {};
	void mouseMoved(int x, int y) {};
	void mouseDragged(int x, int y, int button) {};
	void mousePressed(int x, int y, int button) {};
	void mouseReleased(int x, int y, int button) {};
	void windowResized(int w, int h) {};
	void dragEvent(ofDragInfo dragInfo) {};
	void gotMessage(ofMessage msg) {};

	ofEasyCam cam;
	ofTrueTypeFont font;
};

#pragma once

#include "ofMain.h"

class ofApp : public ofBaseApp {

public:

void setup();

void update();

void draw();

void keyPressed(int key) {};

void keyReleased(int key) {};

void mouseMoved(int x, int y) {};

void mouseDragged(int x, int y, int button) {};

void mousePressed(int x, int y, int button) {};

void mouseReleased(int x, int y, int button) {};

void windowResized(int w, int h) {};

void dragEvent(ofDragInfo dragInfo) {};

void gotMessage(ofMessage msg) {};

ofEasyCam cam;

ofTrueTypeFont font;

};

#include "ofApp.h"

//--------------------------------------------------------------
void ofApp::setup() {

	ofSetFrameRate(30);
	ofSetWindowTitle("openFrameworks");

	ofBackground(0);
	ofSetLineWidth(2);
	ofEnableDepthTest();

	this->font.loadFont("fonts/Kazesawa-Bold.ttf", 50, true, true, true);
}

//--------------------------------------------------------------
void ofApp::update() {

	ofSeedRandom(39);
}

//--------------------------------------------------------------
void ofApp::draw() {

	this->cam.begin();

	vector<string> word_list = {
		"0", "1", "2", "3",
		"6", "5", "4",
		"7", "8", "9", "0"
	};

	for (int base_deg = 0; base_deg < 360; base_deg += 15) {

		for (int y = -120; y <= 180; y += 60) {

			int word_index = ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.005), 0, 1, 0, word_list.size());
			auto word = word_list[word_index];

			vector<ofPath> word_path = this->font.getStringAsPoints(word, true, false);
			for (int word_index = 0; word_index < word_path.size(); word_index++) {

				vector<ofPolyline> outline = word_path[word_index].getOutline();
				for (int outline_index = 0; outline_index < outline.size(); outline_index++) {

					outline[outline_index] = outline[outline_index].getResampledBySpacing(2);
					vector<glm::vec3> vertices = outline[outline_index].getVertices();
					vector<glm::vec3> mesh_vertices;
					vector<glm::vec3> base_location_list;
					vector<glm::highp_mat4x4> rotate_vertices;

					for (int vertices_index = 0; vertices_index < vertices.size(); vertices_index++) {

						auto base_location = glm::vec3(0, y, 200);
						base_location += glm::vec3(this->font.stringWidth(word_list[word_index]) * 0.5, this->font.stringHeight(word_list[word_index]) * 0.5, 0);

						auto noise_value = ofNoise(base_location.y * 0.08, ofGetFrameNum() * 0.005);
						auto deg = base_deg;
						if (noise_value > 0.75) {

							deg = base_deg + ofMap(noise_value, 0.75, 1, 0, 360);
						}
						else if (noise_value < 0.35) {

							deg = base_deg + ofMap(noise_value, 0, 0.35, -360, 0);
						}


						auto rotation = glm::rotate(glm::mat4(), (float)(deg * DEG_TO_RAD), glm::vec3(0, 1, 0));
						auto location = vertices[vertices_index] - glm::vec3(this->font.stringWidth(word_list[word_index]) * 1.5, this->font.stringHeight(word_list[word_index]) * -1.5, 0);
						location.x *= -1;

						mesh_vertices.push_back(location);
						rotate_vertices.push_back(rotation);
						base_location_list.push_back(base_location);
					}

					ofMesh face, line;
					line.setMode(ofPrimitiveMode::OF_PRIMITIVE_LINES);
					for (int k = 0; k < mesh_vertices.size(); k++) {

						face.addVertex(glm::vec4(base_location_list[k], 0) * rotate_vertices[k] + glm::vec4(mesh_vertices[k] + glm::vec3(0, 0, -15), 0) * -rotate_vertices[k]);
						face.addVertex(glm::vec4(base_location_list[k], 0) * rotate_vertices[k] + glm::vec4(mesh_vertices[k] + glm::vec3(0, 0, 15), 0) * -rotate_vertices[k]);

						line.addVertex(glm::vec4(base_location_list[k], 0) * rotate_vertices[k] + glm::vec4(mesh_vertices[k] + glm::vec3(0, 0, -15), 0) * -rotate_vertices[k]);
						line.addVertex(glm::vec4(base_location_list[k], 0) * rotate_vertices[k] + glm::vec4(mesh_vertices[k] + glm::vec3(0, 0, 15), 0) * -rotate_vertices[k]);

						if (k > 0) {

							face.addIndex(face.getNumVertices() - 1); face.addIndex(face.getNumVertices() - 2); face.addIndex(face.getNumVertices() - 4);
							face.addIndex(face.getNumVertices() - 1); face.addIndex(face.getNumVertices() - 3); face.addIndex(face.getNumVertices() - 4);

							line.addIndex(line.getNumVertices() - 1); line.addIndex(line.getNumVertices() - 3);
							line.addIndex(line.getNumVertices() - 2); line.addIndex(line.getNumVertices() - 4);
						}

						line.addIndex(line.getNumVertices() - 1); line.addIndex(line.getNumVertices() - 2);
					}

					face.addIndex(face.getNumVertices() - 1); face.addIndex(0); face.addIndex(1);
					face.addIndex(face.getNumVertices() - 1); face.addIndex(face.getNumVertices() - 2); face.addIndex(2);

					line.addIndex(line.getNumVertices() - 1); line.addIndex(1);
					line.addIndex(line.getNumVertices() - 2); line.addIndex(0);

					ofSetColor(0);
					face.draw();

					ofSetColor(0, 255, 255);
					line.drawWireframe();
				}
			}
		}
	}

	this->cam.end();
}

//--------------------------------------------------------------
int main() {

	ofSetupOpenGL(720, 720, OF_WINDOW);
	ofRunApp(new ofApp());
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

#include "ofApp.h"

//--------------------------------------------------------------

void ofApp::setup() {

ofSetFrameRate(30);

ofSetWindowTitle("openFrameworks");

ofBackground(0);

ofSetLineWidth(2);

ofEnableDepthTest();

this->font.loadFont("fonts/Kazesawa-Bold.ttf", 50, true, true, true);

}

//--------------------------------------------------------------

void ofApp::update() {

ofSeedRandom(39);

}

//--------------------------------------------------------------

void ofApp::draw() {

this->cam.begin();

vector<string> word_list = {

"0", "1", "2", "3",

"6", "5", "4",

"7", "8", "9", "0"

};

for (int base_deg = 0; base_deg < 360; base_deg += 15) {

for (int y = -120; y <= 180; y += 60) {

int word_index = ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.005), 0, 1, 0, word_list.size());

auto word = word_list[word_index];

vector<ofPath> word_path = this->font.getStringAsPoints(word, true, false);

for (int word_index = 0; word_index < word_path.size(); word_index++) {

vector<ofPolyline> outline = word_path[word_index].getOutline();

for (int outline_index = 0; outline_index < outline.size(); outline_index++) {

outline[outline_index] = outline[outline_index].getResampledBySpacing(2);

vector<glm::vec3> vertices = outline[outline_index].getVertices();

vector<glm::vec3> mesh_vertices;

vector<glm::vec3> base_location_list;

vector<glm::highp_mat4x4> rotate_vertices;

for (int vertices_index = 0; vertices_index < vertices.size(); vertices_index++) {

auto base_location = glm::vec3(0, y, 200);

base_location += glm::vec3(this->font.stringWidth(word_list[word_index]) * 0.5, this->font.stringHeight(word_list[word_index]) * 0.5, 0);

auto noise_value = ofNoise(base_location.y * 0.08, ofGetFrameNum() * 0.005);

auto deg = base_deg;

if (noise_value > 0.75) {

deg = base_deg + ofMap(noise_value, 0.75, 1, 0, 360);

}

else if (noise_value < 0.35) {

deg = base_deg + ofMap(noise_value, 0, 0.35, -360, 0);

}

auto rotation = glm::rotate(glm::mat4(), (float)(deg * DEG_TO_RAD), glm::vec3(0, 1, 0));

auto location = vertices[vertices_index] - glm::vec3(this->font.stringWidth(word_list[word_index]) * 1.5, this->font.stringHeight(word_list[word_index]) * -1.5, 0);

location.x *= -1;

mesh_vertices.push_back(location);

rotate_vertices.push_back(rotation);

base_location_list.push_back(base_location);

}

ofMesh face, line;

line.setMode(ofPrimitiveMode::OF_PRIMITIVE_LINES);

for (int k = 0; k < mesh_vertices.size(); k++) {

face.addVertex(glm::vec4(base_location_list[k], 0) * rotate_vertices[k] + glm::vec4(mesh_vertices[k] + glm::vec3(0, 0, -15), 0) * -rotate_vertices[k]);

face.addVertex(glm::vec4(base_location_list[k], 0) * rotate_vertices[k] + glm::vec4(mesh_vertices[k] + glm::vec3(0, 0, 15), 0) * -rotate_vertices[k]);

line.addVertex(glm::vec4(base_location_list[k], 0) * rotate_vertices[k] + glm::vec4(mesh_vertices[k] + glm::vec3(0, 0, -15), 0) * -rotate_vertices[k]);

line.addVertex(glm::vec4(base_location_list[k], 0) * rotate_vertices[k] + glm::vec4(mesh_vertices[k] + glm::vec3(0, 0, 15), 0) * -rotate_vertices[k]);

if (k > 0) {

face.addIndex(face.getNumVertices() - 1); face.addIndex(face.getNumVertices() - 2); face.addIndex(face.getNumVertices() - 4);

face.addIndex(face.getNumVertices() - 1); face.addIndex(face.getNumVertices() - 3); face.addIndex(face.getNumVertices() - 4);

line.addIndex(line.getNumVertices() - 1); line.addIndex(line.getNumVertices() - 3);

line.addIndex(line.getNumVertices() - 2); line.addIndex(line.getNumVertices() - 4);

}

line.addIndex(line.getNumVertices() - 1); line.addIndex(line.getNumVertices() - 2);

}

face.addIndex(face.getNumVertices() - 1); face.addIndex(0); face.addIndex(1);

face.addIndex(face.getNumVertices() - 1); face.addIndex(face.getNumVertices() - 2); face.addIndex(2);

line.addIndex(line.getNumVertices() - 1); line.addIndex(1);

line.addIndex(line.getNumVertices() - 2); line.addIndex(0);

ofSetColor(0);

face.draw();

ofSetColor(0, 255, 255);

line.drawWireframe();

}

this->cam.end();

}

//--------------------------------------------------------------

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

[ Link ]
https://github.com/junkiyoshi/Insta20220130

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2022年1月29日

10 PRINT of ellipse. Draw by openFrameworks

[ Video ]

[ About ]
10 PRINT を線ではなく楕円にしてみる。

Try to make 10 PRINT an ellipse instead of a line.

[ Source ]

#pragma once
#include "ofMain.h"

class ofApp : public ofBaseApp {

public:
	void setup();
	void update();
	void draw();

	void keyPressed(int key) {};
	void keyReleased(int key) {};
	void mouseMoved(int x, int y) {};
	void mouseDragged(int x, int y, int button) {};
	void mousePressed(int x, int y, int button) {};
	void mouseReleased(int x, int y, int button) {};
	void mouseEntered(int x, int y) {};
	void mouseExited(int x, int y) {};
	void windowResized(int w, int h) {};
	void dragEvent(ofDragInfo dragInfo) {};
	void gotMessage(ofMessage msg) {};
};

#pragma once

#include "ofMain.h"

class ofApp : public ofBaseApp {

public:

void setup();

void update();

void draw();

void keyPressed(int key) {};

void keyReleased(int key) {};

void mouseMoved(int x, int y) {};

void mouseDragged(int x, int y, int button) {};

void mousePressed(int x, int y, int button) {};

void mouseReleased(int x, int y, int button) {};

void mouseEntered(int x, int y) {};

void mouseExited(int x, int y) {};

void windowResized(int w, int h) {};

void dragEvent(ofDragInfo dragInfo) {};

void gotMessage(ofMessage msg) {};

};

#include "ofApp.h"

//--------------------------------------------------------------
void ofApp::setup() {

	ofSetFrameRate(30);
	ofSetWindowTitle("openframeworks");

	ofBackground(255);
	ofSetLineWidth(2);
}

//--------------------------------------------------------------
void ofApp::update() {

	ofSeedRandom(39);
}

//--------------------------------------------------------------
void ofApp::draw() {

	ofTranslate(ofGetWindowSize() * 0.5);

	int span = 40;
	for (int x = span * -8; x < span * 8; x += span) {

		for (int y = span * -8; y < span * 8; y += span) {

			vector<glm::vec2> vertices;

			int r = ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.0035), 0, 1, 0, 4);
			auto location = glm::vec2(x, y);

			if (r == 1) {

				location += glm::vec2(span, 0);
			}
			else if (r == 2) {

				location += glm::vec2(span, span);
			}
			else if (r == 3) {

				location += glm::vec2(0, span);
			}

			int deg_start = r * 90;
			int radius = span;
			for (int deg = deg_start; deg <= deg_start + 90; deg += 1) {

				vertices.push_back(location + glm::vec2(radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD)));
			}

			r = (r + 2) % 4;

			location = glm::vec2(x, y);
			if (r == 1) {

				location += glm::vec2(span, 0);
			}
			else if (r == 2) {

				location += glm::vec2(span, span);
			}
			else if (r == 3) {

				location += glm::vec2(0, span);
			}

			deg_start = r * 90;
			for (int deg = deg_start; deg <= deg_start + 90; deg += 1) {

				vertices.push_back(location + glm::vec2(radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD)));
			}

			ofSetColor(0);
			ofFill();
			ofBeginShape();
			ofVertices(vertices);
			ofEndShape(true);

			ofSetColor(255);
			ofNoFill();
			ofBeginShape();
			ofVertices(vertices);
			ofEndShape(true);
		}
	}
}

//--------------------------------------------------------------
int main() {

	ofSetupOpenGL(720, 720, OF_WINDOW);
	ofRunApp(new ofApp());
}

#include "ofApp.h"

//--------------------------------------------------------------

void ofApp::setup() {

ofSetFrameRate(30);

ofSetWindowTitle("openframeworks");

ofBackground(255);

ofSetLineWidth(2);

}

//--------------------------------------------------------------

void ofApp::update() {

ofSeedRandom(39);

}

//--------------------------------------------------------------

void ofApp::draw() {

ofTranslate(ofGetWindowSize() * 0.5);

int span = 40;

for (int x = span * -8; x < span * 8; x += span) {

for (int y = span * -8; y < span * 8; y += span) {

vector<glm::vec2> vertices;

int r = ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.0035), 0, 1, 0, 4);

auto location = glm::vec2(x, y);

if (r == 1) {

location += glm::vec2(span, 0);

}

else if (r == 2) {

location += glm::vec2(span, span);

}

else if (r == 3) {

location += glm::vec2(0, span);

}

int deg_start = r * 90;

int radius = span;

for (int deg = deg_start; deg <= deg_start + 90; deg += 1) {

vertices.push_back(location + glm::vec2(radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD)));

}

r = (r + 2) % 4;

location = glm::vec2(x, y);

if (r == 1) {

location += glm::vec2(span, 0);

}

else if (r == 2) {

location += glm::vec2(span, span);

}

else if (r == 3) {

location += glm::vec2(0, span);

}

deg_start = r * 90;

for (int deg = deg_start; deg <= deg_start + 90; deg += 1) {

vertices.push_back(location + glm::vec2(radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD)));

}

ofSetColor(0);

ofFill();

ofBeginShape();

ofVertices(vertices);

ofEndShape(true);

ofSetColor(255);

ofNoFill();

ofBeginShape();

ofVertices(vertices);

ofEndShape(true);

}

//--------------------------------------------------------------

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

[ Link ]
https://github.com/junkiyoshi/Insta20220129

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2022年1月28日

Many arrow. Draw by openFrameworks

[ Video ]

[ About ]
255本のランダムウォークする矢。

255 randomly walking arrows.

[ Source ]

#pragma once
#include "ofMain.h"

class Actor {
public:
	Actor(vector<glm::vec3>& location_list, vector<vector<int>>& next_index_list, vector<int>& destination_list);
	void update(const int& frame_span, vector<glm::vec3>& location_list, vector<vector<int>>& next_index_list, vector<int>& destination_list);
	glm::vec3 get_location();
	glm::vec3 get_prev_location();

private:

	int select_index;
	int next_index;

	glm::vec3 location;
	glm::vec3 prev_location;
};

class ofApp : public ofBaseApp {

public:
	void setup();
	void update();
	void draw();

	void keyPressed(int key) {};
	void keyReleased(int key) {};
	void mouseMoved(int x, int y) {};
	void mouseDragged(int x, int y, int button) {};
	void mousePressed(int x, int y, int button) {};
	void mouseReleased(int x, int y, int button) {};
	void windowResized(int w, int h) {};
	void dragEvent(ofDragInfo dragInfo) {};
	void gotMessage(ofMessage msg) {};

	void draw_arrow(glm::vec2 location, glm::vec2 next_location, float size, ofColor color);

	ofEasyCam cam;
	vector<glm::vec3> location_list;
	vector<vector<int>> next_index_list;
	vector<int> destination_list;

	vector<unique_ptr<Actor>> actor_list;
};

#pragma once

#include "ofMain.h"

class Actor {

public:

Actor(vector<glm::vec3>& location_list, vector<vector<int>>& next_index_list, vector<int>& destination_list);

void update(const int& frame_span, vector<glm::vec3>& location_list, vector<vector<int>>& next_index_list, vector<int>& destination_list);

glm::vec3 get_location();

glm::vec3 get_prev_location();

private:

int select_index;

int next_index;

glm::vec3 location;

glm::vec3 prev_location;

};

class ofApp : public ofBaseApp {

public:

void setup();

void update();

void draw();

void keyPressed(int key) {};

void keyReleased(int key) {};

void mouseMoved(int x, int y) {};

void mouseDragged(int x, int y, int button) {};

void mousePressed(int x, int y, int button) {};

void mouseReleased(int x, int y, int button) {};

void windowResized(int w, int h) {};

void dragEvent(ofDragInfo dragInfo) {};

void gotMessage(ofMessage msg) {};

void draw_arrow(glm::vec2 location, glm::vec2 next_location, float size, ofColor color);

ofEasyCam cam;

vector<glm::vec3> location_list;

vector<vector<int>> next_index_list;

vector<int> destination_list;

vector<unique_ptr<Actor>> actor_list;

};

#include "ofApp.h"	

//--------------------------------------------------------------
Actor::Actor(vector<glm::vec3>& location_list, vector<vector<int>>& next_index_list, vector<int>& destination_list) {

	this->select_index = ofRandom(location_list.size());
	while (true) {

		auto itr = find(destination_list.begin(), destination_list.end(), this->select_index);
		if (itr == destination_list.end()) {

			destination_list.push_back(this->select_index);
			break;
		}

		this->select_index = (this->select_index + 1) % location_list.size();
	}

	this->next_index = this->select_index;
}

//--------------------------------------------------------------
void Actor::update(const int& frame_span, vector<glm::vec3>& location_list, vector<vector<int>>& next_index_list, vector<int>& destination_list) {

	if (ofGetFrameNum() % frame_span == 0) {

		auto tmp_index = this->select_index;
		this->select_index = this->next_index;
		int retry = next_index_list[this->select_index].size() + 1;
		this->next_index = next_index_list[this->select_index][(int)ofRandom(next_index_list[this->select_index].size())];
		while (--retry > 0) {

			auto destination_itr = find(destination_list.begin(), destination_list.end(), this->next_index);
			if (destination_itr == destination_list.end()) {

				if (tmp_index != this->next_index) {

					destination_list.push_back(this->next_index);
					break;
				}
			}

			this->next_index = next_index_list[this->select_index][(this->next_index + 1) % next_index_list[this->select_index].size()];
		}
		if (retry <= 0) {

			destination_list.push_back(this->select_index);
			this->next_index = this->select_index;
		}
	}

	auto param = ofGetFrameNum() % frame_span;
	auto distance = location_list[this->next_index] - location_list[this->select_index];
	if (this->next_index != this->select_index) {

		this->prev_location = location;
	}
	this->location = location_list[this->select_index] + distance / frame_span * param;
}

//--------------------------------------------------------------
glm::vec3 Actor::get_location() {

	return this->location;
}

//--------------------------------------------------------------
glm::vec3 Actor::get_prev_location() {

	return this->prev_location;
}

//--------------------------------------------------------------
void ofApp::setup() {

	ofSetFrameRate(60);
	ofSetWindowTitle("openFrameworks");

	ofBackground(255);
	ofEnableDepthTest();
	ofSetLineWidth(2);

	auto span = 25;
	for (int x = -200; x <= 200; x += span) {

		for (int y = -200; y <= 200; y += span) {

			this->location_list.push_back(glm::vec3(x, y, 0));
		}
	}

	for (auto& location : this->location_list) {

		vector<int> next_index = vector<int>();
		int index = -1;
		for (auto& other : this->location_list) {

			index++;
			if (location == other) { continue; }

			float distance = glm::distance(location, other);
			if (distance <= span + 1) {

				next_index.push_back(index);
			}
		}

		this->next_index_list.push_back(next_index);
	}

	for (int i = 0; i < 255; i++) {
		this->actor_list.push_back(make_unique<Actor>(this->location_list, this->next_index_list, this->destination_list));
	}
}

//--------------------------------------------------------------
void ofApp::update() {

	int frame_span = 15;
	int prev_index_size = 0;

	if (ofGetFrameNum() % frame_span == 0) {

		prev_index_size = this->destination_list.size();
	}

	for (auto& actor : this->actor_list) {

		actor->update(frame_span, this->location_list, this->next_index_list, this->destination_list);
	}

	if (prev_index_size != 0) {

		this->destination_list.erase(this->destination_list.begin(), this->destination_list.begin() + prev_index_size);
	}
}

//--------------------------------------------------------------
void ofApp::draw() {

	this->cam.begin();

	int count = 0;
	ofColor color;
	for (auto& actor : this->actor_list) {

		color.setHsb(count++, 130, 255);
		this->draw_arrow(actor->get_prev_location(), actor->get_location(), 10, color);
	}

	this->cam.end();
}

//--------------------------------------------------------------
void ofApp::draw_arrow(glm::vec2 location, glm::vec2 next_location, float size, ofColor color) {

	auto angle = std::atan2(next_location.y - location.y, next_location.x - location.x);

	ofSetColor(color);
	ofFill();
	ofBeginShape();
	ofVertex(location + glm::vec2(size * cos(angle), size * sin(angle)));
	ofVertex(location + glm::vec2(size * 0.5 * cos(angle + PI * 0.5), size * 0.5 * sin(angle + PI * 0.5)));
	ofVertex(location + glm::vec2(size * 0.5 * cos(angle - PI * 0.5), size * 0.5 * sin(angle - PI * 0.5)));
	ofEndShape();

	ofBeginShape();
	ofVertex(location + glm::vec2(size * 0.5 * cos(angle + PI * 0.5), size * 0.5 * sin(angle + PI * 0.5)) * 0.25);
	ofVertex(location + glm::vec2(size * 0.5 * cos(angle + PI * 0.5), size * 0.5 * sin(angle + PI * 0.5)) * 0.25 - glm::vec2(size * cos(angle), size * sin(angle)) * 0.5);
	ofVertex(location + glm::vec2(size * 0.5 * cos(angle - PI * 0.5), size * 0.5 * sin(angle - PI * 0.5)) * 0.25 - glm::vec2(size * cos(angle), size * sin(angle)) * 0.5);
	ofVertex(location + glm::vec2(size * 0.5 * cos(angle - PI * 0.5), size * 0.5 * sin(angle - PI * 0.5)) * 0.25);
	ofEndShape();

	ofSetColor(255);
	ofNoFill();
	ofBeginShape();
	ofVertex(location + glm::vec2(size * cos(angle), size * sin(angle)));
	ofVertex(location + glm::vec2(size * 0.5 * cos(angle + PI * 0.5), size * 0.5 * sin(angle + PI * 0.5)));
	ofVertex(location + glm::vec2(size * 0.5 * cos(angle - PI * 0.5), size * 0.5 * sin(angle - PI * 0.5)));
	ofEndShape(true);

	ofBeginShape();
	ofVertex(location + glm::vec2(size * 0.5 * cos(angle + PI * 0.5), size * 0.5 * sin(angle + PI * 0.5)) * 0.25);
	ofVertex(location + glm::vec2(size * 0.5 * cos(angle + PI * 0.5), size * 0.5 * sin(angle + PI * 0.5)) * 0.25 - glm::vec2(size * cos(angle), size * sin(angle)) * 0.5);
	ofVertex(location + glm::vec2(size * 0.5 * cos(angle - PI * 0.5), size * 0.5 * sin(angle - PI * 0.5)) * 0.25 - glm::vec2(size * cos(angle), size * sin(angle)) * 0.5);
	ofVertex(location + glm::vec2(size * 0.5 * cos(angle - PI * 0.5), size * 0.5 * sin(angle - PI * 0.5)) * 0.25);
	ofEndShape();
}

//--------------------------------------------------------------
int main() {

	ofSetupOpenGL(720, 720, OF_WINDOW);
	ofRunApp(new ofApp());
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

#include "ofApp.h"

//--------------------------------------------------------------

Actor::Actor(vector<glm::vec3>& location_list, vector<vector<int>>& next_index_list, vector<int>& destination_list) {

this->select_index = ofRandom(location_list.size());

while (true) {

auto itr = find(destination_list.begin(), destination_list.end(), this->select_index);

if (itr == destination_list.end()) {

destination_list.push_back(this->select_index);

break;

}

this->select_index = (this->select_index + 1) % location_list.size();

}

this->next_index = this->select_index;

}

//--------------------------------------------------------------

void Actor::update(const int& frame_span, vector<glm::vec3>& location_list, vector<vector<int>>& next_index_list, vector<int>& destination_list) {

if (ofGetFrameNum() % frame_span == 0) {

auto tmp_index = this->select_index;

this->select_index = this->next_index;

int retry = next_index_list[this->select_index].size() + 1;

this->next_index = next_index_list[this->select_index][(int)ofRandom(next_index_list[this->select_index].size())];

while (--retry > 0) {

auto destination_itr = find(destination_list.begin(), destination_list.end(), this->next_index);

if (destination_itr == destination_list.end()) {

if (tmp_index != this->next_index) {

destination_list.push_back(this->next_index);

break;

}

this->next_index = next_index_list[this->select_index][(this->next_index + 1) % next_index_list[this->select_index].size()];

}

if (retry <= 0) {

destination_list.push_back(this->select_index);

this->next_index = this->select_index;

}

auto param = ofGetFrameNum() % frame_span;

auto distance = location_list[this->next_index] - location_list[this->select_index];

if (this->next_index != this->select_index) {

this->prev_location = location;

}

this->location = location_list[this->select_index] + distance / frame_span * param;

}

//--------------------------------------------------------------

glm::vec3 Actor::get_location() {

return this->location;

}

//--------------------------------------------------------------

glm::vec3 Actor::get_prev_location() {

return this->prev_location;

}

//--------------------------------------------------------------

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openFrameworks");

ofBackground(255);

ofEnableDepthTest();

ofSetLineWidth(2);

auto span = 25;

for (int x = -200; x <= 200; x += span) {

for (int y = -200; y <= 200; y += span) {

this->location_list.push_back(glm::vec3(x, y, 0));

}

for (auto& location : this->location_list) {

vector<int> next_index = vector<int>();

int index = -1;

for (auto& other : this->location_list) {

index++;

if (location == other) { continue; }

float distance = glm::distance(location, other);

if (distance <= span + 1) {

next_index.push_back(index);

}

this->next_index_list.push_back(next_index);

}

for (int i = 0; i < 255; i++) {

this->actor_list.push_back(make_unique<Actor>(this->location_list, this->next_index_list, this->destination_list));

}

//--------------------------------------------------------------

void ofApp::update() {

int frame_span = 15;

int prev_index_size = 0;

if (ofGetFrameNum() % frame_span == 0) {

prev_index_size = this->destination_list.size();

}

for (auto& actor : this->actor_list) {

actor->update(frame_span, this->location_list, this->next_index_list, this->destination_list);

}

if (prev_index_size != 0) {

this->destination_list.erase(this->destination_list.begin(), this->destination_list.begin() + prev_index_size);

}

//--------------------------------------------------------------

void ofApp::draw() {

this->cam.begin();

int count = 0;

ofColor color;

for (auto& actor : this->actor_list) {

color.setHsb(count++, 130, 255);

this->draw_arrow(actor->get_prev_location(), actor->get_location(), 10, color);

}

this->cam.end();

}

//--------------------------------------------------------------

void ofApp::draw_arrow(glm::vec2 location, glm::vec2 next_location, float size, ofColor color) {

auto angle = std::atan2(next_location.y - location.y, next_location.x - location.x);

ofSetColor(color);

ofFill();

ofBeginShape();

ofVertex(location + glm::vec2(size * cos(angle), size * sin(angle)));

ofVertex(location + glm::vec2(size * 0.5 * cos(angle + PI * 0.5), size * 0.5 * sin(angle + PI * 0.5)));

ofVertex(location + glm::vec2(size * 0.5 * cos(angle - PI * 0.5), size * 0.5 * sin(angle - PI * 0.5)));

ofEndShape();

ofBeginShape();

ofVertex(location + glm::vec2(size * 0.5 * cos(angle + PI * 0.5), size * 0.5 * sin(angle + PI * 0.5)) * 0.25);

ofVertex(location + glm::vec2(size * 0.5 * cos(angle + PI * 0.5), size * 0.5 * sin(angle + PI * 0.5)) * 0.25 - glm::vec2(size * cos(angle), size * sin(angle)) * 0.5);

ofVertex(location + glm::vec2(size * 0.5 * cos(angle - PI * 0.5), size * 0.5 * sin(angle - PI * 0.5)) * 0.25 - glm::vec2(size * cos(angle), size * sin(angle)) * 0.5);

ofVertex(location + glm::vec2(size * 0.5 * cos(angle - PI * 0.5), size * 0.5 * sin(angle - PI * 0.5)) * 0.25);

ofEndShape();

ofSetColor(255);

ofNoFill();

ofBeginShape();

ofVertex(location + glm::vec2(size * cos(angle), size * sin(angle)));

ofVertex(location + glm::vec2(size * 0.5 * cos(angle + PI * 0.5), size * 0.5 * sin(angle + PI * 0.5)));

ofVertex(location + glm::vec2(size * 0.5 * cos(angle - PI * 0.5), size * 0.5 * sin(angle - PI * 0.5)));

ofEndShape(true);

ofBeginShape();

ofVertex(location + glm::vec2(size * 0.5 * cos(angle + PI * 0.5), size * 0.5 * sin(angle + PI * 0.5)) * 0.25);

ofVertex(location + glm::vec2(size * 0.5 * cos(angle + PI * 0.5), size * 0.5 * sin(angle + PI * 0.5)) * 0.25 - glm::vec2(size * cos(angle), size * sin(angle)) * 0.5);

ofVertex(location + glm::vec2(size * 0.5 * cos(angle - PI * 0.5), size * 0.5 * sin(angle - PI * 0.5)) * 0.25 - glm::vec2(size * cos(angle), size * sin(angle)) * 0.5);

ofVertex(location + glm::vec2(size * 0.5 * cos(angle - PI * 0.5), size * 0.5 * sin(angle - PI * 0.5)) * 0.25);

ofEndShape();

}

//--------------------------------------------------------------

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

[ Link ]
https://github.com/junkiyoshi/Insta20220128

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2024年11月
月	火	水	木	金	土	日
				1	2	3
4	5	6	7	8	9	10
11	12	13	14	15	16	17
18	19	20	21	22	23	24
25	26	27	28	29	30