プログラミング de 落描き – ページ 522 – クリエイティブ・コーディングによる生成物とソース

2021年7月26日2021年7月26日

Character tunnel. Draw by openFramewroks

[ Video ]

[ About ]
文字を筒状に並べてノイズで文字を変える。

Arrange the letters in a cylindrical shape and change the letters with noise.

[ 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;

	float font_size;
	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;

float font_size;

ofTrueTypeFont font;

};

#include "ofApp.h"

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

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

	ofBackground(239);
	ofSetLineWidth(3);
	ofEnableDepthTest();

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

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

	ofSeedRandom(39);
}

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

	this->cam.begin();
	ofRotateX(90);

	string word = "ABCDEFGHEJKLMNOPQRSTUVWXYZ!";
	int sample_count = 100;
	vector<glm::vec3> base_location;
	for (int y = -500; y <= 500; y += 100) {

		base_location.push_back(glm::vec3(0, y, 0));
	}

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

		auto noise_param = glm::vec3(ofRandom(1000), ofRandom(1000), ofRandom(1000));
		for (int i = 0; i < 24; i++) {

			auto rotation = glm::rotate(glm::mat4(), (i * 15.f) * (float)DEG_TO_RAD, glm::vec3(0, 1, 0));
			auto noise_location = glm::vec4(this->font_size * 0.5, base_location[k].y + this->font_size * -0.5, 320, 0) * rotation;

			int word_index = (int)ofMap(ofNoise(noise_location.x * 0.0001, noise_location.y * 0.0001 - ofGetFrameNum() * 0.005, noise_location.z * 0.0001), 0, 1, 0, word.size() * 2) % word.size();

			ofPath chara_path = this->font.getCharacterAsPoints(word[word_index], true, false);
			vector<ofPolyline> outline = chara_path.getOutline();

			ofFill();
			ofSetColor(239);
			ofBeginShape();
			for (int outline_index = 0; outline_index < outline.size(); outline_index++) {

				if (outline_index != 0) { ofNextContour(true); }

				auto vertices = outline[outline_index].getResampledByCount(sample_count).getVertices();
				for (auto& vertex : vertices) {

					auto location = vertex - glm::vec3(this->font_size * 0.5, this->font_size * -0.5, 350);
					auto rotation = glm::rotate(glm::mat4(), (i * 15.f) * (float)DEG_TO_RAD, glm::vec3(0, 1, 0));
					location = glm::vec4(location, 0) * rotation;
					location += base_location[k];

					ofVertex(location);
				}
			}
			ofEndShape();

			ofNoFill();
			ofSetColor(39);
			ofBeginShape();
			for (int outline_index = 0; outline_index < outline.size(); outline_index++) {

				if (outline_index != 0) { ofNextContour(true); }

				auto vertices = outline[outline_index].getResampledByCount(sample_count).getVertices();
				for (auto& vertex : vertices) {

					auto location = vertex - glm::vec3(this->font_size * 0.5, this->font_size * -0.5, 350);
					auto rotation = glm::rotate(glm::mat4(), (i * 15.f) * (float)DEG_TO_RAD, glm::vec3(0, 1, 0));
					location = glm::vec4(location, 0) * rotation;
					location += base_location[k];

					ofVertex(location);
				}
			}
			ofEndShape();
		}
	}

	this->cam.end();
}

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

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

100

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(30);

ofSetWindowTitle("openframeworks");

ofBackground(239);

ofSetLineWidth(3);

ofEnableDepthTest();

this->font_size = 80;

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

}

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

void ofApp::update() {

ofSeedRandom(39);

}

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

void ofApp::draw() {

this->cam.begin();

ofRotateX(90);

string word = "ABCDEFGHEJKLMNOPQRSTUVWXYZ!";

int sample_count = 100;

vector<glm::vec3> base_location;

for (int y = -500; y <= 500; y += 100) {

base_location.push_back(glm::vec3(0, y, 0));

}

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

auto noise_param = glm::vec3(ofRandom(1000), ofRandom(1000), ofRandom(1000));

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

auto rotation = glm::rotate(glm::mat4(), (i * 15.f) * (float)DEG_TO_RAD, glm::vec3(0, 1, 0));

auto noise_location = glm::vec4(this->font_size * 0.5, base_location[k].y + this->font_size * -0.5, 320, 0) * rotation;

int word_index = (int)ofMap(ofNoise(noise_location.x * 0.0001, noise_location.y * 0.0001 - ofGetFrameNum() * 0.005, noise_location.z * 0.0001), 0, 1, 0, word.size() * 2) % word.size();

ofPath chara_path = this->font.getCharacterAsPoints(word[word_index], true, false);

vector<ofPolyline> outline = chara_path.getOutline();

ofFill();

ofSetColor(239);

ofBeginShape();

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

if (outline_index != 0) { ofNextContour(true); }

auto vertices = outline[outline_index].getResampledByCount(sample_count).getVertices();

for (auto& vertex : vertices) {

auto location = vertex - glm::vec3(this->font_size * 0.5, this->font_size * -0.5, 350);

auto rotation = glm::rotate(glm::mat4(), (i * 15.f) * (float)DEG_TO_RAD, glm::vec3(0, 1, 0));

location = glm::vec4(location, 0) * rotation;

location += base_location[k];

ofVertex(location);

}

ofEndShape();

ofNoFill();

ofSetColor(39);

ofBeginShape();

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

if (outline_index != 0) { ofNextContour(true); }

auto vertices = outline[outline_index].getResampledByCount(sample_count).getVertices();

for (auto& vertex : vertices) {

auto location = vertex - glm::vec3(this->font_size * 0.5, this->font_size * -0.5, 350);

auto rotation = glm::rotate(glm::mat4(), (i * 15.f) * (float)DEG_TO_RAD, glm::vec3(0, 1, 0));

location = glm::vec4(location, 0) * rotation;

location += base_location[k];

ofVertex(location);

}

ofEndShape();

}

this->cam.end();

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

[ Kinako ]

2021年7月25日2021年7月25日

Torsional circular. Draw by openFrameworks

[ Video ]

[ About ]
円形を全体的に同じ角度で回転させる。

Rotate the entire circle at the same angle.

[ 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) {};

	void setRingToMesh(ofMesh& face_target, ofMesh& frame_target, glm::vec3 location, float radius, float height);

	ofEasyCam cam;
	ofMesh face, frame;
};

#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) {};

void setRingToMesh(ofMesh& face_target, ofMesh& frame_target, glm::vec3 location, float radius, float height);

ofEasyCam cam;

ofMesh face, frame;

};

#include "ofApp.h"

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

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

	ofBackground(239);
	ofSetLineWidth(1.5);
	ofEnableDepthTest();

	this->frame.setMode(ofPrimitiveMode::OF_PRIMITIVE_LINES);
}
//--------------------------------------------------------------
void ofApp::update() {

	this->face.clear();
	this->frame.clear();

	vector<glm::vec3> base_location = {

	glm::vec3(-300, -300, 0), glm::vec3(0, -300, 0), glm::vec3(300, -300, 0),
	glm::vec3(-300, 0, 0), glm::vec3(0, 0, 0), glm::vec3(300, 0, 0),
	glm::vec3(-300, 300, 0), glm::vec3(0, 300, 0), glm::vec3(300, 300, 0),
	};

	for (auto& location : base_location) {

		for (int radius = 50; radius <= 130; radius += 20) {

			this->setRingToMesh(this->face, this->frame, location, radius, 45);
		}
	}
}

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

	this->cam.begin();

	ofSetColor(39);
	this->face.draw();

	ofSetColor(239);
	this->frame.drawWireframe();

	this->cam.end();
}

//--------------------------------------------------------------
void ofApp::setRingToMesh(ofMesh& face_target, ofMesh& frame_target, glm::vec3 location, float radius, float height) {

	int index = face_target.getNumVertices();

	for (int deg = 0; deg < 360; deg += 1) {

		vector<glm::vec3> vertices;
		vertices.push_back(glm::vec3(radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD), height * -0.5));
		vertices.push_back(glm::vec3(radius * cos((deg + 1) * DEG_TO_RAD), radius * sin((deg + 1) * DEG_TO_RAD), height * -0.5));
		vertices.push_back(glm::vec3(radius * cos((deg + 1) * DEG_TO_RAD), radius * sin((deg + 1) * DEG_TO_RAD), height * 0.5));
		vertices.push_back(glm::vec3(radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD), height * 0.5));

		for (auto& vertex : vertices) {

			auto noise_value = ofNoise(
				(location.x + vertex.x) * 0.00035,
				(location.y + vertex.y) * 0.00035 + ofGetFrameNum() * 0.008);

			auto rotation_x = glm::rotate(glm::mat4(), ofMap(noise_value, 0, 1, -PI * 3, PI * 3), glm::vec3(1, 0, 0));
			auto rotation_y = glm::rotate(glm::mat4(), ofMap(noise_value, 0, 1, -PI * 3, PI * 3), glm::vec3(0, 1, 0));
			auto rotation_z = glm::rotate(glm::mat4(), ofMap(noise_value, 0, 1, -PI * 3, PI * 3), glm::vec3(0, 0, 1));

			vertex = glm::vec4(vertex, 0) * rotation_z * rotation_y * rotation_x + glm::vec4(location, 0);
		}

		auto face_index = face_target.getNumVertices();
		face_target.addVertices(vertices);

		face_target.addIndex(face_index + 0); face_target.addIndex(face_index + 1); face_target.addIndex(face_index + 2);
		face_target.addIndex(face_index + 0); face_target.addIndex(face_index + 2); face_target.addIndex(face_index + 3);

		auto frame_index = frame_target.getNumVertices();
		frame_target.addVertices(vertices);

		frame_target.addIndex(frame_index + 0); frame_target.addIndex(frame_index + 1);
		frame_target.addIndex(frame_index + 2); frame_target.addIndex(frame_index + 3);
	}
}

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

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(30);

ofSetWindowTitle("openFrameworks");

ofBackground(239);

ofSetLineWidth(1.5);

ofEnableDepthTest();

this->frame.setMode(ofPrimitiveMode::OF_PRIMITIVE_LINES);

}

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

void ofApp::update() {

this->face.clear();

this->frame.clear();

vector<glm::vec3> base_location = {

glm::vec3(-300, -300, 0), glm::vec3(0, -300, 0), glm::vec3(300, -300, 0),

glm::vec3(-300, 0, 0), glm::vec3(0, 0, 0), glm::vec3(300, 0, 0),

glm::vec3(-300, 300, 0), glm::vec3(0, 300, 0), glm::vec3(300, 300, 0),

};

for (auto& location : base_location) {

for (int radius = 50; radius <= 130; radius += 20) {

this->setRingToMesh(this->face, this->frame, location, radius, 45);

}

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

void ofApp::draw() {

this->cam.begin();

ofSetColor(39);

this->face.draw();

ofSetColor(239);

this->frame.drawWireframe();

this->cam.end();

}

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

void ofApp::setRingToMesh(ofMesh& face_target, ofMesh& frame_target, glm::vec3 location, float radius, float height) {

int index = face_target.getNumVertices();

for (int deg = 0; deg < 360; deg += 1) {

vector<glm::vec3> vertices;

vertices.push_back(glm::vec3(radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD), height * -0.5));

vertices.push_back(glm::vec3(radius * cos((deg + 1) * DEG_TO_RAD), radius * sin((deg + 1) * DEG_TO_RAD), height * -0.5));

vertices.push_back(glm::vec3(radius * cos((deg + 1) * DEG_TO_RAD), radius * sin((deg + 1) * DEG_TO_RAD), height * 0.5));

vertices.push_back(glm::vec3(radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD), height * 0.5));

for (auto& vertex : vertices) {

auto noise_value = ofNoise(

(location.x + vertex.x) * 0.00035,

(location.y + vertex.y) * 0.00035 + ofGetFrameNum() * 0.008);

auto rotation_x = glm::rotate(glm::mat4(), ofMap(noise_value, 0, 1, -PI * 3, PI * 3), glm::vec3(1, 0, 0));

auto rotation_y = glm::rotate(glm::mat4(), ofMap(noise_value, 0, 1, -PI * 3, PI * 3), glm::vec3(0, 1, 0));

auto rotation_z = glm::rotate(glm::mat4(), ofMap(noise_value, 0, 1, -PI * 3, PI * 3), glm::vec3(0, 0, 1));

vertex = glm::vec4(vertex, 0) * rotation_z * rotation_y * rotation_x + glm::vec4(location, 0);

}

auto face_index = face_target.getNumVertices();

face_target.addVertices(vertices);

face_target.addIndex(face_index + 0); face_target.addIndex(face_index + 1); face_target.addIndex(face_index + 2);

face_target.addIndex(face_index + 0); face_target.addIndex(face_index + 2); face_target.addIndex(face_index + 3);

auto frame_index = frame_target.getNumVertices();

frame_target.addVertices(vertices);

frame_target.addIndex(frame_index + 0); frame_target.addIndex(frame_index + 1);

frame_target.addIndex(frame_index + 2); frame_target.addIndex(frame_index + 3);

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

2021年7月24日

Delayed contour. Draw by openFrameworks

[ Video ]

[ About ]
フレーム番号でノイズの値の変化に緩急をつける。
ノイズの値を配列に記録して輪郭を描く。

Use frame numbers to slow down the change in noise values.
Record the noise values in an array and draw the contour.

if(ofGetFrameNum() % 60 < 45){ noise_param += ofMap(ofGetFrameNum() % 60, 0, 45, 0.1, 0.001); } Record the noise values in an array and draw the contour. [ 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;

	float font_size;
	ofTrueTypeFont font;
	vector<float> noise_param_list;
};

#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;

float font_size;

ofTrueTypeFont font;

vector<float> noise_param_list;

};

#include "ofApp.h"

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

	ofSetFrameRate(60);
	ofSetWindowTitle("openframeworks");

	ofBackground(239);
	ofSetLineWidth(1.5);
	ofEnableDepthTest();

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

	this->noise_param_list.push_back(ofRandom(1000));
}


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

	ofSeedRandom(39);

	if (ofGetFrameNum() % 60 < 45) {

		auto noise_param = this->noise_param_list.back() + ofMap(ofGetFrameNum() % 60, 0, 45, 0.02, 0.001);
		this->noise_param_list.push_back(noise_param);
	}
	else {

		auto noise_param = this->noise_param_list.back();
		this->noise_param_list.push_back(noise_param);
	}

	while (this->noise_param_list.size() > 10) {

		this->noise_param_list.erase(this->noise_param_list.begin());
	}
}

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

	this->cam.begin();
	ofRotateX(180);

	string word = "A";
	int sample_count = 100;
	int span = 200;
	vector<glm::vec3> base_location = {

		glm::vec3(-100, -100, 0), glm::vec3(0, -100, 0), glm::vec3(100, -100, 0),
		glm::vec3(-100, 0, 0), glm::vec3(0, 0, 0), glm::vec3(100, 0, 0),
		glm::vec3(-100, 100, 0), glm::vec3(0, 100, 0), glm::vec3(100, 100, 0),
	};

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

		for (int radius = 230; radius <= 230; radius += 100) {

			auto noise_param = glm::vec3(ofRandom(1000), ofRandom(1000), ofRandom(1000));
			for (int i = 0; i < word.size(); i++) {

				ofPath chara_path = this->font.getCharacterAsPoints(word[i], true, false);
				vector<ofPolyline> outline = chara_path.getOutline();

				ofFill();
				ofSetColor(239);
				ofBeginShape();
				for (int outline_index = 0; outline_index < outline.size(); outline_index++) {

					if (outline_index != 0) { ofNextContour(true); }

					auto vertices = outline[outline_index].getResampledByCount(sample_count).getVertices();
					for (auto& vertex : vertices) {

						auto location = vertex - glm::vec3(this->font_size * 0.5, this->font_size * -0.5, 0);

						auto angle_x = ofMap(ofNoise(noise_param.x, location.x * 0.001 + this->noise_param_list.back()), 0, 1, -PI * 2, PI * 2);
						auto rotation_x = glm::rotate(glm::mat4(), angle_x, glm::vec3(1, 0, 0));

						location = glm::vec4(location, 0) * rotation_x;
						location += base_location[k];

						ofVertex(location);
					}
				}
				ofEndShape();

				for (int m = 0; m < this->noise_param_list.size(); m++) {

					ofNoFill();
					ofSetColor(39);
					ofBeginShape();
					for (int outline_index = 0; outline_index < outline.size(); outline_index++) {

						if (outline_index != 0) { ofNextContour(true); }

						auto vertices = outline[outline_index].getResampledByCount(sample_count).getVertices();
						for (auto& vertex : vertices) {

							auto location = vertex - glm::vec3(this->font_size * 0.5, this->font_size * -0.5, 0);

							auto angle_x = ofMap(ofNoise(noise_param.x, location.x * 0.001 + this->noise_param_list[m]), 0, 1, -PI * 2, PI * 2);
							auto rotation_x = glm::rotate(glm::mat4(), angle_x, glm::vec3(1, 0, 0));

							location = glm::vec4(location, 0) * rotation_x;
							location += base_location[k];

							ofVertex(location);
						}
					}
					ofEndShape(true);
				}
			}
		}
	}

	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

125

126

127

128

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openframeworks");

ofBackground(239);

ofSetLineWidth(1.5);

ofEnableDepthTest();

this->font_size = 80;

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

this->noise_param_list.push_back(ofRandom(1000));

}

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

void ofApp::update() {

ofSeedRandom(39);

if (ofGetFrameNum() % 60 < 45) {

auto noise_param = this->noise_param_list.back() + ofMap(ofGetFrameNum() % 60, 0, 45, 0.02, 0.001);

this->noise_param_list.push_back(noise_param);

}

else {

auto noise_param = this->noise_param_list.back();

this->noise_param_list.push_back(noise_param);

}

while (this->noise_param_list.size() > 10) {

this->noise_param_list.erase(this->noise_param_list.begin());

}

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

void ofApp::draw() {

this->cam.begin();

ofRotateX(180);

string word = "A";

int sample_count = 100;

int span = 200;

vector<glm::vec3> base_location = {

glm::vec3(-100, -100, 0), glm::vec3(0, -100, 0), glm::vec3(100, -100, 0),

glm::vec3(-100, 0, 0), glm::vec3(0, 0, 0), glm::vec3(100, 0, 0),

glm::vec3(-100, 100, 0), glm::vec3(0, 100, 0), glm::vec3(100, 100, 0),

};

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

for (int radius = 230; radius <= 230; radius += 100) {

auto noise_param = glm::vec3(ofRandom(1000), ofRandom(1000), ofRandom(1000));

for (int i = 0; i < word.size(); i++) {

ofPath chara_path = this->font.getCharacterAsPoints(word[i], true, false);

vector<ofPolyline> outline = chara_path.getOutline();

ofFill();

ofSetColor(239);

ofBeginShape();

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

if (outline_index != 0) { ofNextContour(true); }

auto vertices = outline[outline_index].getResampledByCount(sample_count).getVertices();

for (auto& vertex : vertices) {

auto location = vertex - glm::vec3(this->font_size * 0.5, this->font_size * -0.5, 0);

auto angle_x = ofMap(ofNoise(noise_param.x, location.x * 0.001 + this->noise_param_list.back()), 0, 1, -PI * 2, PI * 2);

auto rotation_x = glm::rotate(glm::mat4(), angle_x, glm::vec3(1, 0, 0));

location = glm::vec4(location, 0) * rotation_x;

location += base_location[k];

ofVertex(location);

}

ofEndShape();

for (int m = 0; m < this->noise_param_list.size(); m++) {

ofNoFill();

ofSetColor(39);

ofBeginShape();

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

if (outline_index != 0) { ofNextContour(true); }

auto vertices = outline[outline_index].getResampledByCount(sample_count).getVertices();

for (auto& vertex : vertices) {

auto location = vertex - glm::vec3(this->font_size * 0.5, this->font_size * -0.5, 0);

auto angle_x = ofMap(ofNoise(noise_param.x, location.x * 0.001 + this->noise_param_list[m]), 0, 1, -PI * 2, PI * 2);

auto rotation_x = glm::rotate(glm::mat4(), angle_x, glm::vec3(1, 0, 0));

location = glm::vec4(location, 0) * rotation_x;

location += base_location[k];

ofVertex(location);

}

ofEndShape(true);

}

this->cam.end();

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

2025年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