hexagon – ページ 11 – プログラミング de 落描き

2019年5月2日

Draw noise line by hexagon. openFrameworks

[ Video ]

[ About ]
パーリンノイズ由来の線を六角形でプロット

Draw noise line by hexagon.

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

	float radius;
	vector<glm::vec2> hex_locations;
	vector<ofColor> hex_colors;
};

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

float radius;

vector<glm::vec2> hex_locations;

vector<ofColor> hex_colors;

};

#include "ofApp.h"	

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

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

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

	this->radius = 10;
	auto flag = true;
	float sqrt_3 = sqrt(3);
	for (float y = -ofGetHeight() * 0.5 - radius; y < ofGetHeight() * 0.5 + radius; y += radius * 1.5) {

		for (float x = -ofGetWidth() * 0.5 - radius; x < ofGetWidth() * 0.5 + radius; x += radius * sqrt_3) {

			auto location = flag ? glm::vec2(x, y) : glm::vec2(x + this->radius * sqrt_3 * 0.5, y);
			this->hex_locations.push_back(location);
			ofColor hex_color;
			hex_color.setHsb(ofRandom(255), 230, 230);
			this->hex_colors.push_back(hex_color);
		}
		flag = !flag;
	}
}

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

	ofSeedRandom(39);
}

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

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

	for (int k = 0; k < 3; k++) {

		float noise_seed = ofRandom(1000);
		for (int i = 0; i < this->hex_locations.size(); i++) {

			auto noise_location = glm::vec2(this->hex_locations[i].x, ofMap(ofNoise(noise_seed, this->hex_locations[i].x * 0.001, ofGetFrameNum() * 0.003), 0, 1, -ofGetHeight() * 0.75, ofGetHeight() * 0.75));
			auto distance = glm::distance(this->hex_locations[i], noise_location);

			if (distance < 60) {

				ofPushMatrix();
				ofTranslate(this->hex_locations[i]);

				vector<glm::vec2> vertices;
				for (int deg = 30; deg <= 390; deg += 60) {

					vertices.push_back(glm::vec2((radius)* cos(deg * DEG_TO_RAD), (radius)* sin(deg * DEG_TO_RAD)));
				}

				ofNoFill();
				ofSetColor(this->hex_colors[i]);

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

				ofFill();
				ofSetColor(this->hex_colors[i], ofMap(distance, 0, 60, 255, 32));

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

				ofPopMatrix();
			}
		}
	}
}

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

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openFrameworks");

ofBackground(0);

ofEnableBlendMode(ofBlendMode::OF_BLENDMODE_ADD);

this->radius = 10;

auto flag = true;

float sqrt_3 = sqrt(3);

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

for (float x = -ofGetWidth() * 0.5 - radius; x < ofGetWidth() * 0.5 + radius; x += radius * sqrt_3) {

auto location = flag ? glm::vec2(x, y) : glm::vec2(x + this->radius * sqrt_3 * 0.5, y);

this->hex_locations.push_back(location);

ofColor hex_color;

hex_color.setHsb(ofRandom(255), 230, 230);

this->hex_colors.push_back(hex_color);

}

flag = !flag;

}

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

void ofApp::update() {

ofSeedRandom(39);

}

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

void ofApp::draw() {

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

for (int k = 0; k < 3; k++) {

float noise_seed = ofRandom(1000);

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

auto noise_location = glm::vec2(this->hex_locations[i].x, ofMap(ofNoise(noise_seed, this->hex_locations[i].x * 0.001, ofGetFrameNum() * 0.003), 0, 1, -ofGetHeight() * 0.75, ofGetHeight() * 0.75));

auto distance = glm::distance(this->hex_locations[i], noise_location);

if (distance < 60) {

ofPushMatrix();

ofTranslate(this->hex_locations[i]);

vector<glm::vec2> vertices;

for (int deg = 30; deg <= 390; deg += 60) {

vertices.push_back(glm::vec2((radius)* cos(deg * DEG_TO_RAD), (radius)* sin(deg * DEG_TO_RAD)));

}

ofNoFill();

ofSetColor(this->hex_colors[i]);

ofBeginShape();

ofVertices(vertices);

ofEndShape(true);

ofFill();

ofSetColor(this->hex_colors[i], ofMap(distance, 0, 60, 255, 32));

ofBeginShape();

ofVertices(vertices);

ofEndShape(true);

ofPopMatrix();

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2019年4月30日

Hex wave. openFrameworks

[ Video ]

[ About ]
六角形でウェーブ

Hexagon wave.

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

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

};

#include "ofApp.h"	

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

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

	ofBackground(239);
}

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

	ofSeedRandom(39);
}

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

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

	auto radius = 15;
	auto flg = true;
	float sqrt_3 = sqrt(3);
	int threshold = (ofGetFrameNum() * 3) % 600;
	ofColor color;
	for (float y = -ofGetHeight() * 0.5 - radius; y < ofGetHeight() * 0.5 + radius; y += radius * 1.5) {

		for (float x = -ofGetWidth() * 0.5 - radius; x < ofGetWidth() * 0.5 + radius; x += radius * sqrt_3) {

			auto location = flg ? glm::vec2(x, y) : glm::vec2(x + radius * sqrt_3 * 0.5, y);
			auto len = glm::length(location) + 39;
			auto gap = abs(len - threshold);
			color.setHsb(ofRandom(255), 255, 255);

			if (gap < 39) {

				ofPushMatrix();
				ofTranslate(location);

				vector<glm::vec2> vertices;
				for (int deg = 30; deg <= 390; deg += 60) {

					vertices.push_back(glm::vec2((radius - 1) * cos(deg * DEG_TO_RAD), (radius - 1) * sin(deg * DEG_TO_RAD)));
				}

				ofNoFill();
				ofSetColor(color);
				ofBeginShape();
				ofVertices(vertices);
				ofEndShape(true);

				ofFill();
				ofSetColor(color, ofMap(gap, 0, 39, 255, 0));
				ofBeginShape();
				ofVertices(vertices);
				ofEndShape(true);

				ofPopMatrix();
			}
		}
		flg = !flg;
	}
}

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

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openFrameworks");

ofBackground(239);

}

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

void ofApp::update() {

ofSeedRandom(39);

}

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

void ofApp::draw() {

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

auto radius = 15;

auto flg = true;

float sqrt_3 = sqrt(3);

int threshold = (ofGetFrameNum() * 3) % 600;

ofColor color;

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

for (float x = -ofGetWidth() * 0.5 - radius; x < ofGetWidth() * 0.5 + radius; x += radius * sqrt_3) {

auto location = flg ? glm::vec2(x, y) : glm::vec2(x + radius * sqrt_3 * 0.5, y);

auto len = glm::length(location) + 39;

auto gap = abs(len - threshold);

color.setHsb(ofRandom(255), 255, 255);

if (gap < 39) {

ofPushMatrix();

ofTranslate(location);

vector<glm::vec2> vertices;

for (int deg = 30; deg <= 390; deg += 60) {

vertices.push_back(glm::vec2((radius - 1) * cos(deg * DEG_TO_RAD), (radius - 1) * sin(deg * DEG_TO_RAD)));

}

ofNoFill();

ofSetColor(color);

ofBeginShape();

ofVertices(vertices);

ofEndShape(true);

ofFill();

ofSetColor(color, ofMap(gap, 0, 39, 255, 0));

ofBeginShape();

ofVertices(vertices);

ofEndShape(true);

ofPopMatrix();

}

flg = !flg;

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2018年10月9日2018年10月16日

Many hexagon. openFrameworks

[ Video ]

[ About ]
Hexagonを増殖

Many hexagon.

[ Source ]

#pragma once
#include "ofMain.h"
#include "Hexagon.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) {};

	vector<Hexagon> hexagons;
};

#pragma once

#include "ofMain.h"

#include "Hexagon.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) {};

vector<Hexagon> hexagons;

};

#include "ofApp.h"

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

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

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

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

		ofColor color;
		color.setHsb(i * 2, 200, 255);

		Hexagon hexagon = Hexagon(ofPoint(ofGetWidth() * 0.5, ofGetHeight() * 0.5), 10, color);
		this->hexagons.push_back(hexagon);
	}
}

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

	for (Hexagon& hexagon : this->hexagons) {
	
		hexagon.Update();
	}
}

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

	for (Hexagon& hexagon : this->hexagons) {

		hexagon.Draw();
	}
}

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

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openframeworks");

ofBackground(39);

ofEnableBlendMode(ofBlendMode::OF_BLENDMODE_ADD);

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

ofColor color;

color.setHsb(i * 2, 200, 255);

Hexagon hexagon = Hexagon(ofPoint(ofGetWidth() * 0.5, ofGetHeight() * 0.5), 10, color);

this->hexagons.push_back(hexagon);

}

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

void ofApp::update() {

for (Hexagon& hexagon : this->hexagons) {

hexagon.Update();

}

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

void ofApp::draw() {

for (Hexagon& hexagon : this->hexagons) {

hexagon.Draw();

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

#pragma once
#include "ofMain.h"

class Hexagon {
public:
	Hexagon();
	Hexagon(ofPoint location, float radius, ofColor color);

	void Update();
	void Draw();

private:

	ofPoint location;
	std::deque<ofPoint> logs;
	float radius;
	float height;
	ofColor color;
};

#pragma once

#include "ofMain.h"

class Hexagon {

public:

Hexagon();

Hexagon(ofPoint location, float radius, ofColor color);

void Update();

void Draw();

private:

ofPoint location;

std::deque<ofPoint> logs;

float radius;

float height;

ofColor color;

};

#include "Hexagon.h"

Hexagon::Hexagon() : Hexagon(ofPoint(), 0, ofColor()) {}

Hexagon::Hexagon(ofPoint location, float radius, ofColor color) {

	this->location = location;
	this->radius = radius;
	this->height = radius * sqrt(3);
	this->color = color;
}

void Hexagon::Update() {

	if (ofGetFrameNum() % 5 == 0) {
		
		int r = ofRandom(6);
		int deg = r * 60 + 30;

		int try_count = 0;
		ofPoint tmp_location;
		while (true) {

			tmp_location = this->location + ofPoint(this->height * cos(deg * DEG_TO_RAD), this->height * sin(deg * DEG_TO_RAD));
			if (tmp_location.x > 0 && tmp_location.x < ofGetWidth() && tmp_location.y > 0 && tmp_location.y < ofGetHeight()) { break; }

			deg += 60;
			if (++try_count > 6) { 
				
				tmp_location = this->location; 
				break;
			}
		}
		this->location = tmp_location;
		this->logs.push_front(this->location);
	}

	while (this->logs.size() > 6) { this->logs.pop_back(); }
}

void Hexagon::Draw() {

	float tmp_radius = this->radius;
	ofSetColor(this->color);

	for (ofPoint& log : this->logs) {

		ofPushMatrix();
		ofTranslate(log);

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

			ofVertex(tmp_radius * cos(deg * DEG_TO_RAD), tmp_radius * sin(deg * DEG_TO_RAD));
		}
		ofEndShape(true);

		ofPopMatrix();
	}
}

#include "Hexagon.h"

Hexagon::Hexagon() : Hexagon(ofPoint(), 0, ofColor()) {}

Hexagon::Hexagon(ofPoint location, float radius, ofColor color) {

this->location = location;

this->radius = radius;

this->height = radius * sqrt(3);

this->color = color;

}

void Hexagon::Update() {

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

int r = ofRandom(6);

int deg = r * 60 + 30;

int try_count = 0;

ofPoint tmp_location;

while (true) {

tmp_location = this->location + ofPoint(this->height * cos(deg * DEG_TO_RAD), this->height * sin(deg * DEG_TO_RAD));

if (tmp_location.x > 0 && tmp_location.x < ofGetWidth() && tmp_location.y > 0 && tmp_location.y < ofGetHeight()) { break; }

deg += 60;

if (++try_count > 6) {

tmp_location = this->location;

break;

}

this->location = tmp_location;

this->logs.push_front(this->location);

}

while (this->logs.size() > 6) { this->logs.pop_back(); }

}

void Hexagon::Draw() {

float tmp_radius = this->radius;

ofSetColor(this->color);

for (ofPoint& log : this->logs) {

ofPushMatrix();

ofTranslate(log);

ofBeginShape();

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

ofVertex(tmp_radius * cos(deg * DEG_TO_RAD), tmp_radius * sin(deg * DEG_TO_RAD));

}

ofEndShape(true);

ofPopMatrix();

}

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2024年4月
月	火	水	木	金	土	日
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