circle – ページ 76 – プログラミング de 落描き

2020年2月19日2020年2月19日

Planet rings. openFrameworks

[ Video ]

[ About ]
惑星の環。

Planet rings.

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

	ofEasyCam cam;
	ofMesh face, frame;
};

#pragma once

#include "ofMain.h"

class ofApp : public ofBaseApp {

public:

void setup();

void update();

void draw();

void keyPressed(int key) {};

void keyReleased(int key) {};

void mouseMoved(int x, int y) {};

void mouseDragged(int x, int y, int button) {};

void mousePressed(int x, int y, int button) {};

void mouseReleased(int x, int y, int button) {};

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

ofEasyCam cam;

ofMesh face, frame;

};

#include "ofApp.h"

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

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

	ofBackground(239);
	ofEnableDepthTest();

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

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

	for (auto radius = 200; radius < 500; radius += 20) {

		this->setRingToMesh(this->face, this->frame, glm::vec3(), radius, 20, 10);
	}
}

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

	this->cam.begin();

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

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

	this->cam.end();
}

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

	auto noise_seed = glm::vec3(ofRandom(1000), ofRandom(1000), ofRandom(1000));
	auto noise_value = glm::vec3(ofNoise(noise_seed.x, ofGetFrameNum() * 0.001), ofNoise(noise_seed.y, ofGetFrameNum() * 0.001), ofNoise(noise_seed.z, ofGetFrameNum() * 0.003));

	noise_value.z = noise_value.z < 0.4 ? ofMap(noise_value.z, 0, 0.4, 1, 0) : 0;

	auto angle_x = ofMap(noise_value.x * noise_value.z, 0, 1, -PI, PI);
	auto angle_y = ofMap(noise_value.y * noise_value.z, 0, 1, -PI, PI);

	auto rotation_x = glm::rotate(glm::mat4(), angle_x, glm::vec3(1, 0, 0));
	auto rotation_y = glm::rotate(glm::mat4(), angle_y, glm::vec3(0, 1, 0));

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

		auto face_index = face_target.getNumVertices();

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

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

		for (auto& vertex : vertices) {

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

		face_target.addVertices(vertices);

		face_target.addIndex(face_index + 0); face_target.addIndex(face_index + 1); face_target.addIndex(face_index + 2);
		face_target.addIndex(face_index + 0); face_target.addIndex(face_index + 2); face_target.addIndex(face_index + 3);

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

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

		auto frame_index = frame_target.getNumVertices();

		frame_target.addVertices(vertices);

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

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

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

100

101

102

103

104

105

106

107

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openframeworks");

ofBackground(239);

ofEnableDepthTest();

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

}

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

void ofApp::update() {

ofSeedRandom(39);

this->face.clear();

this->frame.clear();

for (auto radius = 200; radius < 500; radius += 20) {

this->setRingToMesh(this->face, this->frame, glm::vec3(), radius, 20, 10);

}

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

void ofApp::draw() {

this->cam.begin();

ofSetColor(39);

ofDrawSphere(150);

this->face.draw();

ofSetColor(239);

this->frame.drawWireframe();

this->cam.end();

}

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

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

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

auto noise_value = glm::vec3(ofNoise(noise_seed.x, ofGetFrameNum() * 0.001), ofNoise(noise_seed.y, ofGetFrameNum() * 0.001), ofNoise(noise_seed.z, ofGetFrameNum() * 0.003));

noise_value.z = noise_value.z < 0.4 ? ofMap(noise_value.z, 0, 0.4, 1, 0) : 0;

auto angle_x = ofMap(noise_value.x * noise_value.z, 0, 1, -PI, PI);

auto angle_y = ofMap(noise_value.y * noise_value.z, 0, 1, -PI, PI);

auto rotation_x = glm::rotate(glm::mat4(), angle_x, glm::vec3(1, 0, 0));

auto rotation_y = glm::rotate(glm::mat4(), angle_y, glm::vec3(0, 1, 0));

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

auto face_index = face_target.getNumVertices();

vector<glm::vec3> vertices;

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

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

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

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

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

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

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

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

for (auto& vertex : vertices) {

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

}

face_target.addVertices(vertices);

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

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

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

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

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

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

auto frame_index = frame_target.getNumVertices();

frame_target.addVertices(vertices);

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

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

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

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

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

2020年2月11日2020年2月11日

Loop line. openframeworks

[ Video ]

[ About ]
環状線。

Loop line.

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

	ofEasyCam cam;
	ofMesh face, frame;
};

#pragma once

#include "ofMain.h"

class ofApp : public ofBaseApp {

public:

void setup();

void update();

void draw();

void keyPressed(int key) {};

void keyReleased(int key) {};

void mouseMoved(int x, int y) {};

void mouseDragged(int x, int y, int button) {};

void mousePressed(int x, int y, int button) {};

void mouseReleased(int x, int y, int button) {};

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

ofEasyCam cam;

ofMesh face, frame;

};

#include "ofApp.h"	

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

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

	ofBackground(239);
	ofEnableDepthTest();
	ofSetLineWidth(3);

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

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

	ofSeedRandom(39);

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

	auto radius_min = 50;
	auto radius_max = 200;
	auto radius_span = 10;
	auto len = 360;

	for (auto radius = radius_min; radius < radius_max; radius += radius_span) {

		auto start_deg = ofGetFrameNum() * ofRandom(3, 5) + ofRandom(720);
		int start_index = this->face.getNumVertices();
		vector<glm::vec3> vertices;
		for (int deg = start_deg; deg < start_deg + len; deg += 1) {

			auto param = deg % 720;
			auto z = 0;
			if (param < 360) {

				z = param < 180 ? ofMap(param, 0, 180, -30, -20) : ofMap(param, 180, 360, -20, 30);

				vertices.push_back(glm::vec3(radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD), z) + glm::vec3((radius_min + radius_max) * -0.5, 0, 0));
				vertices.push_back(glm::vec3((radius + radius_span) * cos(deg * DEG_TO_RAD), (radius + radius_span) * sin(deg * DEG_TO_RAD), z) + glm::vec3((radius_min + radius_max) * -0.5, 0, 0));
			}
			else {

				z = param < 540 ? ofMap(param, 360, 540, 30, 20) : ofMap(param, 540, 720, 20, -30);

				int tmp_radius = ofMap(radius, radius_min, radius_max, radius_max, radius_min);
				vertices.push_back(glm::vec3(-1 * tmp_radius * cos(deg * DEG_TO_RAD), tmp_radius * sin(deg * DEG_TO_RAD), z) + glm::vec3((radius_min + radius_max) * 0.5, 0, 0));
				vertices.push_back(glm::vec3(-1 * (tmp_radius - radius_span) * cos(deg * DEG_TO_RAD), (tmp_radius - radius_span) * sin(deg * DEG_TO_RAD), z) + glm::vec3((radius_min + radius_max) * 0.5, 0, 0));
			}
		}

		this->face.addVertices(vertices);
		this->frame.addVertices(vertices);

		for (int i = start_index; i < this->face.getNumVertices() - 4; i += 2) {

			this->face.addIndex(i + 0); this->face.addIndex(i + 2); this->face.addIndex(i + 3);
			this->face.addIndex(i + 0); this->face.addIndex(i + 3); this->face.addIndex(i + 1);

			this->frame.addIndex(i + 0); this->frame.addIndex(i + 2);
			this->frame.addIndex(i + 1); this->frame.addIndex(i + 3);
		}

		this->face.addIndex(this->frame.getNumVertices() - 4); this->face.addIndex(this->face.getNumVertices() - 2); this->face.addIndex(this->face.getNumVertices() - 1);
		this->face.addIndex(this->frame.getNumVertices() - 4); this->face.addIndex(this->face.getNumVertices() - 1); this->face.addIndex(this->face.getNumVertices() - 3);

		this->frame.addIndex(this->frame.getNumVertices() - 4); this->frame.addIndex(this->frame.getNumVertices() - 2);
		this->frame.addIndex(this->frame.getNumVertices() - 3); this->frame.addIndex(this->frame.getNumVertices() - 1);

		this->frame.addIndex(start_index + 0); this->frame.addIndex(start_index + 1);
		this->frame.addIndex(this->frame.getNumVertices() - 1); this->frame.addIndex(this->frame.getNumVertices() - 2);
	}
}

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

	this->cam.begin();

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

	ofSetColor(39);
	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(239);

ofEnableDepthTest();

ofSetLineWidth(3);

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

}

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

void ofApp::update() {

ofSeedRandom(39);

this->face.clear();

this->frame.clear();

auto radius_min = 50;

auto radius_max = 200;

auto radius_span = 10;

auto len = 360;

for (auto radius = radius_min; radius < radius_max; radius += radius_span) {

auto start_deg = ofGetFrameNum() * ofRandom(3, 5) + ofRandom(720);

int start_index = this->face.getNumVertices();

vector<glm::vec3> vertices;

for (int deg = start_deg; deg < start_deg + len; deg += 1) {

auto param = deg % 720;

auto z = 0;

if (param < 360) {

z = param < 180 ? ofMap(param, 0, 180, -30, -20) : ofMap(param, 180, 360, -20, 30);

vertices.push_back(glm::vec3(radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD), z) + glm::vec3((radius_min + radius_max) * -0.5, 0, 0));

vertices.push_back(glm::vec3((radius + radius_span) * cos(deg * DEG_TO_RAD), (radius + radius_span) * sin(deg * DEG_TO_RAD), z) + glm::vec3((radius_min + radius_max) * -0.5, 0, 0));

}

else {

z = param < 540 ? ofMap(param, 360, 540, 30, 20) : ofMap(param, 540, 720, 20, -30);

int tmp_radius = ofMap(radius, radius_min, radius_max, radius_max, radius_min);

vertices.push_back(glm::vec3(-1 * tmp_radius * cos(deg * DEG_TO_RAD), tmp_radius * sin(deg * DEG_TO_RAD), z) + glm::vec3((radius_min + radius_max) * 0.5, 0, 0));

vertices.push_back(glm::vec3(-1 * (tmp_radius - radius_span) * cos(deg * DEG_TO_RAD), (tmp_radius - radius_span) * sin(deg * DEG_TO_RAD), z) + glm::vec3((radius_min + radius_max) * 0.5, 0, 0));

}

this->face.addVertices(vertices);

this->frame.addVertices(vertices);

for (int i = start_index; i < this->face.getNumVertices() - 4; i += 2) {

this->face.addIndex(i + 0); this->face.addIndex(i + 2); this->face.addIndex(i + 3);

this->face.addIndex(i + 0); this->face.addIndex(i + 3); this->face.addIndex(i + 1);

this->frame.addIndex(i + 0); this->frame.addIndex(i + 2);

this->frame.addIndex(i + 1); this->frame.addIndex(i + 3);

}

this->face.addIndex(this->frame.getNumVertices() - 4); this->face.addIndex(this->face.getNumVertices() - 2); this->face.addIndex(this->face.getNumVertices() - 1);

this->face.addIndex(this->frame.getNumVertices() - 4); this->face.addIndex(this->face.getNumVertices() - 1); this->face.addIndex(this->face.getNumVertices() - 3);

this->frame.addIndex(this->frame.getNumVertices() - 4); this->frame.addIndex(this->frame.getNumVertices() - 2);

this->frame.addIndex(this->frame.getNumVertices() - 3); this->frame.addIndex(this->frame.getNumVertices() - 1);

this->frame.addIndex(start_index + 0); this->frame.addIndex(start_index + 1);

this->frame.addIndex(this->frame.getNumVertices() - 1); this->frame.addIndex(this->frame.getNumVertices() - 2);

}

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

void ofApp::draw() {

this->cam.begin();

ofSetColor(239);

this->face.draw();

ofSetColor(39);

this->frame.drawWireframe();

this->cam.end();

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

2020年2月9日

From Reona396 workshop. openFrameworks

[ Video ]

[ About ]
PCD Tokyo 2020 のレオナさん・ワークショップより(アシスタント版)

From Reona396 workshop on PCD Tokyo 2020.

[ Source ]

#pragma once
#include "ofMain.h"

class ofApp : public ofBaseApp {

public:
	void setup();
	void update();
	void draw();

	void keyPressed(int key) {};
	void keyReleased(int key) {};
	void mouseMoved(int x, int y) {};
	void mouseDragged(int x, int y, int button) {};
	void mousePressed(int x, int y, int button) {};
	void mouseReleased(int x, int y, int button) {};
	void mouseEntered(int x, int y) {};
	void mouseExited(int x, int y) {};
	void windowResized(int w, int h) {};
	void dragEvent(ofDragInfo dragInfo) {};
	void gotMessage(ofMessage msg) {};

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

	ofShader shader;
	ofFbo fbo;
};

#pragma once

#include "ofMain.h"

class ofApp : public ofBaseApp {

public:

void setup();

void update();

void draw();

void keyPressed(int key) {};

void keyReleased(int key) {};

void mouseMoved(int x, int y) {};

void mouseDragged(int x, int y, int button) {};

void mousePressed(int x, int y, int button) {};

void mouseReleased(int x, int y, int button) {};

void mouseEntered(int x, int y) {};

void mouseExited(int x, int y) {};

void windowResized(int w, int h) {};

void dragEvent(ofDragInfo dragInfo) {};

void gotMessage(ofMessage msg) {};

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

ofShader shader;

ofFbo fbo;

};

#include "ofApp.h"

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

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

	ofBackground(255);
	ofSetColor(0);

	this->shader.load("shader/shader.vert", "shader/shader.frag");
	this->fbo.allocate(ofGetWidth(), ofGetHeight());
}
//--------------------------------------------------------------
void ofApp::update() {

	this->fbo.begin();
	ofClear(0);

	vector<glm::vec2> right, left;
	for (auto param = 0; param <= 50; param++) {

		auto noise_value = ofNoise(param * 0.08, ofGetFrameNum() * 0.005);

		if (noise_value < 0.65) {

			right.push_back(this->make_point(720, param) + glm::vec2(ofGetWidth() * 0.5, ofGetHeight() * 0.5));
			left.push_back(this->make_point(720, 100 - param) + glm::vec2(ofGetWidth() * 0.5, ofGetHeight() * 0.5));
		}
		else {

			if (right.size() > 0 && left.size() > 0) {

				reverse(left.begin(), left.end());
				ofBeginShape();
				ofVertices(right);
				ofVertices(left);
				ofEndShape(true);

				right.clear();
				left.clear();
			}
		}
	}

	if (right.size() > 0 && left.size() > 0) {

		reverse(left.begin(), left.end());
		ofBeginShape();
		ofVertices(right);
		ofVertices(left);
		ofEndShape(true);
	}

	this->fbo.end();
}

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

	vector<glm::vec2> targets;
	for (int i = 0; i < 100; i++) {

		float R = 180 + 90 * abs(sin((i * 100 + ofGetFrameNum() + i) * DEG_TO_RAD));
		float x = R * cos((360 * i / 100 + ofGetFrameNum() * 0.15) * DEG_TO_RAD);
		float y = R * sin((360 * i / 100 + ofGetFrameNum() * 0.15) * DEG_TO_RAD);

		targets.push_back(glm::vec2(x, y) + glm::vec2(ofGetWidth() * 0.5, ofGetHeight() * 0.5));
	}

	this->shader.begin();
	this->shader.setUniform1f("time", ofGetElapsedTimef());
	this->shader.setUniform2f("resolution", ofGetWidth(), ofGetHeight());
	this->shader.setUniform2fv("targets", &targets[0].x, targets.size());
	this->shader.setUniformTexture("tex", this->fbo.getTexture(), 1);

	ofDrawRectangle(0, 0, ofGetWidth(), ofGetHeight());

	this->shader.end();
}

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

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

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

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

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

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

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

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

100

101

102

103

104

105

106

107

108

109

110

111

112

113

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openframeworks");

ofBackground(255);

ofSetColor(0);

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

this->fbo.allocate(ofGetWidth(), ofGetHeight());

}

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

void ofApp::update() {

this->fbo.begin();

ofClear(0);

vector<glm::vec2> right, left;

for (auto param = 0; param <= 50; param++) {

auto noise_value = ofNoise(param * 0.08, ofGetFrameNum() * 0.005);

if (noise_value < 0.65) {

right.push_back(this->make_point(720, param) + glm::vec2(ofGetWidth() * 0.5, ofGetHeight() * 0.5));

left.push_back(this->make_point(720, 100 - param) + glm::vec2(ofGetWidth() * 0.5, ofGetHeight() * 0.5));

}

else {

if (right.size() > 0 && left.size() > 0) {

reverse(left.begin(), left.end());

ofBeginShape();

ofVertices(right);

ofVertices(left);

ofEndShape(true);

right.clear();

left.clear();

}

if (right.size() > 0 && left.size() > 0) {

reverse(left.begin(), left.end());

ofBeginShape();

ofVertices(right);

ofVertices(left);

ofEndShape(true);

}

this->fbo.end();

}

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

void ofApp::draw() {

vector<glm::vec2> targets;

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

float R = 180 + 90 * abs(sin((i * 100 + ofGetFrameNum() + i) * DEG_TO_RAD));

float x = R * cos((360 * i / 100 + ofGetFrameNum() * 0.15) * DEG_TO_RAD);

float y = R * sin((360 * i / 100 + ofGetFrameNum() * 0.15) * DEG_TO_RAD);

targets.push_back(glm::vec2(x, y) + glm::vec2(ofGetWidth() * 0.5, ofGetHeight() * 0.5));

}

this->shader.begin();

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

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

this->shader.setUniform2fv("targets", &targets[0].x, targets.size());

this->shader.setUniformTexture("tex", this->fbo.getTexture(), 1);

ofDrawRectangle(0, 0, ofGetWidth(), ofGetHeight());

this->shader.end();

}

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

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

param = param % 100;

if (param < 25) {

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

}

else if (param < 50) {

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

}

else if (param < 75) {

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

}

else {

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

}

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

int main() {

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 = 100;

uniform float time;
uniform vec2 resolution;
uniform vec2 targets[number_of_targets];
uniform sampler2DRect tex;

out vec4 outputColor;

void main() {

  vec2 p = (gl_FragCoord.xy * 2.0 - resolution) / min(resolution.x, resolution.y);
  vec4 tx = texture(tex, vec2(gl_FragCoord.x, resolution.y - gl_FragCoord.y));
  vec3 color = vec3(1.0 - tx.a);
 
  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);

	vec3 v = vec3(smoothstep(0.05, 1.0, 0.0165 / length(p - t)));
	color += ((tx.a == 0) ? -v : v);
  }

  outputColor = vec4(color, 1.0);
}

#version 150

const int number_of_targets = 100;

uniform float time;

uniform vec2 resolution;

uniform vec2 targets[number_of_targets];

uniform sampler2DRect tex;

out vec4 outputColor;

void main() {

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

vec4 tx = texture(tex, vec2(gl_FragCoord.x, resolution.y - gl_FragCoord.y));

vec3 color = vec3(1.0 - tx.a);

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

vec3 v = vec3(smoothstep(0.05, 1.0, 0.0165 / length(p - t)));

color += ((tx.a == 0) ? -v : v);

}

outputColor = vec4(color, 1.0);

}

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

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