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

2026年2月27日2026年2月26日

Spider’s web orb.

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

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

ofMesh mesh;

};

#include "ofApp.h"

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

	ofSetFrameRate(25);
	ofSetWindowTitle("openFrameworks");

	ofBackground(39);
	ofSetLineWidth(0.5);
	ofEnableDepthTest();

	this->mesh.setMode(ofPrimitiveMode::OF_PRIMITIVE_LINES);
}

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

	ofSeedRandom(39);

	vector<float> min_distance_list;
	this->mesh.clear();

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

		auto vertex = glm::vec3(
			ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.001), 0, 1, -160, 160),
			ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.001), 0, 1, -160, 160),
			ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.001), 0, 1, -160, 160));
		this->mesh.addVertex(vertex);
		min_distance_list.push_back(40);
	}

	for (auto& vertex : this->mesh.getVertices()) {

		auto len = glm::length(vertex);
		if (len < 150) {

			vertex = glm::normalize(vertex) * 150;
		}
	}


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

		for (int k = 0; k < this->mesh.getNumVertices(); k++) {

			if (i == k) { continue; }

			auto distance = glm::distance(this->mesh.getVertex(i), this->mesh.getVertex(k));
			if (distance < 30) {

				this->mesh.addIndex(i);
				this->mesh.addIndex(k);

				if (distance < min_distance_list[i]) {

					min_distance_list[i] = distance;
				}
			}
		}

		this->mesh.addColor(ofColor(255, ofMap(min_distance_list[i], 0, 30, 255, 0)));
	}
}

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

	this->cam.begin();

	ofRotateY(ofGetFrameNum() * 0.72);

	this->mesh.draw();

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

		ofSetColor(this->mesh.getColor(i));
		ofDrawSphere(this->mesh.getVertex(i), 1.5);
	}

	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

104

105

106

107

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(25);

ofSetWindowTitle("openFrameworks");

ofBackground(39);

ofSetLineWidth(0.5);

ofEnableDepthTest();

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

}

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

void ofApp::update() {

ofSeedRandom(39);

vector<float> min_distance_list;

this->mesh.clear();

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

auto vertex = glm::vec3(

ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.001), 0, 1, -160, 160),

ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.001), 0, 1, -160, 160));

this->mesh.addVertex(vertex);

min_distance_list.push_back(40);

}

for (auto& vertex : this->mesh.getVertices()) {

auto len = glm::length(vertex);

if (len < 150) {

vertex = glm::normalize(vertex) * 150;

}

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

for (int k = 0; k < this->mesh.getNumVertices(); k++) {

if (i == k) { continue; }

auto distance = glm::distance(this->mesh.getVertex(i), this->mesh.getVertex(k));

if (distance < 30) {

this->mesh.addIndex(i);

this->mesh.addIndex(k);

if (distance < min_distance_list[i]) {

min_distance_list[i] = distance;

}

this->mesh.addColor(ofColor(255, ofMap(min_distance_list[i], 0, 30, 255, 0)));

}

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

void ofApp::draw() {

this->cam.begin();

ofRotateY(ofGetFrameNum() * 0.72);

this->mesh.draw();

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

ofSetColor(this->mesh.getColor(i));

ofDrawSphere(this->mesh.getVertex(i), 1.5);

}

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

2026年2月26日

Sphere in the box.

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

	glm::vec3 make_point(float R, float r, float u, float v);

	ofEasyCam cam;
	ofMesh mesh;
};

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

glm::vec3 make_point(float R, float r, float u, float v);

ofEasyCam cam;

ofMesh mesh;

};

#include "ofApp.h"

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

	ofSetFrameRate(25);
	ofSetWindowTitle("openFrameworks");

	ofBackground(239);
	ofEnableDepthTest();
	ofNoFill();

	this->mesh.setMode(ofPrimitiveMode::OF_PRIMITIVE_LINES);
}

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

	ofSeedRandom(39);

	vector<float> min_distance_list;
	this->mesh.clear();

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

		auto vertex = glm::vec3(
			ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.001), 0, 1, -300, 300),
			ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.001), 0, 1, -300, 300),
			ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.001), 0, 1, -300, 300));
		this->mesh.addVertex(vertex);
		min_distance_list.push_back(40);
	}

	for (auto& vertex : this->mesh.getVertices()) {

		vertex.x = vertex.x < -150 ? -150 : vertex.x > 150 ? 150 : vertex.x;
		vertex.y = vertex.y < -150 ? -150 : vertex.y > 150 ? 150 : vertex.y;
		vertex.z = vertex.z < -150 ? -150 : vertex.z > 150 ? 150 : vertex.z;

		auto len = glm::length(vertex);
		if (len < 210) {

			vertex = glm::normalize(vertex) * 210;
		}
	}


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

		for (int k = 0; k < this->mesh.getNumVertices(); k++) {

			if (i == k) { continue; }

			auto distance = glm::distance(this->mesh.getVertex(i), this->mesh.getVertex(k));
			if (distance < 30) {

				this->mesh.addIndex(i);
				this->mesh.addIndex(k);

				if (distance < min_distance_list[i]) {

					min_distance_list[i] = distance;
				}
			}
		}

		this->mesh.addColor(ofColor(39, ofMap(min_distance_list[i], 0, 30, 255, 0)));
	}
}

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

	this->cam.begin();

	ofRotateY(ofGetFrameNum() * 1.44);

	this->mesh.draw();

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

		ofSetColor(this->mesh.getColor(i));
		ofDrawSphere(this->mesh.getVertex(i), 1.5);
	}

	ofSetColor(0);
	ofDrawBox(300);

	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);
		}
	}
	*/
}

//--------------------------------------------------------------
glm::vec3 ofApp::make_point(float R, float r, float u, float v) {

	// 数学デッサン教室 描いて楽しむ数学たち　P.31

	u *= DEG_TO_RAD;
	v *= DEG_TO_RAD;

	auto x = (R + r * cos(u)) * cos(v);
	auto y = (R + r * cos(u)) * sin(v);
	auto z = r * sin(u);

	return glm::vec3(x, y, z);
}


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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(25);

ofSetWindowTitle("openFrameworks");

ofBackground(239);

ofEnableDepthTest();

ofNoFill();

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

}

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

void ofApp::update() {

ofSeedRandom(39);

vector<float> min_distance_list;

this->mesh.clear();

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

auto vertex = glm::vec3(

ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.001), 0, 1, -300, 300),

ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.001), 0, 1, -300, 300));

this->mesh.addVertex(vertex);

min_distance_list.push_back(40);

}

for (auto& vertex : this->mesh.getVertices()) {

vertex.x = vertex.x < -150 ? -150 : vertex.x > 150 ? 150 : vertex.x;

vertex.y = vertex.y < -150 ? -150 : vertex.y > 150 ? 150 : vertex.y;

vertex.z = vertex.z < -150 ? -150 : vertex.z > 150 ? 150 : vertex.z;

auto len = glm::length(vertex);

if (len < 210) {

vertex = glm::normalize(vertex) * 210;

}

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

for (int k = 0; k < this->mesh.getNumVertices(); k++) {

if (i == k) { continue; }

auto distance = glm::distance(this->mesh.getVertex(i), this->mesh.getVertex(k));

if (distance < 30) {

this->mesh.addIndex(i);

this->mesh.addIndex(k);

if (distance < min_distance_list[i]) {

min_distance_list[i] = distance;

}

this->mesh.addColor(ofColor(39, ofMap(min_distance_list[i], 0, 30, 255, 0)));

}

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

void ofApp::draw() {

this->cam.begin();

ofRotateY(ofGetFrameNum() * 1.44);

this->mesh.draw();

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

ofSetColor(this->mesh.getColor(i));

ofDrawSphere(this->mesh.getVertex(i), 1.5);

}

ofSetColor(0);

ofDrawBox(300);

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

}

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

glm::vec3 ofApp::make_point(float R, float r, float u, float v) {

// 数学デッサン教室描いて楽しむ数学たち　P.31

u *= DEG_TO_RAD;

v *= DEG_TO_RAD;

auto x = (R + r * cos(u)) * cos(v);

auto y = (R + r * cos(u)) * sin(v);

auto z = r * sin(u);

return glm::vec3(x, y, z);

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

2026年2月25日

Divided circle.

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

	void setRingToMesh(ofMesh& mesh, glm::vec3 location, float radius, float width, int deg_start, int deg_end, ofColor color);

	ofMesh mesh;
	float noise_param;
};

#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& mesh, glm::vec3 location, float radius, float width, int deg_start, int deg_end, ofColor color);

ofMesh mesh;

float noise_param;

};

#include "ofApp.h"

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

	ofSetFrameRate(25);
	ofSetWindowTitle("openFrameworks");

	ofBackground(39);
	ofEnableBlendMode(ofBlendMode::OF_BLENDMODE_ADD);

	this->noise_param = ofRandom(1000);
}

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

	ofSeedRandom(39);

	this->mesh.clear();

	int width = 10;
	int deg_span = 30;

	ofColor color;

	for (int x = 180; x < ofGetWidth(); x += 360) {

		for (int y = 180; y < ofGetHeight(); y += 360) {

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

				color.setHsb(ofMap(i, 0, 8, 0, 255), 200, 255, 128);

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

					auto noise_param = ofRandom(1000);
					int radius = ofMap(ofNoise(noise_param, cos(deg * DEG_TO_RAD) * 15, sin(deg * DEG_TO_RAD) * 15, this->noise_param), 0, 1, 30, 180);

					this->setRingToMesh(this->mesh, glm::vec3(x, y, 0), radius, width, deg, deg + deg_span, color);
				}
			}
		}
	}

	this->noise_param += 0.02;
}

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

	this->mesh.draw();

	/*
	// ffmpeg -i img_%04d.jpg aaa.mp4
	int start = 50;
	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);
		}
	}
	*/
}

//--------------------------------------------------------------
void ofApp::setRingToMesh(ofMesh& mesh, glm::vec3 location, float radius, float width, int deg_start, int deg_end, ofColor color) {

	if (deg_start == deg_end) { return; }

	int deg_span = 5;
	for (int deg = deg_start; deg < deg_end; deg += deg_span) {

		auto index = mesh.getNumVertices();

		vector<glm::vec3> vertices;
		vertices.push_back(location + glm::vec3((radius + width * 0.5) * cos(deg * DEG_TO_RAD), (radius + width * 0.5) * sin(deg * DEG_TO_RAD), 0));
		vertices.push_back(location + glm::vec3((radius + width * 0.5) * cos((deg + deg_span) * DEG_TO_RAD), (radius + width * 0.5) * sin((deg + deg_span) * DEG_TO_RAD), 0));
		vertices.push_back(location + glm::vec3((radius - width * 0.5) * cos((deg + deg_span) * DEG_TO_RAD), (radius - width * 0.5) * sin((deg + deg_span) * DEG_TO_RAD), 0));
		vertices.push_back(location + glm::vec3((radius - width * 0.5) * cos(deg * DEG_TO_RAD), (radius - width * 0.5) * sin(deg * DEG_TO_RAD), 0));

		mesh.addVertices(vertices);

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

		mesh.addColor(color);
		mesh.addColor(color);
		mesh.addColor(color);
		mesh.addColor(color);
	}
}

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

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

100

101

102

103

104

105

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(25);

ofSetWindowTitle("openFrameworks");

ofBackground(39);

ofEnableBlendMode(ofBlendMode::OF_BLENDMODE_ADD);

this->noise_param = ofRandom(1000);

}

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

void ofApp::update() {

ofSeedRandom(39);

this->mesh.clear();

int width = 10;

int deg_span = 30;

ofColor color;

for (int x = 180; x < ofGetWidth(); x += 360) {

for (int y = 180; y < ofGetHeight(); y += 360) {

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

color.setHsb(ofMap(i, 0, 8, 0, 255), 200, 255, 128);

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

auto noise_param = ofRandom(1000);

int radius = ofMap(ofNoise(noise_param, cos(deg * DEG_TO_RAD) * 15, sin(deg * DEG_TO_RAD) * 15, this->noise_param), 0, 1, 30, 180);

this->setRingToMesh(this->mesh, glm::vec3(x, y, 0), radius, width, deg, deg + deg_span, color);

}

this->noise_param += 0.02;

}

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

void ofApp::draw() {

this->mesh.draw();

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

int start = 50;

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

}

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

void ofApp::setRingToMesh(ofMesh& mesh, glm::vec3 location, float radius, float width, int deg_start, int deg_end, ofColor color) {

if (deg_start == deg_end) { return; }

int deg_span = 5;

for (int deg = deg_start; deg < deg_end; deg += deg_span) {

auto index = mesh.getNumVertices();

vector<glm::vec3> vertices;

vertices.push_back(location + glm::vec3((radius + width * 0.5) * cos(deg * DEG_TO_RAD), (radius + width * 0.5) * sin(deg * DEG_TO_RAD), 0));

vertices.push_back(location + glm::vec3((radius + width * 0.5) * cos((deg + deg_span) * DEG_TO_RAD), (radius + width * 0.5) * sin((deg + deg_span) * DEG_TO_RAD), 0));

vertices.push_back(location + glm::vec3((radius - width * 0.5) * cos((deg + deg_span) * DEG_TO_RAD), (radius - width * 0.5) * sin((deg + deg_span) * DEG_TO_RAD), 0));

vertices.push_back(location + glm::vec3((radius - width * 0.5) * cos(deg * DEG_TO_RAD), (radius - width * 0.5) * sin(deg * DEG_TO_RAD), 0));

mesh.addVertices(vertices);

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

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

mesh.addColor(color);

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

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