ofMesh – ページ 105 – プログラミング de 落描き

2021年9月10日2021年9月10日

Cylinders. Draw by openFrameworks

[ Video ]

[ About ]
円柱状を移動する点を近づいたら線で結ぶ。色情報はXとY座標から計算する。

When you get close to the point where you want to move the cylinder shape, connect it with a line. The color information is calculated from the X and Y coordinates.

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

	ofMesh line;

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

ofMesh line;

ofEasyCam cam;

};

#include "ofApp.h"

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

	ofSetFrameRate(60);
	ofSetWindowTitle("openFrameworks");

	ofBackground(0);
	ofSetLineWidth(0.8);
	ofEnableDepthTest();

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

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

	ofSeedRandom(39);

	this->line.clear();

	auto radius = 300;
	auto deg_span = 5;

	for (int x = -350; x <= 350; x += 700) {

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

			this->line.addVertex(glm::vec3(x + radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD), -radius));
			this->line.addColor(ofColor());
			this->line.addVertex(glm::vec3(x + radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD), radius));
			this->line.addColor(ofColor());
		}

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

			int z = (int)(ofRandom(radius * 2) + ofGetFrameNum() * ofRandom(1, 3)) % radius * 2 - radius;
			if (x == 350) { z = -z; }
			int deg = (int)ofRandom(0, 360) / deg_span * deg_span;

			this->line.addVertex(glm::vec3(x + radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD), z));
			this->line.addColor(ofColor());
		}
	}

	auto color = ofColor();
	for (int i = 0; i < this->line.getNumVertices(); i++) {

		auto location = this->line.getVertex(i);
		auto hue = ofMap(location.x, -600, 600, 0, 255);
		auto alpha = ofMap(location.y, -radius, radius, 255, 32);
		color.setHsb(hue, 255, 255, alpha);
		this->line.setColor(i, color);

		for (int k = i + 1; k < this->line.getNumVertices(); k++) {

			auto other = this->line.getVertex(k);
			float distance = glm::distance(location, other);
			if (distance < 50) {

				this->line.addIndex(i);
				this->line.addIndex(k);
			}
		}
	}
}

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

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

	this->line.drawWireframe();

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

		ofSetColor(this->line.getColor(i));
		ofDrawSphere(this->line.getVertex(i), 4);
	}

	this->cam.end();
}

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

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openFrameworks");

ofBackground(0);

ofSetLineWidth(0.8);

ofEnableDepthTest();

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

}

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

void ofApp::update() {

ofSeedRandom(39);

this->line.clear();

auto radius = 300;

auto deg_span = 5;

for (int x = -350; x <= 350; x += 700) {

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

this->line.addVertex(glm::vec3(x + radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD), -radius));

this->line.addColor(ofColor());

this->line.addVertex(glm::vec3(x + radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD), radius));

this->line.addColor(ofColor());

}

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

int z = (int)(ofRandom(radius * 2) + ofGetFrameNum() * ofRandom(1, 3)) % radius * 2 - radius;

if (x == 350) { z = -z; }

int deg = (int)ofRandom(0, 360) / deg_span * deg_span;

this->line.addVertex(glm::vec3(x + radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD), z));

this->line.addColor(ofColor());

}

auto color = ofColor();

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

auto location = this->line.getVertex(i);

auto hue = ofMap(location.x, -600, 600, 0, 255);

auto alpha = ofMap(location.y, -radius, radius, 255, 32);

color.setHsb(hue, 255, 255, alpha);

this->line.setColor(i, color);

for (int k = i + 1; k < this->line.getNumVertices(); k++) {

auto other = this->line.getVertex(k);

float distance = glm::distance(location, other);

if (distance < 50) {

this->line.addIndex(i);

this->line.addIndex(k);

}

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

void ofApp::draw() {

this->cam.begin();

ofRotateX(270);

this->line.drawWireframe();

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

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

ofDrawSphere(this->line.getVertex(i), 4);

}

this->cam.end();

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

2021年9月9日

Rotating gradation. Draw by openFrameworks

[ Video ]

[ About ]
回転する輪の色をグラデーションにして差分を見る。

Gradient the color of the spinning wheel to see the difference.

[ 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& face_target, ofMesh& frame_target, glm::vec3 location, glm::vec3 noise_location, float radius, float height, ofColor face_color);

	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 windowResized(int w, int h) {};

void dragEvent(ofDragInfo dragInfo) {};

void gotMessage(ofMessage msg) {};

void setRingToMesh(ofMesh& face_target, ofMesh& frame_target, glm::vec3 location, glm::vec3 noise_location, float radius, float height, ofColor face_color);

ofEasyCam cam;

ofMesh face, frame;

};

#include "ofApp.h"

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

	ofSetFrameRate(60);
	ofSetWindowTitle("openFrameworks");

	ofBackground(239);
	ofSetLineWidth(1.5);
	ofEnableDepthTest();

	this->frame.setMode(ofPrimitiveMode::OF_PRIMITIVE_LINES);
}
//--------------------------------------------------------------
void ofApp::update() {

	ofSeedRandom(39);

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

	vector<glm::vec3> base_location = { glm::vec3()	};
	auto noise_location = glm::vec3(ofRandom(1000), ofRandom(1000), ofRandom(1000));
	ofColor face_color;
	for (auto& location : base_location) {

		for (int radius = 50; radius <= 300; radius += 10) {

			face_color.setHsb(ofMap(radius, 50, 300, 0, 255), 150, 255);
			this->setRingToMesh(this->face, this->frame, location, noise_location, radius, 125, face_color);
		}
	}
}

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

	this->cam.begin();
	ofRotateY(ofGetFrameNum());

	ofSetColor(39);
	this->face.draw();

	ofSetColor(239);
	this->frame.drawWireframe();

	this->cam.end();
}

//--------------------------------------------------------------
void ofApp::setRingToMesh(ofMesh& face_target, ofMesh& frame_target, glm::vec3 location, glm::vec3 noise_location, float radius, float height, ofColor face_color) {

	int index = face_target.getNumVertices();

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

		vector<glm::vec3> vertices;
		vertices.push_back(glm::vec3(radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD), height * -0.5));
		vertices.push_back(glm::vec3(radius * cos((deg + 1) * DEG_TO_RAD), radius * sin((deg + 1) * DEG_TO_RAD), height * -0.5));
		vertices.push_back(glm::vec3(radius * cos((deg + 1) * DEG_TO_RAD), radius * sin((deg + 1) * DEG_TO_RAD), height * 0.5));
		vertices.push_back(glm::vec3(radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD), height * 0.5));

		for (auto& vertex : vertices) {

			auto noise_value_x = ofNoise(
				noise_location.x, radius * 0.0008 + ofGetFrameNum() * 0.0035);
			auto noise_value_y = ofNoise(
				noise_location.y, radius * 0.0008 + ofGetFrameNum() * 0.0035);
			auto noise_value_z = ofNoise(
				noise_location.z, radius * 0.0008 + ofGetFrameNum() * 0.0035);

			auto rotation_x = glm::rotate(glm::mat4(), ofMap(noise_value_x, 0, 1, -PI * 2.5, PI * 2.5), glm::vec3(1, 0, 0));
			auto rotation_y = glm::rotate(glm::mat4(), ofMap(noise_value_y, 0, 1, -PI * 2.5, PI * 2.5), glm::vec3(0, 1, 0));
			auto rotation_z = glm::rotate(glm::mat4(), ofMap(noise_value_z, 0, 1, -PI * 2.5, PI * 2.5), glm::vec3(0, 0, 1));

			vertex = glm::vec4(vertex, 0) * rotation_y * rotation_x + glm::vec4(location, 0);
		}

		auto face_index = face_target.getNumVertices();
		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 + 0); face_target.addIndex(face_index + 2); face_target.addIndex(face_index + 3);

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

			face_target.addColor(face_color);
		}

		auto frame_index = frame_target.getNumVertices();
		frame_target.addVertices(vertices);

		frame_target.addIndex(frame_index + 0); frame_target.addIndex(frame_index + 1);
		frame_target.addIndex(frame_index + 2); frame_target.addIndex(frame_index + 3);
	}
}

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

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

100

101

102

103

104

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openFrameworks");

ofBackground(239);

ofSetLineWidth(1.5);

ofEnableDepthTest();

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

}

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

void ofApp::update() {

ofSeedRandom(39);

this->face.clear();

this->frame.clear();

vector<glm::vec3> base_location = { glm::vec3() };

auto noise_location = glm::vec3(ofRandom(1000), ofRandom(1000), ofRandom(1000));

ofColor face_color;

for (auto& location : base_location) {

for (int radius = 50; radius <= 300; radius += 10) {

face_color.setHsb(ofMap(radius, 50, 300, 0, 255), 150, 255);

this->setRingToMesh(this->face, this->frame, location, noise_location, radius, 125, face_color);

}

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

void ofApp::draw() {

this->cam.begin();

ofRotateY(ofGetFrameNum());

ofSetColor(39);

this->face.draw();

ofSetColor(239);

this->frame.drawWireframe();

this->cam.end();

}

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

void ofApp::setRingToMesh(ofMesh& face_target, ofMesh& frame_target, glm::vec3 location, glm::vec3 noise_location, float radius, float height, ofColor face_color) {

int index = face_target.getNumVertices();

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

vector<glm::vec3> vertices;

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

vertices.push_back(glm::vec3(radius * cos((deg + 1) * DEG_TO_RAD), radius * sin((deg + 1) * DEG_TO_RAD), height * -0.5));

vertices.push_back(glm::vec3(radius * cos((deg + 1) * DEG_TO_RAD), radius * sin((deg + 1) * DEG_TO_RAD), height * 0.5));

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

for (auto& vertex : vertices) {

auto noise_value_x = ofNoise(

noise_location.x, radius * 0.0008 + ofGetFrameNum() * 0.0035);

auto noise_value_y = ofNoise(

noise_location.y, radius * 0.0008 + ofGetFrameNum() * 0.0035);

auto noise_value_z = ofNoise(

noise_location.z, radius * 0.0008 + ofGetFrameNum() * 0.0035);

auto rotation_x = glm::rotate(glm::mat4(), ofMap(noise_value_x, 0, 1, -PI * 2.5, PI * 2.5), glm::vec3(1, 0, 0));

auto rotation_y = glm::rotate(glm::mat4(), ofMap(noise_value_y, 0, 1, -PI * 2.5, PI * 2.5), glm::vec3(0, 1, 0));

auto rotation_z = glm::rotate(glm::mat4(), ofMap(noise_value_z, 0, 1, -PI * 2.5, PI * 2.5), glm::vec3(0, 0, 1));

vertex = glm::vec4(vertex, 0) * rotation_y * rotation_x + glm::vec4(location, 0);

}

auto face_index = face_target.getNumVertices();

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

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

face_target.addColor(face_color);

}

auto frame_index = frame_target.getNumVertices();

frame_target.addVertices(vertices);

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

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

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

2021年9月8日2021年9月8日

Overwrite. Draw by openFrameworks

[ Video ]

[ About ]
ofSetBackgroundAuto(false)で塗りつぶしを止めて、書き続ける。

Stop filling with ofSetBackgroundAuto(false) and continue writing.

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

	glm::vec2 make_point(int len, int param);

	ofTrueTypeFont font;
	int font_size;
	vector<string> words;

	vector<ofMesh> mesh_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 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) {};

glm::vec2 make_point(int len, int param);

ofTrueTypeFont font;

int font_size;

vector<string> words;

vector<ofMesh> mesh_list;

};

#include "ofApp.h"

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

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

	ofBackground(239);
	ofSetColor(239);
	ofNoFill();
	ofSetRectMode(ofRectMode::OF_RECTMODE_CENTER);
	ofSetBackgroundAuto(false);

	this->font_size = 55;
	ofTrueTypeFontSettings font_settings("fonts/msgothic.ttc", this->font_size);
	font_settings.antialiased = true;
	font_settings.addRanges(ofAlphabet::Japanese);
	this->font.load(font_settings);

	this->words = {

		u8"はる", u8"なつ", u8"あき", u8"ふゆ", u8"そら",
		u8"つち", u8"あめ", u8"くも", u8"かさ", u8"ひと",
	};
}

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

	ofColor color;
	vector<ofColor> color_list;
	vector<int> hex_list = { 0xef476f, 0xffd166, 0x06d6a0, 0x118ab2, 0x073b4c };
	for (auto hex : hex_list) {

		color.setHex(hex);
		color_list.push_back(color);
	}

	if (ofGetFrameNum() % 2 == 0) {

		this->mesh_list.clear();

		ofColor color_1, color_2;
		int len = 600;
		int x = ofGetWidth() * 0.5;
		int y = ofGetHeight() * 0.5;

		ofMesh mesh;
		color_1 = color_list[int(ofRandom(color_list.size()))];
		color_2 = color_list[int(ofRandom(color_list.size()))];

		int param = ofRandom(100);

		if (ofRandom(1) < 0.5) {

			mesh.addVertex(glm::vec3(x, y, 0) + glm::vec3(this->make_point(len, param), 0));
			mesh.addVertex(glm::vec3(x, y, 0) + glm::vec3(this->make_point(len, param + 2), 0));
			mesh.addColor(color_1);
			mesh.addColor(color_1);

			mesh.addVertex(glm::vec3(x, y, 0) + glm::vec3(this->make_point(len, 100 - param - 2), 0));
			mesh.addVertex(glm::vec3(x, y, 0) + glm::vec3(this->make_point(len, 100 - param), 0));
			mesh.addColor(color_2);
			mesh.addColor(color_2);
		}
		else {

			mesh.addVertex(glm::vec3(x, y, 0) + glm::vec3(this->make_point(len, param), 0));
			mesh.addVertex(glm::vec3(x, y, 0) + glm::vec3(this->make_point(len, param + 2), 0));
			mesh.addColor(color_1);
			mesh.addColor(color_1);

			mesh.addVertex(glm::vec3(x, y, 0) + glm::vec3(this->make_point(len, 75 - param + 75 - 2), 0));
			mesh.addVertex(glm::vec3(x, y, 0) + glm::vec3(this->make_point(len, 75 - param + 75), 0));
			mesh.addColor(color_2);
			mesh.addColor(color_2);
		}

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

		this->mesh_list.push_back(mesh);
	}
}

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

	if (ofGetFrameNum() % 12 == 0) {

		int x = ofRandom(120, 600);
		int y = ofRandom(150, 570);
		int word_index = (int)ofRandom(this->words.size());

		ofFill();
		ofSetColor(239);

		ofPushMatrix();
		ofTranslate(x, y);
		ofRotateZ(ofRandom(360));

		this->font.drawString(this->words[word_index], -60, -60);

		ofPopMatrix();

	}

	ofNoFill();
	for (auto& mesh : this->mesh_list) {

		mesh.draw();

		ofSetColor(255);
		ofBeginShape();
		for (auto& vertex : mesh.getVertices()) {

			ofVertex(vertex);
		}
		ofEndShape(true);
	}

	ofSetColor(39);
	ofDrawRectangle(360, 360, 600, 600);
}

//--------------------------------------------------------------
glm::vec2 ofApp::make_point(int len, int param) {

	param = param % 100;
	if (param < 25) {

		return glm::vec2(ofMap(param, 0, 25, -len * 0.5, len * 0.5), -len * 0.5);
	}
	else if (param < 50) {

		return glm::vec2(len * 0.5, ofMap(param, 25, 50, -len * 0.5, len * 0.5));
	}
	else if (param < 75) {

		return glm::vec2(ofMap(param, 50, 75, len * 0.5, -len * 0.5), len * 0.5);
	}
	else {

		return glm::vec2(-len * 0.5, ofMap(param, 75, 100, len * 0.5, -len * 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

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openframeworks");

ofBackground(239);

ofSetColor(239);

ofNoFill();

ofSetRectMode(ofRectMode::OF_RECTMODE_CENTER);

ofSetBackgroundAuto(false);

this->font_size = 55;

ofTrueTypeFontSettings font_settings("fonts/msgothic.ttc", this->font_size);

font_settings.antialiased = true;

font_settings.addRanges(ofAlphabet::Japanese);

this->font.load(font_settings);

this->words = {

u8"はる", u8"なつ", u8"あき", u8"ふゆ", u8"そら",

u8"つち", u8"あめ", u8"くも", u8"かさ", u8"ひと",

};

}

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

void ofApp::update() {

ofColor color;

vector<ofColor> color_list;

vector<int> hex_list = { 0xef476f, 0xffd166, 0x06d6a0, 0x118ab2, 0x073b4c };

for (auto hex : hex_list) {

color.setHex(hex);

color_list.push_back(color);

}

if (ofGetFrameNum() % 2 == 0) {

this->mesh_list.clear();

ofColor color_1, color_2;

int len = 600;

int x = ofGetWidth() * 0.5;

int y = ofGetHeight() * 0.5;

ofMesh mesh;

color_1 = color_list[int(ofRandom(color_list.size()))];

color_2 = color_list[int(ofRandom(color_list.size()))];

int param = ofRandom(100);

if (ofRandom(1) < 0.5) {

mesh.addVertex(glm::vec3(x, y, 0) + glm::vec3(this->make_point(len, param), 0));

mesh.addVertex(glm::vec3(x, y, 0) + glm::vec3(this->make_point(len, param + 2), 0));

mesh.addColor(color_1);

mesh.addVertex(glm::vec3(x, y, 0) + glm::vec3(this->make_point(len, 100 - param - 2), 0));

mesh.addVertex(glm::vec3(x, y, 0) + glm::vec3(this->make_point(len, 100 - param), 0));

mesh.addColor(color_2);

}

else {

mesh.addVertex(glm::vec3(x, y, 0) + glm::vec3(this->make_point(len, param), 0));

mesh.addVertex(glm::vec3(x, y, 0) + glm::vec3(this->make_point(len, param + 2), 0));

mesh.addColor(color_1);

mesh.addVertex(glm::vec3(x, y, 0) + glm::vec3(this->make_point(len, 75 - param + 75 - 2), 0));

mesh.addVertex(glm::vec3(x, y, 0) + glm::vec3(this->make_point(len, 75 - param + 75), 0));

mesh.addColor(color_2);

}

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

mesh.addIndex(1); mesh.addIndex(2); mesh.addIndex(3);

this->mesh_list.push_back(mesh);

}

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

void ofApp::draw() {

if (ofGetFrameNum() % 12 == 0) {

int x = ofRandom(120, 600);

int y = ofRandom(150, 570);

int word_index = (int)ofRandom(this->words.size());

ofFill();

ofSetColor(239);

ofPushMatrix();

ofTranslate(x, y);

ofRotateZ(ofRandom(360));

this->font.drawString(this->words[word_index], -60, -60);

ofPopMatrix();

}

ofNoFill();

for (auto& mesh : this->mesh_list) {

mesh.draw();

ofSetColor(255);

ofBeginShape();

for (auto& vertex : mesh.getVertices()) {

ofVertex(vertex);

}

ofEndShape(true);

}

ofSetColor(39);

ofDrawRectangle(360, 360, 600, 600);

}

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

glm::vec2 ofApp::make_point(int len, int param) {

param = param % 100;

if (param < 25) {

return glm::vec2(ofMap(param, 0, 25, -len * 0.5, len * 0.5), -len * 0.5);

}

else if (param < 50) {

return glm::vec2(len * 0.5, ofMap(param, 25, 50, -len * 0.5, len * 0.5));

}

else if (param < 75) {

return glm::vec2(ofMap(param, 50, 75, len * 0.5, -len * 0.5), len * 0.5);

}

else {

return glm::vec2(-len * 0.5, ofMap(param, 75, 100, len * 0.5, -len * 0.5));

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

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