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

2026年2月13日2026年2月13日

Jointable.

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

	float seed_value;
};

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

float seed_value;

};

#include "ofApp.h"

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

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

	ofBackground(39);
	ofSetColor(239);
	ofNoFill();
	ofSetCircleResolution(60);

	this->seed_value = ofRandom(1000);
}

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

	ofSeedRandom(this->seed_value);
}

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

	auto center = glm::vec2(ofGetWindowSize() * 0.5);
	auto radius = 340;
	auto flag = ofRandom(100) < 50 ? true : false;

	vector<glm::vec2> vertices;
	for (int draw_radius = radius; draw_radius > 5;) {

		vertices.push_back(center);

		flag = !flag;

		auto tmp_radius = draw_radius;
		draw_radius *= 0.8;

		auto deg = ofMap(ofNoise(center.x * 0.0005, center.y * 0.0005, ofGetFrameNum() * 0.005), 0, 1, -720, 720);
		auto center_radius = tmp_radius - draw_radius;
		center = center + glm::vec2(center_radius * cos(deg * DEG_TO_RAD), center_radius * sin(deg * DEG_TO_RAD));
	}

	ofBeginShape();
	ofVertices(vertices);
	ofEndShape();

	for (auto& vertex : vertices) {

		ofDrawCircle(vertex, 5);
	}

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(25);

ofSetWindowTitle("openFrameworks");

ofBackground(39);

ofSetColor(239);

ofNoFill();

ofSetCircleResolution(60);

this->seed_value = ofRandom(1000);

}

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

void ofApp::update() {

ofSeedRandom(this->seed_value);

}

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

void ofApp::draw() {

auto center = glm::vec2(ofGetWindowSize() * 0.5);

auto radius = 340;

auto flag = ofRandom(100) < 50 ? true : false;

vector<glm::vec2> vertices;

for (int draw_radius = radius; draw_radius > 5;) {

vertices.push_back(center);

flag = !flag;

auto tmp_radius = draw_radius;

draw_radius *= 0.8;

auto deg = ofMap(ofNoise(center.x * 0.0005, center.y * 0.0005, ofGetFrameNum() * 0.005), 0, 1, -720, 720);

auto center_radius = tmp_radius - draw_radius;

center = center + glm::vec2(center_radius * cos(deg * DEG_TO_RAD), center_radius * sin(deg * DEG_TO_RAD));

}

ofBeginShape();

ofVertices(vertices);

ofEndShape();

for (auto& vertex : vertices) {

ofDrawCircle(vertex, 5);

}

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

int start = 1;

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

2026年2月12日

Multiple joints.

[ Video ]

[ About ]
複数の関節。

[ Suource ]

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

	float seed_value;
};

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

float seed_value;

};

#include "ofApp.h"

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

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

	ofBackground(239);
	ofSetColor(39);
	ofNoFill();
	ofSetCircleResolution(60);

	this->seed_value = ofRandom(1000);
}

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

	ofSeedRandom(this->seed_value);
}

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

	int span = 120;
	for (int x = span * 1; x <= ofGetWindowWidth() - span * 1; x += span) {

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

			auto center = glm::vec2(x, y);
			auto radius = span * 0.75;
			auto flag = ofRandom(100) < 50 ? true : false;

			vector<glm::vec2> vertices;
			for (int draw_radius = radius; draw_radius > 5;) {

				vertices.push_back(center);

				flag = !flag;

				auto tmp_radius = draw_radius;
				draw_radius *= ofRandom(0.4, 0.8);

				auto deg = ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.005), 0, 1, -720, 720);
				auto center_radius = tmp_radius - draw_radius;
				center = center + glm::vec2(center_radius * cos(deg * DEG_TO_RAD), center_radius * sin(deg * DEG_TO_RAD));


			}

			ofNoFill();

			ofBeginShape();
			ofVertices(vertices);
			ofEndShape();

			ofFill();
			for (auto& vertex : vertices) {

				ofDrawCircle(vertex, 3);
			}
		}
	}

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(25);

ofSetWindowTitle("openFrameworks");

ofBackground(239);

ofSetColor(39);

ofNoFill();

ofSetCircleResolution(60);

this->seed_value = ofRandom(1000);

}

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

void ofApp::update() {

ofSeedRandom(this->seed_value);

}

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

void ofApp::draw() {

int span = 120;

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

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

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

auto radius = span * 0.75;

auto flag = ofRandom(100) < 50 ? true : false;

vector<glm::vec2> vertices;

for (int draw_radius = radius; draw_radius > 5;) {

vertices.push_back(center);

flag = !flag;

auto tmp_radius = draw_radius;

draw_radius *= ofRandom(0.4, 0.8);

auto deg = ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.005), 0, 1, -720, 720);

auto center_radius = tmp_radius - draw_radius;

center = center + glm::vec2(center_radius * cos(deg * DEG_TO_RAD), center_radius * sin(deg * DEG_TO_RAD));

}

ofNoFill();

ofBeginShape();

ofVertices(vertices);

ofEndShape();

ofFill();

for (auto& vertex : vertices) {

ofDrawCircle(vertex, 3);

}

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

2026年2月11日2026年2月11日

Cliff face.

[ 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 mouseEntered(int x, int y) {};
	void mouseExited(int x, int y) {};
	void windowResized(int w, int h) {};
	void dragEvent(ofDragInfo dragInfo) {};
	void gotMessage(ofMessage msg) {};

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

	vector<glm::vec3> location_list;

	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 mouseEntered(int x, int y) {};

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

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

void dragEvent(ofDragInfo dragInfo) {};

void gotMessage(ofMessage msg) {};

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

vector<glm::vec3> location_list;

ofEasyCam cam;

ofMesh face, frame;

};

#include "ofApp.h"

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

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

	ofBackground(39);
	ofEnableDepthTest();

	auto radius = 30;
	auto x_span = radius * sqrt(3);
	auto flg = true;
	for (float y = -450; y <= 450; y += radius * 1.5) {

		for (float x = -450; x <= 450; x += x_span) {

			glm::vec3 location;
			if (flg) {

				location = glm::vec3(x, y, 0);
			}
			else {

				location = glm::vec3(x + (x_span / 2), y, 0);
			}

			this->location_list.push_back(location);
		}
		flg = !flg;
	}

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

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

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

	for (int i = 0; i < this->location_list.size(); i++) {

		auto height = ofMap(ofNoise(this->location_list[i].x * 0.005, this->location_list[i].y * 0.005, ofGetFrameNum() * 0.005), 0, 1, 5, 700);

		if (height < 350) {

			height = 350;
		}
		this->setHexagonToMesh(this->face, this->frame, this->location_list[i], 30, height);
	}

}

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

	this->cam.begin();

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

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

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

	ofColor face_color = ofColor(0);
	ofColor frame_color = ofColor(255);

	auto noise_param = ofNoise(location.x * 0.005, location.y * 0.005, location.z * 0.001, ofGetFrameNum() * 0.005);
	auto face_radius = radius - 0.5;

	for (int deg = 90; deg < 450; deg += 60) {

		auto face_index = face_target.getNumVertices();
		auto frame_index = frame_target.getNumVertices();

		vector<glm::vec3> vertices;
		vertices.push_back(glm::vec3(0, 0, 0));
		vertices.push_back(glm::vec3(face_radius * cos(deg * DEG_TO_RAD), face_radius * sin(deg * DEG_TO_RAD), 0));
		vertices.push_back(glm::vec3(face_radius * cos((deg + 60) * DEG_TO_RAD), face_radius * sin((deg + 60) * DEG_TO_RAD), 0));
		vertices.push_back(glm::vec3(0, 0, height));
		vertices.push_back(glm::vec3(face_radius * cos((deg + 60) * DEG_TO_RAD), face_radius * sin((deg + 60) * DEG_TO_RAD), height));
		vertices.push_back(glm::vec3(face_radius * cos(deg * DEG_TO_RAD), face_radius * sin(deg * DEG_TO_RAD), height));

		for (auto& vertex : vertices) {

			vertex += location;
		}

		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 + 3); face_target.addIndex(face_index + 4); face_target.addIndex(face_index + 5);
		face_target.addIndex(face_index + 1); face_target.addIndex(face_index + 2); face_target.addIndex(face_index + 4);
		face_target.addIndex(face_index + 1); face_target.addIndex(face_index + 4); face_target.addIndex(face_index + 5);

		frame_target.addVertices(vertices);

		frame_target.addIndex(frame_index + 1); frame_target.addIndex(frame_index + 2);
		frame_target.addIndex(frame_index + 4); frame_target.addIndex(frame_index + 5);
		frame_target.addIndex(frame_index + 1); frame_target.addIndex(frame_index + 5);
		frame_target.addIndex(frame_index + 2); frame_target.addIndex(frame_index + 4);

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

			face_target.addColor(face_color);
			frame_target.addColor(frame_color);
		}
	}
}

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

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

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(25);

ofSetWindowTitle("openFrameworks");

ofBackground(39);

ofEnableDepthTest();

auto radius = 30;

auto x_span = radius * sqrt(3);

auto flg = true;

for (float y = -450; y <= 450; y += radius * 1.5) {

for (float x = -450; x <= 450; x += x_span) {

glm::vec3 location;

if (flg) {

location = glm::vec3(x, y, 0);

}

else {

location = glm::vec3(x + (x_span / 2), y, 0);

}

this->location_list.push_back(location);

}

flg = !flg;

}

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

}

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

void ofApp::update() {

this->face.clear();

this->frame.clear();

for (int i = 0; i < this->location_list.size(); i++) {

auto height = ofMap(ofNoise(this->location_list[i].x * 0.005, this->location_list[i].y * 0.005, ofGetFrameNum() * 0.005), 0, 1, 5, 700);

if (height < 350) {

height = 350;

}

this->setHexagonToMesh(this->face, this->frame, this->location_list[i], 30, height);

}

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

void ofApp::draw() {

this->cam.begin();

this->face.draw();

this->frame.draw();

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

}

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

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

ofColor face_color = ofColor(0);

ofColor frame_color = ofColor(255);

auto noise_param = ofNoise(location.x * 0.005, location.y * 0.005, location.z * 0.001, ofGetFrameNum() * 0.005);

auto face_radius = radius - 0.5;

for (int deg = 90; deg < 450; deg += 60) {

auto face_index = face_target.getNumVertices();

auto frame_index = frame_target.getNumVertices();

vector<glm::vec3> vertices;

vertices.push_back(glm::vec3(0, 0, 0));

vertices.push_back(glm::vec3(face_radius * cos(deg * DEG_TO_RAD), face_radius * sin(deg * DEG_TO_RAD), 0));

vertices.push_back(glm::vec3(face_radius * cos((deg + 60) * DEG_TO_RAD), face_radius * sin((deg + 60) * DEG_TO_RAD), 0));

vertices.push_back(glm::vec3(0, 0, height));

vertices.push_back(glm::vec3(face_radius * cos((deg + 60) * DEG_TO_RAD), face_radius * sin((deg + 60) * DEG_TO_RAD), height));

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

for (auto& vertex : vertices) {

vertex += location;

}

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 + 3); face_target.addIndex(face_index + 4); face_target.addIndex(face_index + 5);

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

face_target.addIndex(face_index + 1); face_target.addIndex(face_index + 4); face_target.addIndex(face_index + 5);

frame_target.addVertices(vertices);

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

frame_target.addIndex(frame_index + 4); frame_target.addIndex(frame_index + 5);

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

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

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

face_target.addColor(face_color);

frame_target.addColor(frame_color);

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

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