noise – ページ 172 – プログラミング de 落描き

2021年6月19日2021年6月19日

Tornado type. Draw by openFrameworks

[ Video ]

[ About ]
Tornado type.

[ 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(60);
	ofSetWindowTitle("openFrameworks");

	ofBackground(239);
	ofSetLineWidth(2);
	ofEnableDepthTest();

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

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

}

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

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

	vector<string> word_list = {
		"A", "B", "C",
		"1", "2", "3",
		"X", "Y", "Z"
	};

	vector<glm::vec2> base_location_list = {
		glm::vec2(this->font.stringWidth(word_list[0]) * 0.5 - 150, -150), glm::vec2(this->font.stringWidth(word_list[0]) * 0.5, -150), glm::vec2(this->font.stringWidth(word_list[0]) * 0.5 + 150, -150),
		glm::vec2(this->font.stringWidth(word_list[0]) * 0.5 - 150, 60),   glm::vec2(this->font.stringWidth(word_list[0]) * 0.5, 60),   glm::vec2(this->font.stringWidth(word_list[0]) * 0.5 + 150, 60),
		glm::vec2(this->font.stringWidth(word_list[0]) * 0.5 - 150, 270),  glm::vec2(this->font.stringWidth(word_list[0]) * 0.5, 270),  glm::vec2(this->font.stringWidth(word_list[0]) * 0.5 + 150, 270)
	}; 

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

		auto word = word_list[i];
		auto base_location = base_location_list[i];
		base_location += glm::vec2(this->font.stringWidth(word_list[i]) * 0.5, this->font.stringHeight(word_list[i]) * 0.5);

		int sample_count = 120;
		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].getResampledByCount(sample_count);
				vector<glm::vec3> vertices = outline[outline_index].getVertices();
				vector<glm::vec2> mesh_vertices;
				vector<glm::highp_mat4x4> rotate_vertices;
				
				for (int vertices_index = 0; vertices_index < vertices.size(); vertices_index++) {

					auto noise_value = ofNoise(
						(base_location.x + vertices[vertices_index].x) * 0.001,
						(base_location.y + vertices[vertices_index].y) * 0.001 + ofGetFrameNum() * 0.008);
					float param = 0.5;
					if (noise_value < 0.3) { param = ofMap(noise_value, 0, 0.3, 0, 0.5); }
					if (noise_value > 0.7) { param = ofMap(noise_value, 0.7, 1, 0.5, 1); }

					auto rotation = glm::rotate(glm::mat4(), ofMap(param, 0, 1, -PI * 3, PI * 3), glm::vec3(0, 1, 0));
					auto location = vertices[vertices_index] - glm::vec2(this->font.stringWidth(word_list[i]) * 0.5, this->font.stringHeight(word_list[i]) * 0.5);
					
					mesh_vertices.push_back(location);
					rotate_vertices.push_back(rotation);
				}

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

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

					line.addVertex(glm::vec4(base_location, 0, 0) + glm::vec4(mesh_vertices[k], -15, 0) * rotate_vertices[k]);
					line.addVertex(glm::vec4(base_location, 0, 0) + glm::vec4(mesh_vertices[k], 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);
					}
				}

				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(39);
				face.draw();

				ofSetColor(139);
				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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openFrameworks");

ofBackground(239);

ofSetLineWidth(2);

ofEnableDepthTest();

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

}

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

void ofApp::update() {

}

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

void ofApp::draw() {

this->cam.begin();

ofRotateX(180);

vector<string> word_list = {

"A", "B", "C",

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

"X", "Y", "Z"

};

vector<glm::vec2> base_location_list = {

glm::vec2(this->font.stringWidth(word_list[0]) * 0.5 - 150, -150), glm::vec2(this->font.stringWidth(word_list[0]) * 0.5, -150), glm::vec2(this->font.stringWidth(word_list[0]) * 0.5 + 150, -150),

glm::vec2(this->font.stringWidth(word_list[0]) * 0.5 - 150, 60), glm::vec2(this->font.stringWidth(word_list[0]) * 0.5, 60), glm::vec2(this->font.stringWidth(word_list[0]) * 0.5 + 150, 60),

glm::vec2(this->font.stringWidth(word_list[0]) * 0.5 - 150, 270), glm::vec2(this->font.stringWidth(word_list[0]) * 0.5, 270), glm::vec2(this->font.stringWidth(word_list[0]) * 0.5 + 150, 270)

};

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

auto word = word_list[i];

auto base_location = base_location_list[i];

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

int sample_count = 120;

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].getResampledByCount(sample_count);

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

vector<glm::vec2> mesh_vertices;

vector<glm::highp_mat4x4> rotate_vertices;

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

auto noise_value = ofNoise(

(base_location.x + vertices[vertices_index].x) * 0.001,

(base_location.y + vertices[vertices_index].y) * 0.001 + ofGetFrameNum() * 0.008);

float param = 0.5;

if (noise_value < 0.3) { param = ofMap(noise_value, 0, 0.3, 0, 0.5); }

if (noise_value > 0.7) { param = ofMap(noise_value, 0.7, 1, 0.5, 1); }

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

auto location = vertices[vertices_index] - glm::vec2(this->font.stringWidth(word_list[i]) * 0.5, this->font.stringHeight(word_list[i]) * 0.5);

mesh_vertices.push_back(location);

rotate_vertices.push_back(rotation);

}

ofMesh face, line;

line.setMode(ofPrimitiveMode::OF_PRIMITIVE_LINES);

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

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

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

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

line.addVertex(glm::vec4(base_location, 0, 0) + glm::vec4(mesh_vertices[k], 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);

}

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(39);

face.draw();

ofSetColor(139);

line.drawWireframe();

}

this->cam.end();

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

[ Kinako ]

2021年6月16日2021年6月16日

RGB mask. Draw by openFrameworks

[ Video ]

[ About ]
RGB mask.

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

	ofImage image;
	ofFbo fbo;
};

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

ofImage image;

ofFbo fbo;

};

#include "ofApp.h"

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

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

	ofBackground(239);
	ofSetColor(255);
	ofSetRectMode(ofRectMode::OF_RECTMODE_CENTER);

	this->image.loadImage("images/lenna.png");
	this->image.resize(720, 720);
	this->fbo.allocate(720, 720);
}

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

	ofSeedRandom(39);

	this->fbo.begin();
	ofClear(0);
	ofEnableBlendMode(ofBlendMode::OF_BLENDMODE_ADD);

	ofTranslate(this->fbo.getWidth() * 0.5, this->fbo.getHeight() * 0.5);

	for (int k = 0; k < 3; k++) {

		switch (k % 3) {

		case 0:
			ofSetColor(255, 255, 0);
			break;
		case 1:
			ofSetColor(0, 255, 255);
			break;
		case 2:
			ofSetColor(255, 0, 255);
			break;
		}
		
		auto noise_seed = glm::vec2(ofRandom(1000), ofRandom(1000));

		ofMesh mesh;
		vector<glm::vec3> right, left;

		glm::vec3 last_location;
		float last_theta;
		int len = 100;
		int head_size = 45;

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

			auto location = glm::vec3(ofMap(ofNoise(noise_seed.x, (ofGetFrameNum() + i) * 0.008), 0, 1, -280, 280), ofMap(ofNoise(noise_seed.y, (ofGetFrameNum() + i) * 0.008), 0, 1, -280, 280), 0);
			auto next = glm::vec3(ofMap(ofNoise(noise_seed.x, (ofGetFrameNum() + i + 1) * 0.008), 0, 1, -280, 280), ofMap(ofNoise(noise_seed.y, (ofGetFrameNum() + i + 1) * 0.008), 0, 1, -280, 280), 0);

			auto direction = next - location;
			auto theta = atan2(direction.y, direction.x);

			right.push_back(location + glm::vec3(ofMap(i, 0, len, 0, head_size) * cos(theta + PI * 0.5), ofMap(i, 0, len, 0, head_size) * sin(theta + PI * 0.5), 0));
			left.push_back(location + glm::vec3(ofMap(i, 0, len, 0, head_size) * cos(theta - PI * 0.5), ofMap(i, 0, len, 0, head_size) * sin(theta - PI * 0.5), 0));

			last_location = location;
			last_theta = theta;
		}

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

			mesh.addVertex(left[i]);
			mesh.addVertex(right[i]);
		}

		for (int i = 0; i < mesh.getNumVertices() - 2; i += 2) {

			mesh.addIndex(i + 0); mesh.addIndex(i + 1); mesh.addIndex(i + 3);
			mesh.addIndex(i + 0); mesh.addIndex(i + 2); mesh.addIndex(i + 3);
		}

		auto tmp_head_size = ofMap(len - 2, 0, len, 0, head_size);
		mesh.addVertex(last_location);

		int index = mesh.getNumVertices();
		for (auto theta = last_theta - PI * 0.5; theta <= last_theta + PI * 0.5; theta += PI / 20) {

			mesh.addVertex(last_location + glm::vec3(tmp_head_size * cos(theta), tmp_head_size * sin(theta), 0));
		}

		for (int i = index; i < mesh.getNumVertices() - 1; i++) {

			mesh.addIndex(index); mesh.addIndex(i + 0); mesh.addIndex(i + 1);
		}

		mesh.draw();
	}

	ofDisableBlendMode();
	this->fbo.end();

	this->image.getTextureReference().setAlphaMask(this->fbo.getTexture());
	this->image.update();
}

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

	ofSetColor(255);
	this->image.draw(ofGetWindowSize() * 0.5);
}

//--------------------------------------------------------------
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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openframeworks");

ofBackground(239);

ofSetColor(255);

ofSetRectMode(ofRectMode::OF_RECTMODE_CENTER);

this->image.loadImage("images/lenna.png");

this->image.resize(720, 720);

this->fbo.allocate(720, 720);

}

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

void ofApp::update() {

ofSeedRandom(39);

this->fbo.begin();

ofClear(0);

ofEnableBlendMode(ofBlendMode::OF_BLENDMODE_ADD);

ofTranslate(this->fbo.getWidth() * 0.5, this->fbo.getHeight() * 0.5);

for (int k = 0; k < 3; k++) {

switch (k % 3) {

case 0:

ofSetColor(255, 255, 0);

break;

case 1:

ofSetColor(0, 255, 255);

break;

case 2:

ofSetColor(255, 0, 255);

break;

}

auto noise_seed = glm::vec2(ofRandom(1000), ofRandom(1000));

ofMesh mesh;

vector<glm::vec3> right, left;

glm::vec3 last_location;

float last_theta;

int len = 100;

int head_size = 45;

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

auto location = glm::vec3(ofMap(ofNoise(noise_seed.x, (ofGetFrameNum() + i) * 0.008), 0, 1, -280, 280), ofMap(ofNoise(noise_seed.y, (ofGetFrameNum() + i) * 0.008), 0, 1, -280, 280), 0);

auto next = glm::vec3(ofMap(ofNoise(noise_seed.x, (ofGetFrameNum() + i + 1) * 0.008), 0, 1, -280, 280), ofMap(ofNoise(noise_seed.y, (ofGetFrameNum() + i + 1) * 0.008), 0, 1, -280, 280), 0);

auto direction = next - location;

auto theta = atan2(direction.y, direction.x);

right.push_back(location + glm::vec3(ofMap(i, 0, len, 0, head_size) * cos(theta + PI * 0.5), ofMap(i, 0, len, 0, head_size) * sin(theta + PI * 0.5), 0));

left.push_back(location + glm::vec3(ofMap(i, 0, len, 0, head_size) * cos(theta - PI * 0.5), ofMap(i, 0, len, 0, head_size) * sin(theta - PI * 0.5), 0));

last_location = location;

last_theta = theta;

}

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

mesh.addVertex(left[i]);

mesh.addVertex(right[i]);

}

for (int i = 0; i < mesh.getNumVertices() - 2; i += 2) {

mesh.addIndex(i + 0); mesh.addIndex(i + 1); mesh.addIndex(i + 3);

mesh.addIndex(i + 0); mesh.addIndex(i + 2); mesh.addIndex(i + 3);

}

auto tmp_head_size = ofMap(len - 2, 0, len, 0, head_size);

mesh.addVertex(last_location);

int index = mesh.getNumVertices();

for (auto theta = last_theta - PI * 0.5; theta <= last_theta + PI * 0.5; theta += PI / 20) {

mesh.addVertex(last_location + glm::vec3(tmp_head_size * cos(theta), tmp_head_size * sin(theta), 0));

}

for (int i = index; i < mesh.getNumVertices() - 1; i++) {

mesh.addIndex(index); mesh.addIndex(i + 0); mesh.addIndex(i + 1);

}

mesh.draw();

}

ofDisableBlendMode();

this->fbo.end();

this->image.getTextureReference().setAlphaMask(this->fbo.getTexture());

this->image.update();

}

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

void ofApp::draw() {

ofSetColor(255);

this->image.draw(ofGetWindowSize() * 0.5);

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

[ Kinako ]

2021年6月14日2021年6月14日

gradation body and outline. Draw by openFrameworks

[ Video ]

[ About ]
gradation body and outline.

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

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

};

#include "ofApp.h"

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

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

	ofBackground(0);
}

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

	ofSeedRandom(39);
}

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

	ofTranslate(ofGetWidth() * 0.5, ofGetHeight() * 0.5);

	ofColor color, tmp_color;
	for (int k = 0; k < 23; k++) {

		auto noise_seed = glm::vec2(ofRandom(1000), ofRandom(1000));
		
		color.setHsb((int)ofRandom(200, 280) % 255, 255,255);

		ofMesh mesh, line;
		line.setMode(ofPrimitiveMode::OF_PRIMITIVE_LINES);
		vector<glm::vec3> right, left;

		glm::vec3 last_location;
		float last_theta;
		int len = 30;
		int head_size = 15;

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

			auto location = glm::vec3(ofMap(ofNoise(noise_seed.x, (ofGetFrameNum() + i) * 0.005), 0, 1, -325, 325), ofMap(ofNoise(noise_seed.y, (ofGetFrameNum() + i) * 0.005), 0, 1, -350, 350), 0);
			auto next = glm::vec3(ofMap(ofNoise(noise_seed.x, (ofGetFrameNum() + i + 1) * 0.005), 0, 1, -325, 325), ofMap(ofNoise(noise_seed.y, (ofGetFrameNum() + i + 1) * 0.005), 0, 1, -350, 350), 0);

			auto direction = next - location;
			auto theta = atan2(direction.y, direction.x);

			right.push_back(location + glm::vec3(ofMap(i, 0, len, 0, head_size) * cos(theta + PI * 0.5), ofMap(i, 0, len, 0, head_size) * sin(theta + PI * 0.5), 0));
			left.push_back(location + glm::vec3(ofMap(i, 0, len, 0, head_size) * cos(theta - PI * 0.5), ofMap(i, 0, len, 0, head_size) * sin(theta - PI * 0.5), 0));

			last_location = location;
			last_theta = theta;
		}

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

			mesh.addVertex(left[i]);
			mesh.addVertex(right[i]);

			line.addVertex(left[i]);
			line.addVertex(right[i]);

			if (i > right.size() * 0.5) {
				
				tmp_color.setHsb(color.getHue(), color.getSaturation(), ofMap(i, right.size(), right.size() * 0.5, color.getBrightness(), 16));
			}
			else {

				tmp_color.setHsb(color.getHue(), color.getSaturation(), 32);
			}

			mesh.addColor(tmp_color);
			mesh.addColor(tmp_color);

			line.addColor(color);
			line.addColor(color);
		}

		for (int i = 0; i < mesh.getNumVertices() - 2; i += 2) {

			mesh.addIndex(i + 0); mesh.addIndex(i + 1); mesh.addIndex(i + 3);
			mesh.addIndex(i + 0); mesh.addIndex(i + 2); mesh.addIndex(i + 3);

			line.addIndex(i + 0); line.addIndex(i + 2);
			line.addIndex(i + 1); line.addIndex(i + 3);
		}

		auto tmp_head_size = ofMap(len - 2, 0, len, 0, head_size);
		tmp_color.setHsb(color.getHue(), color.getSaturation(), ofMap(len - 2, right.size(), right.size() * 0.5, color.getBrightness(), 16));

		mesh.addVertex(last_location);
		mesh.addColor(tmp_color);
		line.addVertex(last_location);
		line.addColor(color);

		int index = mesh.getNumVertices();
		tmp_color.setHsb(color.getHue(), color.getSaturation(), ofMap(len, right.size(), right.size() * 0.5, color.getBrightness(), 16));
		for (auto theta = last_theta - PI * 0.5; theta <= last_theta + PI * 0.5; theta += PI / 20) {

			mesh.addVertex(last_location + glm::vec3(tmp_head_size * cos(theta), tmp_head_size * sin(theta), 0));
			line.addVertex(last_location + glm::vec3(tmp_head_size * cos(theta), tmp_head_size * sin(theta), 0));
			mesh.addColor(tmp_color);
			line.addColor(color);
		}

		for (int i = index; i < mesh.getNumVertices() - 1; i++) {

			mesh.addIndex(index); mesh.addIndex(i + 0); mesh.addIndex(i + 1);
			line.addIndex(i + 0); line.addIndex(i + 1);
		}

		mesh.draw();
		line.drawWireframe();
	}
}

//--------------------------------------------------------------
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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openframeworks");

ofBackground(0);

}

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

void ofApp::update() {

ofSeedRandom(39);

}

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

void ofApp::draw() {

ofTranslate(ofGetWidth() * 0.5, ofGetHeight() * 0.5);

ofColor color, tmp_color;

for (int k = 0; k < 23; k++) {

auto noise_seed = glm::vec2(ofRandom(1000), ofRandom(1000));

color.setHsb((int)ofRandom(200, 280) % 255, 255,255);

ofMesh mesh, line;

line.setMode(ofPrimitiveMode::OF_PRIMITIVE_LINES);

vector<glm::vec3> right, left;

glm::vec3 last_location;

float last_theta;

int len = 30;

int head_size = 15;

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

auto location = glm::vec3(ofMap(ofNoise(noise_seed.x, (ofGetFrameNum() + i) * 0.005), 0, 1, -325, 325), ofMap(ofNoise(noise_seed.y, (ofGetFrameNum() + i) * 0.005), 0, 1, -350, 350), 0);

auto next = glm::vec3(ofMap(ofNoise(noise_seed.x, (ofGetFrameNum() + i + 1) * 0.005), 0, 1, -325, 325), ofMap(ofNoise(noise_seed.y, (ofGetFrameNum() + i + 1) * 0.005), 0, 1, -350, 350), 0);

auto direction = next - location;

auto theta = atan2(direction.y, direction.x);

right.push_back(location + glm::vec3(ofMap(i, 0, len, 0, head_size) * cos(theta + PI * 0.5), ofMap(i, 0, len, 0, head_size) * sin(theta + PI * 0.5), 0));

left.push_back(location + glm::vec3(ofMap(i, 0, len, 0, head_size) * cos(theta - PI * 0.5), ofMap(i, 0, len, 0, head_size) * sin(theta - PI * 0.5), 0));

last_location = location;

last_theta = theta;

}

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

mesh.addVertex(left[i]);

mesh.addVertex(right[i]);

line.addVertex(left[i]);

line.addVertex(right[i]);

if (i > right.size() * 0.5) {

tmp_color.setHsb(color.getHue(), color.getSaturation(), ofMap(i, right.size(), right.size() * 0.5, color.getBrightness(), 16));

}

else {

tmp_color.setHsb(color.getHue(), color.getSaturation(), 32);

}

mesh.addColor(tmp_color);

line.addColor(color);

}

for (int i = 0; i < mesh.getNumVertices() - 2; i += 2) {

mesh.addIndex(i + 0); mesh.addIndex(i + 1); mesh.addIndex(i + 3);

mesh.addIndex(i + 0); mesh.addIndex(i + 2); mesh.addIndex(i + 3);

line.addIndex(i + 0); line.addIndex(i + 2);

line.addIndex(i + 1); line.addIndex(i + 3);

}

auto tmp_head_size = ofMap(len - 2, 0, len, 0, head_size);

tmp_color.setHsb(color.getHue(), color.getSaturation(), ofMap(len - 2, right.size(), right.size() * 0.5, color.getBrightness(), 16));

mesh.addVertex(last_location);

mesh.addColor(tmp_color);

line.addVertex(last_location);

line.addColor(color);

int index = mesh.getNumVertices();

tmp_color.setHsb(color.getHue(), color.getSaturation(), ofMap(len, right.size(), right.size() * 0.5, color.getBrightness(), 16));

for (auto theta = last_theta - PI * 0.5; theta <= last_theta + PI * 0.5; theta += PI / 20) {

mesh.addVertex(last_location + glm::vec3(tmp_head_size * cos(theta), tmp_head_size * sin(theta), 0));

line.addVertex(last_location + glm::vec3(tmp_head_size * cos(theta), tmp_head_size * sin(theta), 0));

mesh.addColor(tmp_color);

line.addColor(color);

}

for (int i = index; i < mesh.getNumVertices() - 1; i++) {

mesh.addIndex(index); mesh.addIndex(i + 0); mesh.addIndex(i + 1);

line.addIndex(i + 0); line.addIndex(i + 1);

}

mesh.draw();

line.drawWireframe();

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

[ Kinako ]

2025年7月
月	火	水	木	金	土	日
	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	31