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

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月24日

one-quarter.

[ Video ]

[ About ]
1/4.

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

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

ofMesh mesh;

float noise_param;

};

#include "ofApp.h"

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

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

	ofBackground(239);
	ofSetColor(39);

	this->noise_param = ofRandom(1000);
}

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

	ofSeedRandom(39);

	this->mesh.clear();

	int width = 20;
	int deg_span = 90;
	for (int x = 180; x < ofGetWidth(); x += 360) {

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

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

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

	if (ofGetFrameNum() % 50 < 40) {

		this->noise_param += ofMap(ofGetFrameNum() % 50, 0, 40, 0.15, 0);
	}
}

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

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

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

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(25);

ofSetWindowTitle("openFrameworks");

ofBackground(239);

ofSetColor(39);

this->noise_param = ofRandom(1000);

}

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

void ofApp::update() {

ofSeedRandom(39);

this->mesh.clear();

int width = 20;

int deg_span = 90;

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

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

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

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

}

if (ofGetFrameNum() % 50 < 40) {

this->noise_param += ofMap(ofGetFrameNum() % 50, 0, 40, 0.15, 0);

}

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

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

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

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

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