2020年7月 – ページ 8 – プログラミング de 落描き

2020年7月10日

Random walk with a side trip. Draw by openFrameworks

[ Video ]

[ About ]
寄り道するランダムウォーク。

Random walk with a side trip.

[ Source ]

#pragma once
#include "ofMain.h"

class Walker {

public:
	Walker(glm::vec2 location);
	void update();
	void draw();
private:
	glm::vec2 location;
	glm::vec2 direction;

	glm::vec2 rotate_location;
	float rotate_radius;
	float rotate_deg;

	vector<glm::vec2> log;
};

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

	vector<Walker> walker_list;
};

#pragma once

#include "ofMain.h"

class Walker {

public:

Walker(glm::vec2 location);

void update();

void draw();

private:

glm::vec2 location;

glm::vec2 direction;

glm::vec2 rotate_location;

float rotate_radius;

float rotate_deg;

vector<glm::vec2> log;

};

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

vector<Walker> walker_list;

};

#include "ofApp.h"

//--------------------------------------------------------------
Walker::Walker(glm::vec2 location) {

	this->location = location;
	this->direction = glm::normalize(glm::vec2(ofRandom(-1, 1), ofRandom(-1, 1))) * 3;

	this->rotate_location = glm::vec2();
	this->rotate_radius = 0;
	this->rotate_deg = 0;
}

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

	if (this->location.x > -230 && this->location.x < 230 && this->location.y > -230 && this->location.y < 230) {

		if (this->log.size() > 0 && ofRandom(1000) < 5) {

			auto prev_location = this->log.back();
			auto rad = std::atan2(this->location.y - prev_location.y, this->location.x - prev_location.x);
			this->rotate_radius = 40;

			if (ofRandom(100) < 50) {

				this->rotate_location = this->location + glm::vec2(this->rotate_radius * cos(rad + PI * 0.5), this->rotate_radius * sin(rad + PI * 0.5));
				this->rotate_deg = 270;
			}
			else {

				this->rotate_location = this->location + glm::vec2(this->rotate_radius * cos(rad - PI * 0.5), this->rotate_radius * sin(rad - PI * 0.5));
				this->rotate_deg = 90;
			}
		}
	}

	if (this->rotate_radius < 10) {

		this->location += this->direction;

		if (this->location.x < -300 || this->location.x > 300) {

			this->direction *= -1;
			this->location += this->direction;
		}

		if (this->location.y < -300 || this->location.y > 300) {

			this->direction *= -1;
			this->location += this->direction;
		}
	}
	else {

		this->location = this->rotate_location + glm::vec2(this->rotate_radius * cos(this->rotate_deg * DEG_TO_RAD), this->rotate_radius * sin(this->rotate_deg * DEG_TO_RAD));
		this->rotate_deg += 15;
		this->rotate_radius = this->rotate_radius <= 0 ? 0 : this->rotate_radius - 0.5;

		this->direction = glm::normalize(this->location - this->log.back()) * 3;

		if (ofRandom(100) < 1) {

			this->rotate_radius = 0;
		}
	}

	this->log.push_back(this->location);

	while (this->log.size() > 35){
		
		this->log.erase(this->log.begin());
	}
}

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

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

		ofSetColor(ofColor(ofMap(i, 0, this->log.size(), 239, 39)));
		ofDrawLine(this->log[i], this->log[i + 1]);
	}

	ofFill();
	ofDrawCircle(this->log.back(), 4);
}

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

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

	ofBackground(239);
	ofSetColor(39);
	ofSetLineWidth(2);

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

		this->walker_list.push_back(Walker(glm::vec2(ofRandom(-300, 300), ofRandom(-300, 300))));
	}
}

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

	for (auto& walker : this->walker_list) {

		walker.update();
	}
}

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

	ofTranslate(ofGetWidth() * 0.5, ofGetHeight() * 0.5);

	for (auto& walker : this->walker_list) {

		walker.draw();
	}
}

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

#include "ofApp.h"

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

Walker::Walker(glm::vec2 location) {

this->location = location;

this->direction = glm::normalize(glm::vec2(ofRandom(-1, 1), ofRandom(-1, 1))) * 3;

this->rotate_location = glm::vec2();

this->rotate_radius = 0;

this->rotate_deg = 0;

}

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

void Walker::update() {

if (this->location.x > -230 && this->location.x < 230 && this->location.y > -230 && this->location.y < 230) {

if (this->log.size() > 0 && ofRandom(1000) < 5) {

auto prev_location = this->log.back();

auto rad = std::atan2(this->location.y - prev_location.y, this->location.x - prev_location.x);

this->rotate_radius = 40;

if (ofRandom(100) < 50) {

this->rotate_location = this->location + glm::vec2(this->rotate_radius * cos(rad + PI * 0.5), this->rotate_radius * sin(rad + PI * 0.5));

this->rotate_deg = 270;

}

else {

this->rotate_location = this->location + glm::vec2(this->rotate_radius * cos(rad - PI * 0.5), this->rotate_radius * sin(rad - PI * 0.5));

this->rotate_deg = 90;

}

if (this->rotate_radius < 10) {

this->location += this->direction;

if (this->location.x < -300 || this->location.x > 300) {

this->direction *= -1;

this->location += this->direction;

}

if (this->location.y < -300 || this->location.y > 300) {

this->direction *= -1;

this->location += this->direction;

}

else {

this->location = this->rotate_location + glm::vec2(this->rotate_radius * cos(this->rotate_deg * DEG_TO_RAD), this->rotate_radius * sin(this->rotate_deg * DEG_TO_RAD));

this->rotate_deg += 15;

this->rotate_radius = this->rotate_radius <= 0 ? 0 : this->rotate_radius - 0.5;

this->direction = glm::normalize(this->location - this->log.back()) * 3;

if (ofRandom(100) < 1) {

this->rotate_radius = 0;

}

this->log.push_back(this->location);

while (this->log.size() > 35){

this->log.erase(this->log.begin());

}

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

void Walker::draw() {

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

ofSetColor(ofColor(ofMap(i, 0, this->log.size(), 239, 39)));

ofDrawLine(this->log[i], this->log[i + 1]);

}

ofFill();

ofDrawCircle(this->log.back(), 4);

}

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openframeworks");

ofBackground(239);

ofSetColor(39);

ofSetLineWidth(2);

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

this->walker_list.push_back(Walker(glm::vec2(ofRandom(-300, 300), ofRandom(-300, 300))));

}

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

void ofApp::update() {

for (auto& walker : this->walker_list) {

walker.update();

}

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

void ofApp::draw() {

ofTranslate(ofGetWidth() * 0.5, ofGetHeight() * 0.5);

for (auto& walker : this->walker_list) {

walker.draw();

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

2020年7月9日

Group of sphere. Draw by openFrameworks

[ Video ]

[ About ]
球体の塊。

Group of sphere.

[ 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 draw_sphere(glm::vec3 location, float radius);

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

void draw_sphere(glm::vec3 location, float radius);

ofEasyCam cam;

};

#include "ofApp.h"

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

	ofSetFrameRate(30);
	ofSetWindowTitle("openframeworks");

	ofBackground(239);
	ofEnableDepthTest();
}

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

	ofSeedRandom(39);
}

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

	this->cam.begin();
	ofRotateY(ofGetFrameNum() * 2);
	ofRotateX(ofGetFrameNum() * 1.54);

	this->draw_sphere(glm::vec3(), 300);

	this->cam.end();
}

//--------------------------------------------------------------
void ofApp::draw_sphere(glm::vec3 location, float radius) {

	vector<glm::vec3> location_list = {
		location + glm::vec3(-radius * 0.5, -radius * 0.5, radius * 0.5),
		location + glm::vec3(-radius * 0.5, radius * 0.5, radius * 0.5),
		location + glm::vec3(radius * 0.5, radius * 0.5, radius * 0.5),
		location + glm::vec3(radius * 0.5, -radius * 0.5, radius * 0.5),
		location + glm::vec3(-radius * 0.5, -radius * 0.5, -radius * 0.5),
		location + glm::vec3(-radius * 0.5, radius * 0.5, -radius * 0.5),
		location + glm::vec3(radius * 0.5, radius * 0.5, -radius * 0.5),
		location + glm::vec3(radius * 0.5, -radius * 0.5, -radius * 0.5)
	};

	if (radius < 50) {

		for (auto& l : location_list) {

			auto noise_value = ofNoise(glm::vec4(l * 0.05, ofGetFrameNum() * 0.003));

			if (noise_value < 0.85) {

				ofSetColor(ofMap(ofNoise(l * 0.05), 0, 1, 39, 239));
				ofDrawSphere(l, radius * 0.5);
			}
		}
	}
	else {

		for (auto& l : location_list) {

			auto noise_value = ofNoise(glm::vec4(l * 0.05, ofGetFrameNum() * 0.003));

			if (radius == 300 || noise_value < 0.5) {

				this->draw_sphere(l, radius * 0.5);
			}
			else if (noise_value < 0.70) {

				ofSetColor(ofMap(ofNoise(l * 0.05), 0, 1, 39, 239));
				ofDrawSphere(l, radius * 0.5);
			}
		}
	}
}

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

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(30);

ofSetWindowTitle("openframeworks");

ofBackground(239);

ofEnableDepthTest();

}

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

void ofApp::update() {

ofSeedRandom(39);

}

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

void ofApp::draw() {

this->cam.begin();

ofRotateY(ofGetFrameNum() * 2);

ofRotateX(ofGetFrameNum() * 1.54);

this->draw_sphere(glm::vec3(), 300);

this->cam.end();

}

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

void ofApp::draw_sphere(glm::vec3 location, float radius) {

vector<glm::vec3> location_list = {

location + glm::vec3(-radius * 0.5, -radius * 0.5, radius * 0.5),

location + glm::vec3(-radius * 0.5, radius * 0.5, radius * 0.5),

location + glm::vec3(radius * 0.5, radius * 0.5, radius * 0.5),

location + glm::vec3(radius * 0.5, -radius * 0.5, radius * 0.5),

location + glm::vec3(-radius * 0.5, -radius * 0.5, -radius * 0.5),

location + glm::vec3(-radius * 0.5, radius * 0.5, -radius * 0.5),

location + glm::vec3(radius * 0.5, radius * 0.5, -radius * 0.5),

location + glm::vec3(radius * 0.5, -radius * 0.5, -radius * 0.5)

};

if (radius < 50) {

for (auto& l : location_list) {

auto noise_value = ofNoise(glm::vec4(l * 0.05, ofGetFrameNum() * 0.003));

if (noise_value < 0.85) {

ofSetColor(ofMap(ofNoise(l * 0.05), 0, 1, 39, 239));

ofDrawSphere(l, radius * 0.5);

}

else {

for (auto& l : location_list) {

auto noise_value = ofNoise(glm::vec4(l * 0.05, ofGetFrameNum() * 0.003));

if (radius == 300 || noise_value < 0.5) {

this->draw_sphere(l, radius * 0.5);

}

else if (noise_value < 0.70) {

ofSetColor(ofMap(ofNoise(l * 0.05), 0, 1, 39, 239));

ofDrawSphere(l, radius * 0.5);

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

2020年7月8日2020年7月8日

Over 1,300 days. Draw by openFrameworks

[ Video ]

[ About ]
1300日達成。

Over 1,300 days.

[ 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 draw_digital(glm::vec2 location, int number_index, ofColor fill_color, ofColor frame_color);
	void draw_hexagon(glm::vec2 location, float deg, ofColor fill_color, ofColor frame_color);

	vector<pair<glm::vec2, bool>> number_list;

	float hexagon_height;
	float hexagon_width;
};

#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 draw_digital(glm::vec2 location, int number_index, ofColor fill_color, ofColor frame_color);

void draw_hexagon(glm::vec2 location, float deg, ofColor fill_color, ofColor frame_color);

vector<pair<glm::vec2, bool>> number_list;

float hexagon_height;

float hexagon_width;

};

#include "ofApp.h"

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

	ofSetFrameRate(30);
	ofSetWindowTitle("openframeworks");

	ofBackground(239);
	ofSetLineWidth(0.5);

	this->hexagon_height = 8;
	this->hexagon_width = 5;

	ofFbo fbo;
	fbo.allocate(ofGetWidth(), ofGetHeight());
	fbo.begin();
	ofTranslate(ofGetWidth() * 0.5, ofGetHeight() * 0.5);
	ofClear(0);
	ofSetColor(0);

	ofTrueTypeFont font;
	font.loadFont("fonts/Kazesawa-Bold.ttf", 300, true, true, true);
	/* https://github.com/kazesawa/kazesawa */

	font.drawString("13", font.stringWidth("13") * -0.5, font.stringHeight("13") * -0.05);
	font.drawString("00", font.stringWidth("00") * -0.5, font.stringHeight("00") * 1);

	fbo.end();

	ofPixels pixels;
	fbo.readToPixels(pixels);

	ofColor pix_color;
	for (float x = 24; x <= ofGetWidth() - 24; x += 12) {

		for (float y = 24; y <= ofGetHeight() - 24; y += 24) {

			pix_color = pixels.getColor(x, y);
			if (pix_color != ofColor(0, 0)) {

				this->number_list.push_back(make_pair<glm::vec2, bool>(glm::vec2(x, y), true));
			}
			else {

				this->number_list.push_back(make_pair<glm::vec2, bool>(glm::vec2(x, y), false));
			}
		}
	}
}

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

	ofSeedRandom(39);
}

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

	for (auto& number : this->number_list) {

		if (number.second) {

			int number_index = ofMap(ofNoise(glm::vec3(number.first * 0.05, ofGetFrameNum() * 0.05)), 0, 1, 0, 10);
			this->draw_digital(number.first, number_index, ofColor(39), ofColor(239));
		}
		else {

			this->draw_digital(number.first, 0, ofColor(150), ofColor(239));
		}
	}
}

//--------------------------------------------------------------
void ofApp::draw_digital(glm::vec2 location, int number_index, ofColor fill_color, ofColor frame_color) {

	vector<pair<glm::vec2, float>> part_list = {
		make_pair<glm::vec2, float>(location + glm::vec2(0, -this->hexagon_height), 90),
		make_pair<glm::vec2, float>(location + glm::vec2(this->hexagon_height * -0.5, this->hexagon_height * 0.5), 0),
		make_pair<glm::vec2, float>(location + glm::vec2(this->hexagon_height * 0.5, this->hexagon_height * 0.5), 0),
		make_pair<glm::vec2, float>(location + glm::vec2(0, 0), 90),
		make_pair<glm::vec2, float>(location + glm::vec2(this->hexagon_height * -0.5, this->hexagon_height * -0.5), 0),
		make_pair<glm::vec2, float>(location + glm::vec2(this->hexagon_height * 0.5, this->hexagon_height * -0.5), 0),
		make_pair<glm::vec2, float>(location + glm::vec2(0, this->hexagon_height), 90)
	};

	vector<vector<int>> index_list = {
		{ 0, 1, 2, 4, 5, 6 },
		{ 2, 5 },
		{ 0, 1, 3, 5, 6 },
		{ 0, 2, 3, 5, 6 },
		{ 2, 3, 4, 5 },
		{ 0, 2, 3, 4, 6 },
		{ 0, 1, 2, 3, 4, 6 },
		{ 0, 2, 5 },
		{ 0, 1, 2, 3, 4, 5, 6 },
		{ 0, 2, 3, 4, 5, 6 },
	};

	for (auto& index : index_list[number_index]) {

		this->draw_hexagon(part_list[index].first, part_list[index].second, fill_color, frame_color);
	}
}

//--------------------------------------------------------------
void ofApp::draw_hexagon(glm::vec2 location, float deg, ofColor fill_color, ofColor frame_color) {

	ofPushMatrix();
	ofTranslate(location);
	ofRotate(deg);

	vector<glm::vec2> vertices;
	vertices.push_back(glm::vec2(this->hexagon_width * -0.4, this->hexagon_height * -0.4));
	vertices.push_back(glm::vec2(this->hexagon_width * -0.4, this->hexagon_height * 0.4));
	vertices.push_back(glm::vec2(0, this->hexagon_height * 0.5));
	vertices.push_back(glm::vec2(this->hexagon_width * 0.4, this->hexagon_height * 0.4));
	vertices.push_back(glm::vec2(this->hexagon_width * 0.4, this->hexagon_height * -0.4));
	vertices.push_back(glm::vec2(0, this->hexagon_height * -0.5));

	ofFill();
	ofSetColor(fill_color);

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

	ofNoFill();
	ofSetColor(frame_color);

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

	ofPopMatrix();
}

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(30);

ofSetWindowTitle("openframeworks");

ofBackground(239);

ofSetLineWidth(0.5);

this->hexagon_height = 8;

this->hexagon_width = 5;

ofFbo fbo;

fbo.allocate(ofGetWidth(), ofGetHeight());

fbo.begin();

ofTranslate(ofGetWidth() * 0.5, ofGetHeight() * 0.5);

ofClear(0);

ofSetColor(0);

ofTrueTypeFont font;

font.loadFont("fonts/Kazesawa-Bold.ttf", 300, true, true, true);

/* https://github.com/kazesawa/kazesawa */

font.drawString("13", font.stringWidth("13") * -0.5, font.stringHeight("13") * -0.05);

font.drawString("00", font.stringWidth("00") * -0.5, font.stringHeight("00") * 1);

fbo.end();

ofPixels pixels;

fbo.readToPixels(pixels);

ofColor pix_color;

for (float x = 24; x <= ofGetWidth() - 24; x += 12) {

for (float y = 24; y <= ofGetHeight() - 24; y += 24) {

pix_color = pixels.getColor(x, y);

if (pix_color != ofColor(0, 0)) {

this->number_list.push_back(make_pair<glm::vec2, bool>(glm::vec2(x, y), true));

}

else {

this->number_list.push_back(make_pair<glm::vec2, bool>(glm::vec2(x, y), false));

}

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

void ofApp::update() {

ofSeedRandom(39);

}

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

void ofApp::draw() {

for (auto& number : this->number_list) {

if (number.second) {

int number_index = ofMap(ofNoise(glm::vec3(number.first * 0.05, ofGetFrameNum() * 0.05)), 0, 1, 0, 10);

this->draw_digital(number.first, number_index, ofColor(39), ofColor(239));

}

else {

this->draw_digital(number.first, 0, ofColor(150), ofColor(239));

}

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

void ofApp::draw_digital(glm::vec2 location, int number_index, ofColor fill_color, ofColor frame_color) {

vector<pair<glm::vec2, float>> part_list = {

make_pair<glm::vec2, float>(location + glm::vec2(0, -this->hexagon_height), 90),

make_pair<glm::vec2, float>(location + glm::vec2(this->hexagon_height * -0.5, this->hexagon_height * 0.5), 0),

make_pair<glm::vec2, float>(location + glm::vec2(this->hexagon_height * 0.5, this->hexagon_height * 0.5), 0),

make_pair<glm::vec2, float>(location + glm::vec2(0, 0), 90),

make_pair<glm::vec2, float>(location + glm::vec2(this->hexagon_height * -0.5, this->hexagon_height * -0.5), 0),

make_pair<glm::vec2, float>(location + glm::vec2(this->hexagon_height * 0.5, this->hexagon_height * -0.5), 0),

make_pair<glm::vec2, float>(location + glm::vec2(0, this->hexagon_height), 90)

};

vector<vector<int>> index_list = {

{ 0, 1, 2, 4, 5, 6 },

{ 2, 5 },

{ 0, 1, 3, 5, 6 },

{ 0, 2, 3, 5, 6 },

{ 2, 3, 4, 5 },

{ 0, 2, 3, 4, 6 },

{ 0, 1, 2, 3, 4, 6 },

{ 0, 2, 5 },

{ 0, 1, 2, 3, 4, 5, 6 },

{ 0, 2, 3, 4, 5, 6 },

};

for (auto& index : index_list[number_index]) {

this->draw_hexagon(part_list[index].first, part_list[index].second, fill_color, frame_color);

}

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

void ofApp::draw_hexagon(glm::vec2 location, float deg, ofColor fill_color, ofColor frame_color) {

ofPushMatrix();

ofTranslate(location);

ofRotate(deg);

vector<glm::vec2> vertices;

vertices.push_back(glm::vec2(this->hexagon_width * -0.4, this->hexagon_height * -0.4));

vertices.push_back(glm::vec2(this->hexagon_width * -0.4, this->hexagon_height * 0.4));

vertices.push_back(glm::vec2(0, this->hexagon_height * 0.5));

vertices.push_back(glm::vec2(this->hexagon_width * 0.4, this->hexagon_height * 0.4));

vertices.push_back(glm::vec2(this->hexagon_width * 0.4, this->hexagon_height * -0.4));

vertices.push_back(glm::vec2(0, this->hexagon_height * -0.5));

ofFill();

ofSetColor(fill_color);

ofBeginShape();

ofVertices(vertices);

ofEndShape(true);

ofNoFill();

ofSetColor(frame_color);

ofBeginShape();

ofVertices(vertices);

ofEndShape(true);

ofPopMatrix();

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

2020年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