RandomWalk – ページ 81 – プログラミング de 落描き

2020年4月3日2020年4月3日

Random walker 3D. openFrameworks

[ Video ]

[ About ]
deconbatch blog
https://note.com/deconbatch/n/na13107826c9c

deconbatch さんのブログに面白そうなランダムウォーカーの作例があったので、挑戦してみました。
3D座標を移動しますが、それぞれが重ならないように工夫しました。

I found an interesting example of a random walker on deconbatch’s blog, so I challenged it.
The 3D coordinates are moved so that they do not overlap each other.

[ 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 setBoxToMesh(ofMesh& face_target, ofMesh& frame_target, glm::vec3 location, float size);
	void setBoxToMesh(ofMesh& face_target, ofMesh& frame_target, glm::vec3 location, float height, float width, float depth);

	ofEasyCam cam;
	ofMesh face, frame;

	vector<glm::vec3> location_list;
	vector<int> param_list;
	vector<vector<int>> route_info_list;

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

void dragEvent(ofDragInfo dragInfo) {};

void gotMessage(ofMessage msg) {};

void setBoxToMesh(ofMesh& face_target, ofMesh& frame_target, glm::vec3 location, float size);

void setBoxToMesh(ofMesh& face_target, ofMesh& frame_target, glm::vec3 location, float height, float width, float depth);

ofEasyCam cam;

ofMesh face, frame;

vector<glm::vec3> location_list;

vector<int> param_list;

vector<vector<int>> route_info_list;

vector<int> index_list;

};

#include "ofApp.h"

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

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

	ofBackground(239);
	ofEnableDepthTest();

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

	int span = 20;
	for (int x = -220; x <= 220; x += span) {

		for (int y = -220; y <= 220; y += span) {

			for (int z = -220; z <= 220; z += span) {

				this->location_list.push_back(glm::vec3(x, y, z));
				this->param_list.push_back(0);
			}
		}
	}

	for (auto& location : this->location_list) {

		vector<int> route_info = vector<int>();
		int index = -1;
		for (auto& other : this->location_list) {

			index++;
			if (location == other) { continue; }

			float distance = glm::distance(location, other);
			if (distance <= span) {

				route_info.push_back(index);
			}
		}

		this->route_info_list.push_back(route_info);
	}

	for (int i = 0; i < 15; i++) {
	
		this->index_list.push_back((int)ofRandom(this->location_list.size()));
	}
}

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

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

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

		int next_index = this->route_info_list[this->index_list[i]][(int)ofRandom(this->route_info_list[this->index_list[i]].size())];
		for (int k = 0; k < this->route_info_list[this->index_list[i]].size(); k++) {

			if (this->param_list[next_index] <= 0) {

				this->param_list[next_index] = 30;
				this->index_list[i] = next_index;
				break;
			}
		}
	}
	
	for (int i = 0; i < this->location_list.size(); i++) {
	
		if (this->param_list[i] > 0) {
		
			this->setBoxToMesh(this->face, this->frame, this->location_list[i], 20);
		}

		if (this->param_list[i] > 0) { this->param_list[i] -= 1; }
	}
}

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

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

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

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

	this->cam.end();
}

//--------------------------------------------------------------
void ofApp::setBoxToMesh(ofMesh& face_target, ofMesh& frame_target, glm::vec3 location, float size) {

	this->setBoxToMesh(face_target, frame_target, location, size, size, size);
}

//--------------------------------------------------------------
void ofApp::setBoxToMesh(ofMesh& face_target, ofMesh& frame_target, glm::vec3 location, float height, float width, float depth) {

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

	face_target.addVertex(location + glm::vec3(width * -0.5 * 0.99, height * 0.5 * 0.99, depth * -0.5 * 0.99));
	face_target.addVertex(location + glm::vec3(width * 0.5 * 0.99, height * 0.5 * 0.99, depth * -0.5 * 0.99));
	face_target.addVertex(location + glm::vec3(width * 0.5 * 0.99, height * 0.5 * 0.99, depth * 0.5 * 0.99));
	face_target.addVertex(location + glm::vec3(width * -0.5 * 0.99, height * 0.5 * 0.99, depth * 0.5 * 0.99));

	face_target.addVertex(location + glm::vec3(width * -0.5 * 0.99, height * -0.5 * 0.99, depth * -0.5 * 0.99));
	face_target.addVertex(location + glm::vec3(width * 0.5 * 0.99, height * -0.5 * 0.99, depth * -0.5 * 0.99));
	face_target.addVertex(location + glm::vec3(width * 0.5 * 0.99, height * -0.5 * 0.99, depth * 0.5 * 0.99));
	face_target.addVertex(location + glm::vec3(width * -0.5 * 0.99, height * -0.5 * 0.99, depth * 0.5 * 0.99));

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

	face_target.addIndex(face_index + 4); face_target.addIndex(face_index + 5); face_target.addIndex(face_index + 6);
	face_target.addIndex(face_index + 4); face_target.addIndex(face_index + 6); face_target.addIndex(face_index + 7);

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

	face_target.addIndex(face_index + 1); face_target.addIndex(face_index + 5); face_target.addIndex(face_index + 6);
	face_target.addIndex(face_index + 6); face_target.addIndex(face_index + 2); face_target.addIndex(face_index + 1);

	face_target.addIndex(face_index + 2); face_target.addIndex(face_index + 6); face_target.addIndex(face_index + 7);
	face_target.addIndex(face_index + 7); face_target.addIndex(face_index + 3); face_target.addIndex(face_index + 2);

	face_target.addIndex(face_index + 3); face_target.addIndex(face_index + 7); face_target.addIndex(face_index + 4);
	face_target.addIndex(face_index + 4); face_target.addIndex(face_index + 0); face_target.addIndex(face_index + 3);

	frame_target.addVertex(location + glm::vec3(width * -0.5, height * 0.5, depth * -0.5));
	frame_target.addVertex(location + glm::vec3(width * 0.5, height * 0.5, depth * -0.5));
	frame_target.addVertex(location + glm::vec3(width * 0.5, height * 0.5, depth * 0.5));
	frame_target.addVertex(location + glm::vec3(width * -0.5, height * 0.5, depth * 0.5));

	frame_target.addVertex(location + glm::vec3(width * -0.5, height * -0.5, depth * -0.5));
	frame_target.addVertex(location + glm::vec3(width * 0.5, height * -0.5, depth * -0.5));
	frame_target.addVertex(location + glm::vec3(width * 0.5, height * -0.5, depth * 0.5));
	frame_target.addVertex(location + glm::vec3(width * -0.5, height * -0.5, depth * 0.5));

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

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

	frame_target.addIndex(frame_index + 0); frame_target.addIndex(frame_index + 4);
	frame_target.addIndex(frame_index + 1); frame_target.addIndex(frame_index + 5);
	frame_target.addIndex(frame_index + 2); frame_target.addIndex(frame_index + 6);
	frame_target.addIndex(frame_index + 3); frame_target.addIndex(frame_index + 7);
}

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

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openFrameworks");

ofBackground(239);

ofEnableDepthTest();

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

int span = 20;

for (int x = -220; x <= 220; x += span) {

for (int y = -220; y <= 220; y += span) {

for (int z = -220; z <= 220; z += span) {

this->location_list.push_back(glm::vec3(x, y, z));

this->param_list.push_back(0);

}

for (auto& location : this->location_list) {

vector<int> route_info = vector<int>();

int index = -1;

for (auto& other : this->location_list) {

index++;

if (location == other) { continue; }

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

if (distance <= span) {

route_info.push_back(index);

}

this->route_info_list.push_back(route_info);

}

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

this->index_list.push_back((int)ofRandom(this->location_list.size()));

}

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

void ofApp::update() {

this->face.clear();

this->frame.clear();

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

int next_index = this->route_info_list[this->index_list[i]][(int)ofRandom(this->route_info_list[this->index_list[i]].size())];

for (int k = 0; k < this->route_info_list[this->index_list[i]].size(); k++) {

if (this->param_list[next_index] <= 0) {

this->param_list[next_index] = 30;

this->index_list[i] = next_index;

break;

}

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

if (this->param_list[i] > 0) {

this->setBoxToMesh(this->face, this->frame, this->location_list[i], 20);

}

if (this->param_list[i] > 0) { this->param_list[i] -= 1; }

}

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

void ofApp::draw() {

this->cam.begin();

ofRotateY(ofGetFrameNum() * 0.5);

ofSetColor(39);

this->face.draw();

ofSetColor(239);

this->frame.drawWireframe();

this->cam.end();

}

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

void ofApp::setBoxToMesh(ofMesh& face_target, ofMesh& frame_target, glm::vec3 location, float size) {

this->setBoxToMesh(face_target, frame_target, location, size, size, size);

}

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

void ofApp::setBoxToMesh(ofMesh& face_target, ofMesh& frame_target, glm::vec3 location, float height, float width, float depth) {

int face_index = face_target.getNumVertices();

int frame_index = frame_target.getNumVertices();

face_target.addVertex(location + glm::vec3(width * -0.5 * 0.99, height * 0.5 * 0.99, depth * -0.5 * 0.99));

face_target.addVertex(location + glm::vec3(width * 0.5 * 0.99, height * 0.5 * 0.99, depth * -0.5 * 0.99));

face_target.addVertex(location + glm::vec3(width * 0.5 * 0.99, height * 0.5 * 0.99, depth * 0.5 * 0.99));

face_target.addVertex(location + glm::vec3(width * -0.5 * 0.99, height * 0.5 * 0.99, depth * 0.5 * 0.99));

face_target.addVertex(location + glm::vec3(width * -0.5 * 0.99, height * -0.5 * 0.99, depth * -0.5 * 0.99));

face_target.addVertex(location + glm::vec3(width * 0.5 * 0.99, height * -0.5 * 0.99, depth * -0.5 * 0.99));

face_target.addVertex(location + glm::vec3(width * 0.5 * 0.99, height * -0.5 * 0.99, depth * 0.5 * 0.99));

face_target.addVertex(location + glm::vec3(width * -0.5 * 0.99, height * -0.5 * 0.99, depth * 0.5 * 0.99));

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

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

face_target.addIndex(face_index + 4); face_target.addIndex(face_index + 6); face_target.addIndex(face_index + 7);

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

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

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

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

face_target.addIndex(face_index + 2); face_target.addIndex(face_index + 6); face_target.addIndex(face_index + 7);

face_target.addIndex(face_index + 7); face_target.addIndex(face_index + 3); face_target.addIndex(face_index + 2);

face_target.addIndex(face_index + 3); face_target.addIndex(face_index + 7); face_target.addIndex(face_index + 4);

face_target.addIndex(face_index + 4); face_target.addIndex(face_index + 0); face_target.addIndex(face_index + 3);

frame_target.addVertex(location + glm::vec3(width * -0.5, height * 0.5, depth * -0.5));

frame_target.addVertex(location + glm::vec3(width * 0.5, height * 0.5, depth * -0.5));

frame_target.addVertex(location + glm::vec3(width * 0.5, height * 0.5, depth * 0.5));

frame_target.addVertex(location + glm::vec3(width * -0.5, height * 0.5, depth * 0.5));

frame_target.addVertex(location + glm::vec3(width * -0.5, height * -0.5, depth * -0.5));

frame_target.addVertex(location + glm::vec3(width * 0.5, height * -0.5, depth * -0.5));

frame_target.addVertex(location + glm::vec3(width * 0.5, height * -0.5, depth * 0.5));

frame_target.addVertex(location + glm::vec3(width * -0.5, height * -0.5, depth * 0.5));

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

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

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

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

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

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

frame_target.addIndex(frame_index + 6); frame_target.addIndex(frame_index + 7);

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

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

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

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

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

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2020年4月1日2020年4月1日

Proliferating Mover. openFrameworks

[ Video ]

[ About ]
近づくと線を引く Mover は一定の確率で分裂して増えます。
ただし、異常増殖を防止する機能を備えています。

The Mover that draws a line as it gets closer will split up and increase with a certain probability.
However, it does have the ability to prevent abnormal growth.

[ Source ]

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

	vector<unique_ptr<Mover>> mover_list;
};

#pragma once

#include "ofMain.h"

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

vector<unique_ptr<Mover>> mover_list;

};

#include "ofApp.h"

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

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

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

	auto m = make_unique<Mover>(glm::vec2(ofGetWidth() * 0.5, ofGetHeight() * 0.5));
	this->mover_list.push_back(move(m));
}

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

	// 数によって分割する確率を変化させる
	int separation_rate = ofMap(this->mover_list.size(), 1, 30, 100, 0);

	// 更新
	for (auto& mover : this->mover_list) {

		mover->update(separation_rate);
	}

	// 分割
	for (int i = 0; i < this->mover_list.size(); i++) {

		if(this->mover_list[i]->isSeparation()){

			auto m = make_unique<Mover>(this->mover_list[i]->getLocation());
			this->mover_list.push_back(move(m));
		}
	}

	// 削除
	for (int i = this->mover_list.size() - 1; i >= 0; i--) {

		if (this->mover_list[i]->isDead()) {

			this->mover_list.erase(this->mover_list.begin() + i);
		}
	}
}

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

	for (auto& mover : this->mover_list) {

		mover->draw(this->mover_list);
	}
}

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

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openFrameworks");

ofBackground(239);

ofSetColor(39);

ofSetLineWidth(2);

auto m = make_unique<Mover>(glm::vec2(ofGetWidth() * 0.5, ofGetHeight() * 0.5));

this->mover_list.push_back(move(m));

}

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

void ofApp::update() {

// 数によって分割する確率を変化させる

int separation_rate = ofMap(this->mover_list.size(), 1, 30, 100, 0);

// 更新

for (auto& mover : this->mover_list) {

mover->update(separation_rate);

}

// 分割

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

if(this->mover_list[i]->isSeparation()){

auto m = make_unique<Mover>(this->mover_list[i]->getLocation());

this->mover_list.push_back(move(m));

}

// 削除

for (int i = this->mover_list.size() - 1; i >= 0; i--) {

if (this->mover_list[i]->isDead()) {

this->mover_list.erase(this->mover_list.begin() + i);

}

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

void ofApp::draw() {

for (auto& mover : this->mover_list) {

mover->draw(this->mover_list);

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

#pragma once
#include "ofMain.h"

class Mover {
public:

	Mover(glm::vec2 start);
	glm::vec2 think();
	void update(int separation_rate);
	void draw(vector<unique_ptr<Mover>>& mover_list);
	glm::vec2 getLocation();
	bool isDead();
	bool isSeparation();

private:

	int motion_cycle = 60;
	unsigned int count = 0;
	glm::vec2 start;
	glm::vec2 next;
	vector<glm::vec2> log_list;
	bool dead = false;
	bool separation = false;
};

#pragma once

#include "ofMain.h"

class Mover {

public:

Mover(glm::vec2 start);

glm::vec2 think();

void update(int separation_rate);

void draw(vector<unique_ptr<Mover>>& mover_list);

glm::vec2 getLocation();

bool isDead();

bool isSeparation();

private:

int motion_cycle = 60;

unsigned int count = 0;

glm::vec2 start;

glm::vec2 next;

vector<glm::vec2> log_list;

bool dead = false;

bool separation = false;

};

#include "Mover.h"

//--------------------------------------------------------------
Mover::Mover(glm::vec2 start) {

	this->start = start;
	this->next = this->think();
	log_list.push_back(this->start);
}

//--------------------------------------------------------------
void Mover::update(int separation_rate) {

	// 分離判定用のフラグ
	this->separation = false;

	// 次の場所を探す
	int param = ofGetFrameNum() % this->motion_cycle;
	if (param == 0) {

		if (this->count > 0) {
		
			this->start = this->next;
			this->next = this->think();
		}

		// 動きの節目のタイミングで分離有無を判定判定
		this->separation = ofRandom(100) < separation_rate;
	}
	
	// 静 / 動の制御
	if(param > this->motion_cycle * 0.55) {

		auto location = this->start + ((this->next - this->start) / this->motion_cycle) * ofMap(param, this->motion_cycle * 0.55, this->motion_cycle - 1, 0, this->motion_cycle);
		this->log_list.push_back(location);
	}
	else {

		this->log_list.push_back(this->log_list.back());
	}

	// 画面外に出た Mover は削除対象
	if (this->log_list.back().x < 0 || this->log_list.back().x > ofGetWidth() || this->log_list.back().y < 0 || this->log_list.back().y > ofGetHeight()) {
		
		this->dead = true;
	}

	// 軌跡表示用に5フレーム分だけ保存
	while (this->log_list.size() > 5) {

		this->log_list.erase(this->log_list.begin());
	}

	this->count++;
}

//--------------------------------------------------------------
void Mover::draw(vector<unique_ptr<Mover>>& mover_list) {

	// 近くにいたら線を引く
	ofFill();
	bool draw_line = false;
	for (auto& other : mover_list) {

		if (this->log_list.back() == other->getLocation()) { continue; }
		if (glm::distance(this->log_list.back(), other->getLocation()) < 100) {

			ofDrawLine(this->log_list.back(), other->getLocation());
			draw_line = true;
		}
	}

	// 線の基点となる円
	if (draw_line) { ofDrawCircle(this->log_list.back(), 5); }

	// 自身の場所を示す円
	ofNoFill();
	for (int i = 0; i < this->log_list.size(); i++) {

		ofSetColor(ofMap(i, 0, this->log_list.size() - 1, 200, 39));
		ofDrawCircle(this->log_list[i], 15);
	}
}

//--------------------------------------------------------------
glm::vec2 Mover::think() {

	int radius = 175;
	int deg = ofRandom(360);
	auto tmp_next = this->start + glm::vec2(radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD));
	return tmp_next;
}

//--------------------------------------------------------------
glm::vec2 Mover::getLocation() {
	
	return this->log_list.back();
}

//--------------------------------------------------------------
bool Mover::isDead() {

	return this->dead;
}

//--------------------------------------------------------------
bool Mover::isSeparation() {

	return this->separation;
}

100

101

102

103

104

105

106

107

108

109

110

#include "Mover.h"

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

Mover::Mover(glm::vec2 start) {

this->start = start;

this->next = this->think();

log_list.push_back(this->start);

}

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

void Mover::update(int separation_rate) {

// 分離判定用のフラグ

this->separation = false;

// 次の場所を探す

int param = ofGetFrameNum() % this->motion_cycle;

if (param == 0) {

if (this->count > 0) {

this->start = this->next;

this->next = this->think();

}

// 動きの節目のタイミングで分離有無を判定判定

this->separation = ofRandom(100) < separation_rate;

}

// 静 / 動の制御

if(param > this->motion_cycle * 0.55) {

auto location = this->start + ((this->next - this->start) / this->motion_cycle) * ofMap(param, this->motion_cycle * 0.55, this->motion_cycle - 1, 0, this->motion_cycle);

this->log_list.push_back(location);

}

else {

this->log_list.push_back(this->log_list.back());

}

// 画面外に出た Mover は削除対象

if (this->log_list.back().x < 0 || this->log_list.back().x > ofGetWidth() || this->log_list.back().y < 0 || this->log_list.back().y > ofGetHeight()) {

this->dead = true;

}

// 軌跡表示用に5フレーム分だけ保存

while (this->log_list.size() > 5) {

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

}

this->count++;

}

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

void Mover::draw(vector<unique_ptr<Mover>>& mover_list) {

// 近くにいたら線を引く

ofFill();

bool draw_line = false;

for (auto& other : mover_list) {

if (this->log_list.back() == other->getLocation()) { continue; }

if (glm::distance(this->log_list.back(), other->getLocation()) < 100) {

ofDrawLine(this->log_list.back(), other->getLocation());

draw_line = true;

}

// 線の基点となる円

if (draw_line) { ofDrawCircle(this->log_list.back(), 5); }

// 自身の場所を示す円

ofNoFill();

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

ofSetColor(ofMap(i, 0, this->log_list.size() - 1, 200, 39));

ofDrawCircle(this->log_list[i], 15);

}

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

glm::vec2 Mover::think() {

int radius = 175;

int deg = ofRandom(360);

auto tmp_next = this->start + glm::vec2(radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD));

return tmp_next;

}

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

glm::vec2 Mover::getLocation() {

return this->log_list.back();

}

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

bool Mover::isDead() {

return this->dead;

}

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

bool Mover::isSeparation() {

return this->separation;

}

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2020年3月25日2020年3月25日

Glowing random walks. openFrameworks

[ Video ]

[ About ]
お互いに近づくと輝きを増すランダムウォーク。
光る処理はShaderを使用。

Random walks that shine as they get closer to each other.
Shader is used for the glowing process.

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

	ofShader shader;
	int number_of_targets;
	vector<glm::vec4> location_list;
	vector<float> size_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) {};

ofShader shader;

int number_of_targets;

vector<glm::vec4> location_list;

vector<float> size_list;

};

#include "ofApp.h"

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

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

	this->number_of_targets = 65;
	this->shader.load("shader/shader.vert", "shader/shader.frag");
}
//--------------------------------------------------------------
void ofApp::update() {

	ofSeedRandom(39);

	this->location_list.clear();
	this->size_list.clear();

	for (int i = 0; i < this->number_of_targets; i++) {

		auto location = glm::vec4(ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.005), 0, 1, 0, ofGetWidth()), ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.005), 0, 1, 0, ofGetHeight()), 0, 0);
		this->location_list.push_back(location);
		this->size_list.push_back(0.1);
	}

	for (int i = 0; i < this->number_of_targets; i++) {

		for (int k = i + 1; k < this->number_of_targets; k++) {

			auto distance = glm::distance(this->location_list[i], this->location_list[k]);
			if (distance < 50) {

				this->size_list[i] += 0.25;
				this->size_list[k] += 0.25;
			}
		}
	}
}

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

	this->shader.begin();

	this->shader.setUniform1f("time", ofGetElapsedTimef());
	this->shader.setUniform2f("resolution", ofGetWidth(), ofGetHeight());
	this->shader.setUniform4fv("targets", &this->location_list[0].x, this->number_of_targets);
	this->shader.setUniform1fv("sizes", &this->size_list[0], this->number_of_targets);
	ofRect(0, 0, ofGetWidth(), ofGetHeight());

	this->shader.end();
}

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

	ofGLWindowSettings settings;
	settings.setGLVersion(3, 2);
	settings.setSize(720, 720);
	ofCreateWindow(settings);
	ofRunApp(new ofApp());
}

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(30);

ofSetWindowTitle("openframeworks");

this->number_of_targets = 65;

this->shader.load("shader/shader.vert", "shader/shader.frag");

}

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

void ofApp::update() {

ofSeedRandom(39);

this->location_list.clear();

this->size_list.clear();

for (int i = 0; i < this->number_of_targets; i++) {

auto location = glm::vec4(ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.005), 0, 1, 0, ofGetWidth()), ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.005), 0, 1, 0, ofGetHeight()), 0, 0);

this->location_list.push_back(location);

this->size_list.push_back(0.1);

}

for (int i = 0; i < this->number_of_targets; i++) {

for (int k = i + 1; k < this->number_of_targets; k++) {

auto distance = glm::distance(this->location_list[i], this->location_list[k]);

if (distance < 50) {

this->size_list[i] += 0.25;

this->size_list[k] += 0.25;

}

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

void ofApp::draw() {

this->shader.begin();

this->shader.setUniform1f("time", ofGetElapsedTimef());

this->shader.setUniform2f("resolution", ofGetWidth(), ofGetHeight());

this->shader.setUniform4fv("targets", &this->location_list[0].x, this->number_of_targets);

this->shader.setUniform1fv("sizes", &this->size_list[0], this->number_of_targets);

ofRect(0, 0, ofGetWidth(), ofGetHeight());

this->shader.end();

}

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

int main() {

ofGLWindowSettings settings;

settings.setGLVersion(3, 2);

settings.setSize(720, 720);

ofCreateWindow(settings);

ofRunApp(new ofApp());

}

#version 150

uniform mat4 modelViewProjectionMatrix;
in vec4 position;

void main(){
	gl_Position = modelViewProjectionMatrix * position;
}

#version 150

uniform mat4 modelViewProjectionMatrix;

in vec4 position;

void main(){

gl_Position = modelViewProjectionMatrix * position;

}

#version 150

const int number_of_targets = 65;

out vec4 outputColor;
uniform float time;
uniform vec2 resolution;
uniform vec4 targets[number_of_targets];
uniform float sizes[number_of_targets];

void main() {

  vec2 p = (gl_FragCoord.xy * 2.0 - resolution) / min(resolution.x, resolution.y);
  vec3 color = vec3(0.0);
  for(int i = 0; i < number_of_targets; i++){

    vec2 t = vec2(targets[i].x, -targets[i].y) / min(resolution.x, resolution.y) * 2.0;
    t.xy += vec2(-resolution.x, resolution.y) / min(resolution.x, resolution.y);

    float r = 0.03 / length(p - t) * sizes[i];
    vec3 c = vec3(smoothstep(0.03, 1.0, r), smoothstep(0.03, 1.0, r), smoothstep(0.03, 1.0, r));
    color += c;
  }

  outputColor = vec4(color, 1.0);
}

#version 150

const int number_of_targets = 65;

out vec4 outputColor;

uniform float time;

uniform vec2 resolution;

uniform vec4 targets[number_of_targets];

uniform float sizes[number_of_targets];

void main() {

vec2 p = (gl_FragCoord.xy * 2.0 - resolution) / min(resolution.x, resolution.y);

vec3 color = vec3(0.0);

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

vec2 t = vec2(targets[i].x, -targets[i].y) / min(resolution.x, resolution.y) * 2.0;

t.xy += vec2(-resolution.x, resolution.y) / min(resolution.x, resolution.y);

float r = 0.03 / length(p - t) * sizes[i];

vec3 c = vec3(smoothstep(0.03, 1.0, r), smoothstep(0.03, 1.0, r), smoothstep(0.03, 1.0, r));

color += c;

}

outputColor = vec4(color, 1.0);

}

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

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