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

2026年2月19日

Twin rays.

[ Video ]

[ About ]
双子の光線。

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

	vector<glm::vec3> 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) {};

vector<glm::vec3> param_list;

};

#include "ofApp.h"

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

	ofSetFrameRate(25);
	ofSetWindowTitle("openframeworks");

	ofBackground(39);
	ofEnableBlendMode(ofBlendMode::OF_BLENDMODE_ADD);
	ofSetColor(64);
}

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

	ofSeedRandom(39);
}

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

	ofTranslate(ofGetWindowSize() * 0.5);

	auto len = 20;
	for (int k = 0; k < 4; k++) {

		auto head_size = 8;
		auto param = glm::vec2(ofRandom(1000), ofRandom(1000));

		for (int j = 0; j < 4; j++) {

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

			glm::vec3 last_location;
			float last_theta, last_radius;

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

				auto noise_deg = ofMap(ofNoise(param.x, (ofGetFrameNum() + i) * 0.003), 0, 1, -720, 720);
				auto noise_radius = ofMap(ofNoise(param.y, (ofGetFrameNum() + i) * 0.015), 0, 1, -360, 360);
				auto next_noise_deg = ofMap(ofNoise(param.x, (ofGetFrameNum() + i + 1) * 0.003), 0, 1, -720, 720);
				auto next_noise_radius = ofMap(ofNoise(param.y, (ofGetFrameNum() + i + 1) * 0.015), 0, 1, -360, 360);

				auto location = glm::vec3(noise_radius * cos(noise_deg * DEG_TO_RAD), noise_radius * sin(noise_deg * DEG_TO_RAD), 0);
				auto next = glm::vec3(next_noise_radius * cos(next_noise_deg * DEG_TO_RAD), next_noise_radius * sin(next_noise_deg * DEG_TO_RAD), 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, 16, 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, 16, 0, head_size) * sin(theta - PI * 0.5), 0));

				last_location = location;
				last_theta = theta;
				last_radius = noise_radius;
			}

			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(mesh.getNumVertices() - 2, 0, mesh.getNumVertices(), 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));
				frame.push_back(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);
			}

			int span = 2;
			int deg_span = 360 / span;
			for (int deg = 0; deg < 360; deg += deg_span) {

				ofRotate(deg_span);
				mesh.draw();
			}

			head_size -= 4;
		}
	}

	/*
	// ffmpeg -i img_%04d.jpg aaa.mp4
	int start = 500;
	if (ofGetFrameNum() > start) {

		std::ostringstream os;
		os << std::setw(4) << std::setfill('0') << ofGetFrameNum() - start;
		ofImage image;
		image.grabScreen(0, 0, ofGetWidth(), ofGetHeight());
		image.saveImage("image/cap/img_" + os.str() + ".jpg");
		if (ofGetFrameNum() - start >= 25 * 20) {

			std::exit(1);
		}
	}
	*/
}


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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(25);

ofSetWindowTitle("openframeworks");

ofBackground(39);

ofEnableBlendMode(ofBlendMode::OF_BLENDMODE_ADD);

ofSetColor(64);

}

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

void ofApp::update() {

ofSeedRandom(39);

}

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

void ofApp::draw() {

ofTranslate(ofGetWindowSize() * 0.5);

auto len = 20;

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

auto head_size = 8;

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

for (int j = 0; j < 4; j++) {

ofMesh mesh;

vector<glm::vec3> right, left, frame;

glm::vec3 last_location;

float last_theta, last_radius;

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

auto noise_deg = ofMap(ofNoise(param.x, (ofGetFrameNum() + i) * 0.003), 0, 1, -720, 720);

auto noise_radius = ofMap(ofNoise(param.y, (ofGetFrameNum() + i) * 0.015), 0, 1, -360, 360);

auto next_noise_deg = ofMap(ofNoise(param.x, (ofGetFrameNum() + i + 1) * 0.003), 0, 1, -720, 720);

auto next_noise_radius = ofMap(ofNoise(param.y, (ofGetFrameNum() + i + 1) * 0.015), 0, 1, -360, 360);

auto location = glm::vec3(noise_radius * cos(noise_deg * DEG_TO_RAD), noise_radius * sin(noise_deg * DEG_TO_RAD), 0);

auto next = glm::vec3(next_noise_radius * cos(next_noise_deg * DEG_TO_RAD), next_noise_radius * sin(next_noise_deg * DEG_TO_RAD), 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, 16, 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, 16, 0, head_size) * sin(theta - PI * 0.5), 0));

last_location = location;

last_theta = theta;

last_radius = noise_radius;

}

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(mesh.getNumVertices() - 2, 0, mesh.getNumVertices(), 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));

frame.push_back(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);

}

int span = 2;

int deg_span = 360 / span;

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

ofRotate(deg_span);

mesh.draw();

}

head_size -= 4;

}

// ffmpeg -i img_%04d.jpg aaa.mp4

int start = 500;

if (ofGetFrameNum() > start) {

std::ostringstream os;

os << std::setw(4) << std::setfill('0') << ofGetFrameNum() - start;

ofImage image;

image.grabScreen(0, 0, ofGetWidth(), ofGetHeight());

image.saveImage("image/cap/img_" + os.str() + ".jpg");

if (ofGetFrameNum() - start >= 25 * 20) {

std::exit(1);

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

[ Link ]
https://github.com/junkiyoshi/DoodleDeProgramming/tree/cb63b4835cf04fc0e7e7a86f8ecd625119766065

2026年2月18日

Red and Balck.

[ Video ]

[ About ]
赤と黒。

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

	vector<glm::vec3> 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) {};

vector<glm::vec3> param_list;

};

#include "ofApp.h"

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

	ofSetFrameRate(25);
	ofSetWindowTitle("openframeworks");

	ofBackground(239);
}

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

	ofSeedRandom(39);
}

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

	ofTranslate(ofGetWindowSize() * 0.5);

	auto len = 15;

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

		auto head_size = 8;
		auto param = glm::vec2(ofRandom(1000), ofRandom(1000));

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

			j % 2 == 0 ? ofSetColor(0) : ofSetColor(255, 0, 0);

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

			glm::vec3 last_location;
			float last_theta, last_radius;

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

				auto noise_deg = ofMap(ofNoise(param.x, (ofGetFrameNum() + i) * 0.0025), 0, 1, -720, 720);
				auto noise_radius = ofMap(ofNoise(param.y, (ofGetFrameNum() + i) * 0.015), 0, 1, -360, 360);
				auto next_noise_deg = ofMap(ofNoise(param.x, (ofGetFrameNum() + i + 1) * 0.0025), 0, 1, -720, 720);
				auto next_noise_radius = ofMap(ofNoise(param.y, (ofGetFrameNum() + i + 1) * 0.015), 0, 1, -360, 360);

				auto location = glm::vec3(noise_radius * cos(noise_deg * DEG_TO_RAD), noise_radius * sin(noise_deg * DEG_TO_RAD), 0);
				auto next = glm::vec3(next_noise_radius * cos(next_noise_deg * DEG_TO_RAD), next_noise_radius * sin(next_noise_deg * DEG_TO_RAD), 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, 16, 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, 16, 0, head_size) * sin(theta - PI * 0.5), 0));

				last_location = location;
				last_theta = theta;
				last_radius = noise_radius;
			}

			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(mesh.getNumVertices() - 2, 0, mesh.getNumVertices(), 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));
				frame.push_back(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);
			}

			int span = 6;
			int deg_span = 360 / span;
			for (int deg = 0; deg < 360; deg += deg_span) {

				ofRotate(deg_span);
				mesh.draw();
			}

			head_size -= 2;
		}
	}

	/*
	// ffmpeg -i img_%04d.jpg aaa.mp4
	int start = 500;
	if (ofGetFrameNum() > start) {

		std::ostringstream os;
		os << std::setw(4) << std::setfill('0') << ofGetFrameNum() - start;
		ofImage image;
		image.grabScreen(0, 0, ofGetWidth(), ofGetHeight());
		image.saveImage("image/cap/img_" + os.str() + ".jpg");
		if (ofGetFrameNum() - start >= 25 * 20) {

			std::exit(1);
		}
	}
	*/
}


//--------------------------------------------------------------
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(25);

ofSetWindowTitle("openframeworks");

ofBackground(239);

}

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

void ofApp::update() {

ofSeedRandom(39);

}

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

void ofApp::draw() {

ofTranslate(ofGetWindowSize() * 0.5);

auto len = 15;

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

auto head_size = 8;

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

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

j % 2 == 0 ? ofSetColor(0) : ofSetColor(255, 0, 0);

ofMesh mesh;

vector<glm::vec3> right, left, frame;

glm::vec3 last_location;

float last_theta, last_radius;

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

auto noise_deg = ofMap(ofNoise(param.x, (ofGetFrameNum() + i) * 0.0025), 0, 1, -720, 720);

auto noise_radius = ofMap(ofNoise(param.y, (ofGetFrameNum() + i) * 0.015), 0, 1, -360, 360);

auto next_noise_deg = ofMap(ofNoise(param.x, (ofGetFrameNum() + i + 1) * 0.0025), 0, 1, -720, 720);

auto next_noise_radius = ofMap(ofNoise(param.y, (ofGetFrameNum() + i + 1) * 0.015), 0, 1, -360, 360);

auto location = glm::vec3(noise_radius * cos(noise_deg * DEG_TO_RAD), noise_radius * sin(noise_deg * DEG_TO_RAD), 0);

auto next = glm::vec3(next_noise_radius * cos(next_noise_deg * DEG_TO_RAD), next_noise_radius * sin(next_noise_deg * DEG_TO_RAD), 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, 16, 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, 16, 0, head_size) * sin(theta - PI * 0.5), 0));

last_location = location;

last_theta = theta;

last_radius = noise_radius;

}

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(mesh.getNumVertices() - 2, 0, mesh.getNumVertices(), 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));

frame.push_back(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);

}

int span = 6;

int deg_span = 360 / span;

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

ofRotate(deg_span);

mesh.draw();

}

head_size -= 2;

}

// ffmpeg -i img_%04d.jpg aaa.mp4

int start = 500;

if (ofGetFrameNum() > start) {

std::ostringstream os;

os << std::setw(4) << std::setfill('0') << ofGetFrameNum() - start;

ofImage image;

image.grabScreen(0, 0, ofGetWidth(), ofGetHeight());

image.saveImage("image/cap/img_" + os.str() + ".jpg");

if (ofGetFrameNum() - start >= 25 * 20) {

std::exit(1);

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

[ Link ]
https://github.com/junkiyoshi/DoodleDeProgramming/tree/1024f889885a5f6312fd9da86c6758b63ee2caad

2026年2月17日

Pyramid.

[ Video ]

[ About ]
ピラミッド。

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

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

};

#include "ofApp.h"

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

	ofSetFrameRate(25);
	ofSetWindowTitle("openframeworks");

	ofBackground(39);
	ofSetColor(239);
	ofSetLineWidth(1.5);
	ofEnableDepthTest();
}

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

	ofSeedRandom(39);
}

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

	this->cam.begin();

	ofRotateZ(ofRandom(360) + ofGetFrameNum() * ofRandom(1, 3));
	ofRotateY(ofRandom(360) + ofGetFrameNum() * ofRandom(1, 3));
	ofRotateX(ofRandom(360) + ofGetFrameNum() * ofRandom(1, 3));

	for (auto param = 130; param >= 10; param -= 60) {

		ofMesh mesh;
		glm::vec3 avg;
		float noise_value;

		vector<glm::vec3> vertices;
		vertices.push_back(glm::vec4(param, param, param, 0));
		vertices.push_back(glm::vec4(param, -param, -param, 0));
		vertices.push_back(glm::vec4(-param, param, -param, 0));
		vertices.push_back(glm::vec4(-param, -param, param, 0));

		avg = (vertices[0] + vertices[1] + vertices[2]) / 3;
		noise_value = ofNoise(glm::vec4(avg * 0.0085, ofGetFrameNum() * 0.05));
		noise_value = noise_value < 0.5 ? 0 : ofMap(noise_value, 0.5, 1, 0, 10);

		mesh.addVertex(vertices[0] + avg * noise_value);
		mesh.addVertex(vertices[1] + avg * noise_value);
		mesh.addVertex(vertices[2] + avg * noise_value);

		avg = (vertices[0] + vertices[1] + vertices[3]) / 3;
		noise_value = ofNoise(glm::vec4(avg * 0.0085, ofGetFrameNum() * 0.05));
		noise_value = noise_value < 0.5 ? 0 : ofMap(noise_value, 0.5, 1, 0, 10);

		mesh.addVertex(vertices[0] + avg * noise_value);
		mesh.addVertex(vertices[1] + avg * noise_value);
		mesh.addVertex(vertices[3] + avg * noise_value);

		avg = (vertices[0] + vertices[2] + vertices[3]) / 3;
		noise_value = ofNoise(glm::vec4(avg * 0.0085, ofGetFrameNum() * 0.05));
		noise_value = noise_value < 0.5 ? 0 : ofMap(noise_value, 0.5, 1, 0, 10);

		mesh.addVertex(vertices[0] + avg * noise_value);
		mesh.addVertex(vertices[2] + avg * noise_value);
		mesh.addVertex(vertices[3] + avg * noise_value);

		avg = (vertices[1] + vertices[2] + vertices[3]) / 3;
		noise_value = ofNoise(glm::vec4(avg * 0.0085, ofGetFrameNum() * 0.05));
		noise_value = noise_value < 0.5 ? 0 : ofMap(noise_value, 0.5, 1, 0, 5);

		mesh.addVertex(vertices[1] + avg * noise_value);
		mesh.addVertex(vertices[2] + avg * noise_value);
		mesh.addVertex(vertices[3] + avg * noise_value);

		ofSetColor(239);
		mesh.drawWireframe();
	}

	this->cam.end();

	/*
	// ffmpeg -i img_%04d.jpg aaa.mp4
	int start = 500;
	if (ofGetFrameNum() > start) {

		std::ostringstream os;
		os << std::setw(4) << std::setfill('0') << ofGetFrameNum() - start;
		ofImage image;
		image.grabScreen(0, 0, ofGetWidth(), ofGetHeight());
		image.saveImage("image/cap/img_" + os.str() + ".jpg");
		if (ofGetFrameNum() - start >= 25 * 20) {

			std::exit(1);
		}
	}
	*/
}

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

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

100

101

102

103

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(25);

ofSetWindowTitle("openframeworks");

ofBackground(39);

ofSetColor(239);

ofSetLineWidth(1.5);

ofEnableDepthTest();

}

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

void ofApp::update() {

ofSeedRandom(39);

}

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

void ofApp::draw() {

this->cam.begin();

ofRotateZ(ofRandom(360) + ofGetFrameNum() * ofRandom(1, 3));

ofRotateY(ofRandom(360) + ofGetFrameNum() * ofRandom(1, 3));

ofRotateX(ofRandom(360) + ofGetFrameNum() * ofRandom(1, 3));

for (auto param = 130; param >= 10; param -= 60) {

ofMesh mesh;

glm::vec3 avg;

float noise_value;

vector<glm::vec3> vertices;

vertices.push_back(glm::vec4(param, param, param, 0));

vertices.push_back(glm::vec4(param, -param, -param, 0));

vertices.push_back(glm::vec4(-param, param, -param, 0));

vertices.push_back(glm::vec4(-param, -param, param, 0));

avg = (vertices[0] + vertices[1] + vertices[2]) / 3;

noise_value = ofNoise(glm::vec4(avg * 0.0085, ofGetFrameNum() * 0.05));

noise_value = noise_value < 0.5 ? 0 : ofMap(noise_value, 0.5, 1, 0, 10);

mesh.addVertex(vertices[0] + avg * noise_value);

mesh.addVertex(vertices[1] + avg * noise_value);

mesh.addVertex(vertices[2] + avg * noise_value);

avg = (vertices[0] + vertices[1] + vertices[3]) / 3;

noise_value = ofNoise(glm::vec4(avg * 0.0085, ofGetFrameNum() * 0.05));

noise_value = noise_value < 0.5 ? 0 : ofMap(noise_value, 0.5, 1, 0, 10);

mesh.addVertex(vertices[0] + avg * noise_value);

mesh.addVertex(vertices[1] + avg * noise_value);

mesh.addVertex(vertices[3] + avg * noise_value);

avg = (vertices[0] + vertices[2] + vertices[3]) / 3;

noise_value = ofNoise(glm::vec4(avg * 0.0085, ofGetFrameNum() * 0.05));

noise_value = noise_value < 0.5 ? 0 : ofMap(noise_value, 0.5, 1, 0, 10);

mesh.addVertex(vertices[0] + avg * noise_value);

mesh.addVertex(vertices[2] + avg * noise_value);

mesh.addVertex(vertices[3] + avg * noise_value);

avg = (vertices[1] + vertices[2] + vertices[3]) / 3;

noise_value = ofNoise(glm::vec4(avg * 0.0085, ofGetFrameNum() * 0.05));

noise_value = noise_value < 0.5 ? 0 : ofMap(noise_value, 0.5, 1, 0, 5);

mesh.addVertex(vertices[1] + avg * noise_value);

mesh.addVertex(vertices[2] + avg * noise_value);

mesh.addVertex(vertices[3] + avg * noise_value);

ofSetColor(239);

mesh.drawWireframe();

}

this->cam.end();

// ffmpeg -i img_%04d.jpg aaa.mp4

int start = 500;

if (ofGetFrameNum() > start) {

std::ostringstream os;

os << std::setw(4) << std::setfill('0') << ofGetFrameNum() - start;

ofImage image;

image.grabScreen(0, 0, ofGetWidth(), ofGetHeight());

image.saveImage("image/cap/img_" + os.str() + ".jpg");

if (ofGetFrameNum() - start >= 25 * 20) {

std::exit(1);

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

[ Link ]
https://github.com/junkiyoshi/DoodleDeProgramming/tree/d7b150ae611fe11b75a41d37e6add73377549090

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