noise – ページ 261 – プログラミング de 落描き

2020年4月23日2020年4月23日

Velocity visualize. openFrameworks

[ Video ]

[ About ]
Velocity visualize.

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

	ofEasyCam cam;

	int base_radius;
	int number_of_satellite;

	vector<glm::vec3> base_noise_seed_list;
	vector<vector<glm::vec3>> satellite_location_list;
	vector<vector<glm::vec2>> satellite_noise_seed_list;
	vector<glm::vec3> location_list;
	vector<glm::vec3> velocity_list;

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

ofEasyCam cam;

int base_radius;

int number_of_satellite;

vector<glm::vec3> base_noise_seed_list;

vector<vector<glm::vec3>> satellite_location_list;

vector<vector<glm::vec2>> satellite_noise_seed_list;

vector<glm::vec3> location_list;

vector<glm::vec3> velocity_list;

ofMesh frame;

};

#include "ofApp.h"

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

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

	ofBackground(239);
	ofSetColor(39);
	ofEnableDepthTest();

	this->base_radius = 120;
	this->number_of_satellite = 2;
	for (int i = 0; i < 5; i++) {

		this->base_noise_seed_list.push_back(glm::vec3(ofRandom(1000), ofRandom(1000), ofRandom(1000)));
		
		auto s_location_list = vector<glm::vec3>();
		auto s_noise_seed_list = vector<glm::vec2>();
		
		for (int k = 0; k < this->number_of_satellite; k++) {

			s_location_list.push_back(glm::normalize(glm::vec3(ofRandom(-1, 1), ofRandom(-1, 1), ofRandom(-1, 1))) * this->base_radius * 1.2);
			s_noise_seed_list.push_back(glm::vec2(ofRandom(1000), ofRandom(1000)));

		}

		this->satellite_location_list.push_back(s_location_list);
		this->satellite_noise_seed_list.push_back(s_noise_seed_list);
	}

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

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


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

		auto base_location = glm::vec3(
			ofMap(ofNoise(this->base_noise_seed_list[i].x, (ofGetFrameNum() + 0) * 0.005), 0, 1, -350, 350),
			ofMap(ofNoise(this->base_noise_seed_list[i].y, (ofGetFrameNum() + 0) * 0.005), 0, 1, -350, 350),
			ofMap(ofNoise(this->base_noise_seed_list[i].z, (ofGetFrameNum() + 0) * 0.005), 0, 1, -350, 350)
		);

		for (int k = 0; k < this->number_of_satellite; k++) {

			auto rotation_y = glm::rotate(glm::mat4(), ofMap(ofNoise(this->satellite_noise_seed_list[i][k].x, (ofGetFrameNum() + 0) * 0.005), 0, 1, -PI * 2, PI * 2), glm::vec3(0, 1, 0));
			auto rotation_x = glm::rotate(glm::mat4(), ofMap(ofNoise(this->satellite_noise_seed_list[i][k].y, (ofGetFrameNum() + 0) * 0.005), 0, 1, -PI * 2, PI * 2), glm::vec3(1, 0, 0));
			auto satellite_location = glm::vec4(this->satellite_location_list[i][k], 0) * rotation_y * rotation_x;

			auto next_base_location = glm::vec3(
				ofMap(ofNoise(this->base_noise_seed_list[i].x, (ofGetFrameNum() + 1) * 0.005), 0, 1, -350, 350),
				ofMap(ofNoise(this->base_noise_seed_list[i].y, (ofGetFrameNum() + 1) * 0.005), 0, 1, -350, 350),
				ofMap(ofNoise(this->base_noise_seed_list[i].z, (ofGetFrameNum() + 1) * 0.005), 0, 1, -350, 350)
			);

			auto next_rotation_y = glm::rotate(glm::mat4(), ofMap(ofNoise(this->satellite_noise_seed_list[i][k].x, (ofGetFrameNum() + 1) * 0.005), 0, 1, -PI * 2, PI * 2), glm::vec3(0, 1, 0));
			auto next_rotation_x = glm::rotate(glm::mat4(), ofMap(ofNoise(this->satellite_noise_seed_list[i][k].y, (ofGetFrameNum() + 1) * 0.005), 0, 1, -PI * 2, PI * 2), glm::vec3(1, 0, 0));
			auto next_satellite_location = glm::vec4(this->satellite_location_list[i][k], 0) * rotation_y * rotation_x;

			auto location = base_location + satellite_location;
			auto next_location = next_base_location + next_satellite_location;
			auto distance = location - next_location;

			auto future = glm::vec3(satellite_location) + distance * 80;
			auto random_deg_1 = ofRandom(360);
			auto random_deg_2 = ofRandom(360);
			future += glm::vec3(
				30 * cos(random_deg_1 * DEG_TO_RAD) * sin(random_deg_2 * DEG_TO_RAD),
				30 * sin(random_deg_1 * DEG_TO_RAD) * sin(random_deg_2 * DEG_TO_RAD),
				30 * cos(random_deg_2 * DEG_TO_RAD)
			);
			auto future_distance = future - satellite_location;

			this->frame.addVertex(location);
			this->velocity_list.push_back(glm::normalize(future_distance) * glm::length(distance));
		}
	}

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

		this->frame.setVertex(i, this->frame.getVertex(i) + this->velocity_list[i]);
	}

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

		if (glm::length(this->frame.getVertex(i)) > 720) {

			this->velocity_list.erase(this->velocity_list.begin() + i);
			this->frame.removeVertex(i);
		}
	}

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

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

			if (glm::distance(this->frame.getVertex(i), this->frame.getVertex(k)) < 50) {

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

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

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

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

		ofDrawSphere(this->frame.getVertex(i), 2);
	}

	this->frame.drawWireframe();


	this->cam.end();
}

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openframeworks");

ofBackground(239);

ofSetColor(39);

ofEnableDepthTest();

this->base_radius = 120;

this->number_of_satellite = 2;

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

this->base_noise_seed_list.push_back(glm::vec3(ofRandom(1000), ofRandom(1000), ofRandom(1000)));

auto s_location_list = vector<glm::vec3>();

auto s_noise_seed_list = vector<glm::vec2>();

for (int k = 0; k < this->number_of_satellite; k++) {

s_location_list.push_back(glm::normalize(glm::vec3(ofRandom(-1, 1), ofRandom(-1, 1), ofRandom(-1, 1))) * this->base_radius * 1.2);

s_noise_seed_list.push_back(glm::vec2(ofRandom(1000), ofRandom(1000)));

}

this->satellite_location_list.push_back(s_location_list);

this->satellite_noise_seed_list.push_back(s_noise_seed_list);

}

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

}

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

void ofApp::update() {

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

auto base_location = glm::vec3(

ofMap(ofNoise(this->base_noise_seed_list[i].x, (ofGetFrameNum() + 0) * 0.005), 0, 1, -350, 350),

ofMap(ofNoise(this->base_noise_seed_list[i].y, (ofGetFrameNum() + 0) * 0.005), 0, 1, -350, 350),

ofMap(ofNoise(this->base_noise_seed_list[i].z, (ofGetFrameNum() + 0) * 0.005), 0, 1, -350, 350)

);

for (int k = 0; k < this->number_of_satellite; k++) {

auto rotation_y = glm::rotate(glm::mat4(), ofMap(ofNoise(this->satellite_noise_seed_list[i][k].x, (ofGetFrameNum() + 0) * 0.005), 0, 1, -PI * 2, PI * 2), glm::vec3(0, 1, 0));

auto rotation_x = glm::rotate(glm::mat4(), ofMap(ofNoise(this->satellite_noise_seed_list[i][k].y, (ofGetFrameNum() + 0) * 0.005), 0, 1, -PI * 2, PI * 2), glm::vec3(1, 0, 0));

auto satellite_location = glm::vec4(this->satellite_location_list[i][k], 0) * rotation_y * rotation_x;

auto next_base_location = glm::vec3(

ofMap(ofNoise(this->base_noise_seed_list[i].x, (ofGetFrameNum() + 1) * 0.005), 0, 1, -350, 350),

ofMap(ofNoise(this->base_noise_seed_list[i].y, (ofGetFrameNum() + 1) * 0.005), 0, 1, -350, 350),

ofMap(ofNoise(this->base_noise_seed_list[i].z, (ofGetFrameNum() + 1) * 0.005), 0, 1, -350, 350)

);

auto next_rotation_y = glm::rotate(glm::mat4(), ofMap(ofNoise(this->satellite_noise_seed_list[i][k].x, (ofGetFrameNum() + 1) * 0.005), 0, 1, -PI * 2, PI * 2), glm::vec3(0, 1, 0));

auto next_rotation_x = glm::rotate(glm::mat4(), ofMap(ofNoise(this->satellite_noise_seed_list[i][k].y, (ofGetFrameNum() + 1) * 0.005), 0, 1, -PI * 2, PI * 2), glm::vec3(1, 0, 0));

auto next_satellite_location = glm::vec4(this->satellite_location_list[i][k], 0) * rotation_y * rotation_x;

auto location = base_location + satellite_location;

auto next_location = next_base_location + next_satellite_location;

auto distance = location - next_location;

auto future = glm::vec3(satellite_location) + distance * 80;

auto random_deg_1 = ofRandom(360);

auto random_deg_2 = ofRandom(360);

future += glm::vec3(

30 * cos(random_deg_1 * DEG_TO_RAD) * sin(random_deg_2 * DEG_TO_RAD),

30 * sin(random_deg_1 * DEG_TO_RAD) * sin(random_deg_2 * DEG_TO_RAD),

30 * cos(random_deg_2 * DEG_TO_RAD)

);

auto future_distance = future - satellite_location;

this->frame.addVertex(location);

this->velocity_list.push_back(glm::normalize(future_distance) * glm::length(distance));

}

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

this->frame.setVertex(i, this->frame.getVertex(i) + this->velocity_list[i]);

}

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

if (glm::length(this->frame.getVertex(i)) > 720) {

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

this->frame.removeVertex(i);

}

this->frame.clearIndices();

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

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

if (glm::distance(this->frame.getVertex(i), this->frame.getVertex(k)) < 50) {

this->frame.addIndex(i); this->frame.addIndex(k);

}

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

void ofApp::draw() {

this->cam.begin();

ofRotateY(ofGetFrameNum());

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

ofDrawSphere(this->frame.getVertex(i), 2);

}

this->frame.drawWireframe();

this->cam.end();

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

2020年4月20日2020年4月20日

Byproduct of a mistake. openFrameworks

[ Video ]

[ About ]
It was a mistake, but it was good.

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

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

ofEasyCam cam;

ofMesh frame;

};

#include "ofApp.h"

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

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

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

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

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

	ofSeedRandom(39);

	this->frame.clear();
	int number_of_satellite = 4;
	int number_of_log = 50;
	int base_radius = 80;

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

		auto base_seed = glm::vec3(ofRandom(1000), ofRandom(1000), ofRandom(1000));
		auto base_location = glm::vec3(
			ofMap(ofNoise(base_seed.x, (ofGetFrameNum() + number_of_log) * 0.005), 0, 1, -500, 500),
			ofMap(ofNoise(base_seed.y, (ofGetFrameNum() + number_of_log) * 0.005), 0, 1, -500, 500),
			ofMap(ofNoise(base_seed.z, (ofGetFrameNum() + number_of_log) * 0.005), 0, 1, -500, 500));

		for (int j = 0; j < number_of_satellite; j++) {

			float noise_seed_x = ofRandom(1000);
			float noise_seed_y = ofRandom(1000);
			auto location = glm::vec3(ofRandom(-1, 1), ofRandom(-1, 1), ofRandom(-1, 1));
			location = glm::normalize(location) * base_radius * 1.2;

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

				auto rotation_y = glm::rotate(glm::mat4(), ofMap(ofNoise(noise_seed_y, (ofGetFrameNum() + k) * 0.005), 0, 1, -PI * 2, PI * 2), glm::vec3(0, 1, 0));
				auto rotation_x = glm::rotate(glm::mat4(), ofMap(ofNoise(noise_seed_x, (ofGetFrameNum() + k) * 0.005), 0, 1, -PI * 2, PI * 2), glm::vec3(1, 0, 0));
				auto tmp_base_location = glm::vec3(
					ofMap(ofNoise(base_seed.x, (ofGetFrameNum() + k) * 0.005), 0, 1, -500, 500),
					ofMap(ofNoise(base_seed.y, (ofGetFrameNum() + k) * 0.005), 0, 1, -500, 500),
					ofMap(ofNoise(base_seed.z, (ofGetFrameNum() + k) * 0.005), 0, 1, -500, 500));
				auto loc = tmp_base_location + glm::vec4(location, 0) * rotation_y * rotation_x;
				this->frame.addVertex(loc);
				
				ofColor c;
				c.setHsb(ofRandom(255), 255, 255);
				this->frame.addColor(ofColor(c, ofMap(k, 0, number_of_log, 25, 255)));
			}
		}
	}

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

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

			if (glm::distance(this->frame.getVertex(i), this->frame.getVertex(k)) < 30) {

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

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

	this->cam.begin();

	this->frame.drawWireframe();

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

ofEnableBlendMode(ofBlendMode::OF_BLENDMODE_ADD);

ofEnableDepthTest();

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

}

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

void ofApp::update() {

ofSeedRandom(39);

this->frame.clear();

int number_of_satellite = 4;

int number_of_log = 50;

int base_radius = 80;

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

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

auto base_location = glm::vec3(

ofMap(ofNoise(base_seed.x, (ofGetFrameNum() + number_of_log) * 0.005), 0, 1, -500, 500),

ofMap(ofNoise(base_seed.y, (ofGetFrameNum() + number_of_log) * 0.005), 0, 1, -500, 500),

ofMap(ofNoise(base_seed.z, (ofGetFrameNum() + number_of_log) * 0.005), 0, 1, -500, 500));

for (int j = 0; j < number_of_satellite; j++) {

float noise_seed_x = ofRandom(1000);

float noise_seed_y = ofRandom(1000);

auto location = glm::vec3(ofRandom(-1, 1), ofRandom(-1, 1), ofRandom(-1, 1));

location = glm::normalize(location) * base_radius * 1.2;

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

auto rotation_y = glm::rotate(glm::mat4(), ofMap(ofNoise(noise_seed_y, (ofGetFrameNum() + k) * 0.005), 0, 1, -PI * 2, PI * 2), glm::vec3(0, 1, 0));

auto rotation_x = glm::rotate(glm::mat4(), ofMap(ofNoise(noise_seed_x, (ofGetFrameNum() + k) * 0.005), 0, 1, -PI * 2, PI * 2), glm::vec3(1, 0, 0));

auto tmp_base_location = glm::vec3(

ofMap(ofNoise(base_seed.x, (ofGetFrameNum() + k) * 0.005), 0, 1, -500, 500),

ofMap(ofNoise(base_seed.y, (ofGetFrameNum() + k) * 0.005), 0, 1, -500, 500),

ofMap(ofNoise(base_seed.z, (ofGetFrameNum() + k) * 0.005), 0, 1, -500, 500));

auto loc = tmp_base_location + glm::vec4(location, 0) * rotation_y * rotation_x;

this->frame.addVertex(loc);

ofColor c;

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

this->frame.addColor(ofColor(c, ofMap(k, 0, number_of_log, 25, 255)));

}

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

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

if (glm::distance(this->frame.getVertex(i), this->frame.getVertex(k)) < 30) {

this->frame.addIndex(i); this->frame.addIndex(k);

}

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

void ofApp::draw() {

this->cam.begin();

this->frame.drawWireframe();

this->cam.end();

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

2020年4月19日2020年4月19日

Line sphere. openFrameworks

[ Video ]

[ About ]
Rotate a set of vertices over and over.

[ 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 drawVertices(vector<glm::vec3> vertices);

	ofEasyCam cam;
	ofMesh 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 drawVertices(vector<glm::vec3> vertices);

ofEasyCam cam;

ofMesh frame;

};

#include "ofApp.h"

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

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

	ofBackground(0);
	ofSetColor(255);
	ofEnableDepthTest();
}

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

	ofSeedRandom(39);
}

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

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

	int radius = 200;

	auto seed = glm::vec3(ofRandom(1000), ofRandom(1000), ofRandom(1000));
	vector<glm::vec3> vertices;
	for (int i = 0; i < 100; i++) {

		auto location = glm::vec3(
			ofMap(ofNoise(seed.x, (ofGetFrameNum() + i) * 0.008), 0, 1, -1, 1),
			ofMap(ofNoise(seed.y, (ofGetFrameNum() + i) * 0.008), 0, 1, -1, 1),
			ofMap(ofNoise(seed.z, (ofGetFrameNum() + i) * 0.008), 0, 1, -1, 1)
		);
		location = glm::normalize(location) * radius;
		vertices.push_back(location);
	}

	this->drawVertices(vertices);

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

		ofRotateX(60);
		ofRotateY(60);
		ofRotateZ(60);
		this->drawVertices(vertices);
	}
		
	this->cam.end();
}

//--------------------------------------------------------------
void ofApp::drawVertices(vector<glm::vec3> vertices) {

	ofNoFill();
	ofBeginShape();
	ofVertices(vertices);
	ofEndShape();

	ofFill();
	ofDrawSphere(vertices.front(), 3);
	ofDrawSphere(vertices.back(), 3);
}

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

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openframeworks");

ofBackground(0);

ofSetColor(255);

ofEnableDepthTest();

}

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

void ofApp::update() {

ofSeedRandom(39);

}

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

void ofApp::draw() {

this->cam.begin();

ofRotateY(ofGetFrameNum() * 0.5);

int radius = 200;

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

vector<glm::vec3> vertices;

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

auto location = glm::vec3(

ofMap(ofNoise(seed.x, (ofGetFrameNum() + i) * 0.008), 0, 1, -1, 1),

ofMap(ofNoise(seed.y, (ofGetFrameNum() + i) * 0.008), 0, 1, -1, 1),

ofMap(ofNoise(seed.z, (ofGetFrameNum() + i) * 0.008), 0, 1, -1, 1)

);

location = glm::normalize(location) * radius;

vertices.push_back(location);

}

this->drawVertices(vertices);

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

ofRotateX(60);

ofRotateY(60);

ofRotateZ(60);

this->drawVertices(vertices);

}

this->cam.end();

}

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

void ofApp::drawVertices(vector<glm::vec3> vertices) {

ofNoFill();

ofBeginShape();

ofVertices(vertices);

ofEndShape();

ofFill();

ofDrawSphere(vertices.front(), 3);

ofDrawSphere(vertices.back(), 3);

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

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