Shader – ページ 4 – プログラミング de 落描き

2021年2月4日2021年2月4日

Rotating. Draw by openFrameworks

[ Video ]

[ About ]
Rotating.

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

	int number_of_targets;
	vector<glm::vec2> target_list;
	vector<glm::vec3> color_list;
	ofShader shader;

	bool calculate_angle(glm::vec2 location_1, float radius_1, glm::vec2 location_2, float radius_2, double& theta, double& a);
};

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

int number_of_targets;

vector<glm::vec2> target_list;

vector<glm::vec3> color_list;

ofShader shader;

bool calculate_angle(glm::vec2 location_1, float radius_1, glm::vec2 location_2, float radius_2, double& theta, double& a);

};

#include "ofApp.h"	

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

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

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

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

		this->target_list.push_back(glm::vec2());
		this->color_list.push_back(glm::vec3(1, 1, 1));
	}

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

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

	ofSeedRandom(39);


}

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

	auto noise_seed_deg = ofRandom(1000);
	auto noise_seed_radius = ofRandom(1000);

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

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

			auto noise_deg = deg + ofMap(ofNoise(noise_seed_deg, (ofGetFrameNum() + i) * 0.005), 0, 1, -360, 360);
			auto noise_radius = ofMap(ofNoise(noise_seed_radius, (ofGetFrameNum() + i) * 0.005), 0, 1, -350, 350);
			vertices.push_back(glm::vec2(360 + noise_radius * cos(noise_deg * DEG_TO_RAD), 360 + noise_radius * sin(noise_deg * DEG_TO_RAD)));
		}

		this->target_list[index++] = vertices.back();
		this->target_list[index++] = vertices.front();

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

	ofFill();
	this->shader.begin();
	this->shader.setUniform1f("time", ofGetElapsedTimef());
	this->shader.setUniform2f("resolution", ofGetWidth(), ofGetHeight());
	this->shader.setUniform2fv("targets", &this->target_list[0].x, this->number_of_targets);
	this->shader.setUniform3fv("colors", &this->color_list[0].x, this->number_of_targets);

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

	this->shader.end();
}

//--------------------------------------------------------------
bool ofApp::calculate_angle(glm::vec2 location_1, float radius_1, glm::vec2 location_2, float radius_2, double& theta, double& a) {

	auto distance = glm::distance(location_1, location_2);
	if (distance > radius_1 + radius_2 || distance < radius_1 - radius_2) { return false; }

	theta = atan2(location_2.y - location_1.y, location_2.x - location_1.x);
	auto cos_a = (pow(distance, 2) + pow(radius_1, 2) - pow(radius_2, 2)) / (2 * distance * radius_1);
	a = acos(cos_a);
	return true;
}

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

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openFrameworks");

ofBackground(0);

ofEnableBlendMode(ofBlendMode::OF_BLENDMODE_ADD);

ofSetCircleResolution(72);

this->number_of_targets = 40;

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

this->target_list.push_back(glm::vec2());

this->color_list.push_back(glm::vec3(1, 1, 1));

}

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

}

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

void ofApp::update() {

ofSeedRandom(39);

}

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

void ofApp::draw() {

auto noise_seed_deg = ofRandom(1000);

auto noise_seed_radius = ofRandom(1000);

int index = 0;

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

vector<glm::vec2> vertices;

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

auto noise_deg = deg + ofMap(ofNoise(noise_seed_deg, (ofGetFrameNum() + i) * 0.005), 0, 1, -360, 360);

auto noise_radius = ofMap(ofNoise(noise_seed_radius, (ofGetFrameNum() + i) * 0.005), 0, 1, -350, 350);

vertices.push_back(glm::vec2(360 + noise_radius * cos(noise_deg * DEG_TO_RAD), 360 + noise_radius * sin(noise_deg * DEG_TO_RAD)));

}

this->target_list[index++] = vertices.back();

this->target_list[index++] = vertices.front();

ofNoFill();

ofBeginShape();

ofVertices(vertices);

ofEndShape();

}

ofFill();

this->shader.begin();

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

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

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

this->shader.setUniform3fv("colors", &this->color_list[0].x, this->number_of_targets);

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

this->shader.end();

}

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

bool ofApp::calculate_angle(glm::vec2 location_1, float radius_1, glm::vec2 location_2, float radius_2, double& theta, double& a) {

auto distance = glm::distance(location_1, location_2);

if (distance > radius_1 + radius_2 || distance < radius_1 - radius_2) { return false; }

theta = atan2(location_2.y - location_1.y, location_2.x - location_1.x);

auto cos_a = (pow(distance, 2) + pow(radius_1, 2) - pow(radius_2, 2)) / (2 * distance * radius_1);

a = acos(cos_a);

return true;

}

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

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

uniform float time;
uniform vec2 resolution;
uniform vec2 targets[number_of_targets];
uniform vec3 colors[number_of_targets];

out vec4 outputColor;

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 v = 0.02 / length(p - t);
	float r = v * colors[i].x;
	float g = v * colors[i].y;
	float b = v * colors[i].z;
    vec3 c = vec3(smoothstep(0.05, 1.0, r), smoothstep(0.05, 1.0, g), smoothstep(0.05, 1.0, b));
    color += c;
  }

  outputColor = vec4(color, 1.0);
}

#version 150

const int number_of_targets = 40;

uniform float time;

uniform vec2 resolution;

uniform vec2 targets[number_of_targets];

uniform vec3 colors[number_of_targets];

out vec4 outputColor;

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 v = 0.02 / length(p - t);

float r = v * colors[i].x;

float g = v * colors[i].y;

float b = v * colors[i].z;

vec3 c = vec3(smoothstep(0.05, 1.0, r), smoothstep(0.05, 1.0, g), smoothstep(0.05, 1.0, b));

color += c;

}

outputColor = vec4(color, 1.0);

}

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2021年2月3日2021年2月3日

Rotating orbs. Draw by openFrameworks

[ Video ]

[ About ]
Rotating orbs.

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

	int number_of_targets;
	vector<glm::vec2> target_list;
	vector<glm::vec3> color_list;
	ofShader shader;

	bool calculate_angle(glm::vec2 location_1, float radius_1, glm::vec2 location_2, float radius_2, double& theta, double& a);
};

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

int number_of_targets;

vector<glm::vec2> target_list;

vector<glm::vec3> color_list;

ofShader shader;

bool calculate_angle(glm::vec2 location_1, float radius_1, glm::vec2 location_2, float radius_2, double& theta, double& a);

};

#include "ofApp.h"	

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

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

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

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

		this->target_list.push_back(glm::vec2());
		this->color_list.push_back(glm::vec3(1, 1, 1));
	}

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

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

	ofSeedRandom(39);

	int count = 0;
	int index = 0;
	int deg_start = ofGetFrameNum();
	for (int radius = 150; radius <= 300; radius += 15) {

		int deg_start = ofMap(ofNoise(radius * 0.005 + ofGetFrameNum() * 0.01), 0, 1, -180, 180);
		for (int deg = deg_start; deg < deg_start + 360; deg += 10) {

			this->target_list[index] = glm::vec2(360 + radius * cos(deg * DEG_TO_RAD), 360 + radius * sin(deg * DEG_TO_RAD));

			this->color_list[index] = glm::vec3(
				ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.05), 0, 1, 0.5, 1), 
				ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.05), 0, 1, 0.5, 1), 
				ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.05), 0, 1, 0.5, 1));

			index++;
		}
	}
}

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

	ofFill();
	this->shader.begin();
	this->shader.setUniform1f("time", ofGetElapsedTimef());
	this->shader.setUniform2f("resolution", ofGetWidth(), ofGetHeight());
	this->shader.setUniform2fv("targets", &this->target_list[0].x, this->number_of_targets);
	this->shader.setUniform3fv("colors", &this->color_list[0].x, this->number_of_targets);

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

	this->shader.end();
}

//--------------------------------------------------------------
bool ofApp::calculate_angle(glm::vec2 location_1, float radius_1, glm::vec2 location_2, float radius_2, double& theta, double& a) {

	auto distance = glm::distance(location_1, location_2);
	if (distance > radius_1 + radius_2 || distance < radius_1 - radius_2) { return false; }

	theta = atan2(location_2.y - location_1.y, location_2.x - location_1.x);
	auto cos_a = (pow(distance, 2) + pow(radius_1, 2) - pow(radius_2, 2)) / (2 * distance * radius_1);
	a = acos(cos_a);
	return true;
}

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

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openFrameworks");

ofBackground(0);

ofEnableBlendMode(ofBlendMode::OF_BLENDMODE_ADD);

ofSetCircleResolution(72);

this->number_of_targets = 360;

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

this->target_list.push_back(glm::vec2());

this->color_list.push_back(glm::vec3(1, 1, 1));

}

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

}

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

void ofApp::update() {

ofSeedRandom(39);

int count = 0;

int index = 0;

int deg_start = ofGetFrameNum();

for (int radius = 150; radius <= 300; radius += 15) {

int deg_start = ofMap(ofNoise(radius * 0.005 + ofGetFrameNum() * 0.01), 0, 1, -180, 180);

for (int deg = deg_start; deg < deg_start + 360; deg += 10) {

this->target_list[index] = glm::vec2(360 + radius * cos(deg * DEG_TO_RAD), 360 + radius * sin(deg * DEG_TO_RAD));

this->color_list[index] = glm::vec3(

ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.05), 0, 1, 0.5, 1),

ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.05), 0, 1, 0.5, 1));

index++;

}

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

void ofApp::draw() {

ofFill();

this->shader.begin();

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

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

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

this->shader.setUniform3fv("colors", &this->color_list[0].x, this->number_of_targets);

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

this->shader.end();

}

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

bool ofApp::calculate_angle(glm::vec2 location_1, float radius_1, glm::vec2 location_2, float radius_2, double& theta, double& a) {

auto distance = glm::distance(location_1, location_2);

if (distance > radius_1 + radius_2 || distance < radius_1 - radius_2) { return false; }

theta = atan2(location_2.y - location_1.y, location_2.x - location_1.x);

auto cos_a = (pow(distance, 2) + pow(radius_1, 2) - pow(radius_2, 2)) / (2 * distance * radius_1);

a = acos(cos_a);

return true;

}

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

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

uniform float time;
uniform vec2 resolution;
uniform vec2 targets[number_of_targets];
uniform vec3 colors[number_of_targets];

out vec4 outputColor;

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 v = 0.015 / length(p - t);
	float r = v * colors[i].x;
	float g = v * colors[i].y;
	float b = v * colors[i].z;
    vec3 c = vec3(smoothstep(0.05, 1.0, r), smoothstep(0.05, 1.0, g), smoothstep(0.05, 1.0, b));
    color += c;
  }

  outputColor = vec4(color, 1.0);
}

#version 150

const int number_of_targets = 360;

uniform float time;

uniform vec2 resolution;

uniform vec2 targets[number_of_targets];

uniform vec3 colors[number_of_targets];

out vec4 outputColor;

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 v = 0.015 / length(p - t);

float r = v * colors[i].x;

float g = v * colors[i].y;

float b = v * colors[i].z;

vec3 c = vec3(smoothstep(0.05, 1.0, r), smoothstep(0.05, 1.0, g), smoothstep(0.05, 1.0, b));

color += c;

}

outputColor = vec4(color, 1.0);

}

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2021年2月1日2021年2月1日

Orb and child orb. Draw by openFrameworks

[ Video ]

[ About ]
Orb and child orb.

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

	int number_of_targets;
	vector<glm::vec2> target_list;
	vector<glm::vec3> color_list;
	ofShader shader;

	float noise_seed;
};

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

int number_of_targets;

vector<glm::vec2> target_list;

vector<glm::vec3> color_list;

ofShader shader;

float noise_seed;

};

#include "ofApp.h"

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

	ofSetFrameRate(60);
	ofSetWindowTitle("openframeworks");
	
	ofBackground(0);
	ofEnableBlendMode(ofBlendMode::OF_BLENDMODE_ADD);

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

		this->target_list.push_back(glm::vec2());
		this->color_list.push_back(glm::vec3());
	}

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

	ofSeedRandom(39);

	if (ofGetFrameNum() % 60 < 45) {

		this->noise_seed += ofMap(ofGetFrameNum() % 60, 0, 45, 0.04, 0);
	}
}

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

	int range = 100;
	int radius = 20;
	for (int i = 0; i < this->number_of_targets; i += 4) {

		int x = (i / 4) % 5 * 144 + 72;
		int y = (i / 4) / 5 * 144 + 72;

		this->target_list[i] = glm::vec2(x + ofMap(ofNoise(ofRandom(1000), this->noise_seed), 0, 1, range * -0.5, range * 0.5), y + ofMap(ofNoise(ofRandom(1000), this->noise_seed), 0, 1, range * -0.5, range * 0.5));

		auto r_location = glm::vec2(x + ofMap(ofNoise(ofRandom(1000), this->noise_seed), 0, 1, range * -0.5, range * 0.5), y + ofMap(ofNoise(ofRandom(1000), this->noise_seed), 0, 1, range * -0.5, range * 0.5));
		auto g_location = glm::vec2(x + ofMap(ofNoise(ofRandom(1000), this->noise_seed), 0, 1, range * -0.5, range * 0.5), y + ofMap(ofNoise(ofRandom(1000), this->noise_seed), 0, 1, range * -0.5, range * 0.5));
		auto b_location = glm::vec2(x + ofMap(ofNoise(ofRandom(1000), this->noise_seed), 0, 1, range * -0.5, range * 0.5), y + ofMap(ofNoise(ofRandom(1000), this->noise_seed), 0, 1, range * -0.5, range * 0.5));

		auto r = ofMap(distance(this->target_list[i], r_location), 0, range, 1, 0.1);
		auto g = ofMap(distance(this->target_list[i], g_location), 0, range, 1, 0.1);
		auto b = ofMap(distance(this->target_list[i], b_location), 0, range, 1, 0.1);
		this->color_list[i] = glm::vec3(r, g, b);

		this->target_list[i + 1] = r_location;
		this->color_list[i + 1] = glm::vec3(0.3, 0.2, 0.2);
		this->target_list[i + 2] = g_location;
		this->color_list[i + 2] = glm::vec3(0.2, 0.3, 0.2);
		this->target_list[i + 3] = b_location;
		this->color_list[i + 3] = glm::vec3(0.2, 0.2, 0.3);

		ofSetColor(this->color_list[i].x * 255, this->color_list[i].y * 255, this->color_list[i].z * 255);

		auto r_angle = std::atan2(r_location.y - this->target_list[i].y, r_location.x - this->target_list[i].x);
		auto r_line_location = this->target_list[i] + glm::vec2(radius * cos(r_angle), radius * sin(r_angle));
		ofDrawLine(r_location, r_line_location);

		auto g_angle = std::atan2(g_location.y - this->target_list[i].y, g_location.x - this->target_list[i].x);
		auto g_line_location = this->target_list[i] + glm::vec2(radius * cos(g_angle), radius * sin(g_angle));
		ofDrawLine(g_location, g_line_location);

		auto b_angle = std::atan2(b_location.y - this->target_list[i].y, b_location.x - this->target_list[i].x);
		auto b_line_location = this->target_list[i] + glm::vec2(radius * cos(b_angle), radius * sin(b_angle));
		ofDrawLine(b_location, b_line_location);
	}

	ofFill();
	this->shader.begin();
	this->shader.setUniform1f("time", ofGetElapsedTimef());
	this->shader.setUniform2f("resolution", ofGetWidth(), ofGetHeight());
	this->shader.setUniform2fv("targets", &this->target_list[0].x, this->number_of_targets);
	this->shader.setUniform3fv("colors", &this->color_list[0].x, this->number_of_targets);

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

	this->shader.end();

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

		if (i % 4 == 0) {

			ofSetColor(this->color_list[i].x * 255, this->color_list[i].y * 255, this->color_list[i].z * 255);

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

				ofVertex(this->target_list[i] + glm::vec2(radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD)));
			}
			for (int deg = 360; deg >= 0; deg -= 1) {

				ofVertex(this->target_list[i] + glm::vec2((radius + 1) * cos(deg * DEG_TO_RAD), (radius + 1) * sin(deg * DEG_TO_RAD)));
			}
			ofEndShape(true);
		}
	}
}

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

114

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openframeworks");

ofBackground(0);

ofEnableBlendMode(ofBlendMode::OF_BLENDMODE_ADD);

this->number_of_targets = 4 * 5 * 5;

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

this->target_list.push_back(glm::vec2());

this->color_list.push_back(glm::vec3());

}

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

}

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

void ofApp::update() {

ofSeedRandom(39);

if (ofGetFrameNum() % 60 < 45) {

this->noise_seed += ofMap(ofGetFrameNum() % 60, 0, 45, 0.04, 0);

}

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

void ofApp::draw() {

int range = 100;

int radius = 20;

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

int x = (i / 4) % 5 * 144 + 72;

int y = (i / 4) / 5 * 144 + 72;

this->target_list[i] = glm::vec2(x + ofMap(ofNoise(ofRandom(1000), this->noise_seed), 0, 1, range * -0.5, range * 0.5), y + ofMap(ofNoise(ofRandom(1000), this->noise_seed), 0, 1, range * -0.5, range * 0.5));

auto r_location = glm::vec2(x + ofMap(ofNoise(ofRandom(1000), this->noise_seed), 0, 1, range * -0.5, range * 0.5), y + ofMap(ofNoise(ofRandom(1000), this->noise_seed), 0, 1, range * -0.5, range * 0.5));

auto g_location = glm::vec2(x + ofMap(ofNoise(ofRandom(1000), this->noise_seed), 0, 1, range * -0.5, range * 0.5), y + ofMap(ofNoise(ofRandom(1000), this->noise_seed), 0, 1, range * -0.5, range * 0.5));

auto b_location = glm::vec2(x + ofMap(ofNoise(ofRandom(1000), this->noise_seed), 0, 1, range * -0.5, range * 0.5), y + ofMap(ofNoise(ofRandom(1000), this->noise_seed), 0, 1, range * -0.5, range * 0.5));

auto r = ofMap(distance(this->target_list[i], r_location), 0, range, 1, 0.1);

auto g = ofMap(distance(this->target_list[i], g_location), 0, range, 1, 0.1);

auto b = ofMap(distance(this->target_list[i], b_location), 0, range, 1, 0.1);

this->color_list[i] = glm::vec3(r, g, b);

this->target_list[i + 1] = r_location;

this->color_list[i + 1] = glm::vec3(0.3, 0.2, 0.2);

this->target_list[i + 2] = g_location;

this->color_list[i + 2] = glm::vec3(0.2, 0.3, 0.2);

this->target_list[i + 3] = b_location;

this->color_list[i + 3] = glm::vec3(0.2, 0.2, 0.3);

ofSetColor(this->color_list[i].x * 255, this->color_list[i].y * 255, this->color_list[i].z * 255);

auto r_angle = std::atan2(r_location.y - this->target_list[i].y, r_location.x - this->target_list[i].x);

auto r_line_location = this->target_list[i] + glm::vec2(radius * cos(r_angle), radius * sin(r_angle));

ofDrawLine(r_location, r_line_location);

auto g_angle = std::atan2(g_location.y - this->target_list[i].y, g_location.x - this->target_list[i].x);

auto g_line_location = this->target_list[i] + glm::vec2(radius * cos(g_angle), radius * sin(g_angle));

ofDrawLine(g_location, g_line_location);

auto b_angle = std::atan2(b_location.y - this->target_list[i].y, b_location.x - this->target_list[i].x);

auto b_line_location = this->target_list[i] + glm::vec2(radius * cos(b_angle), radius * sin(b_angle));

ofDrawLine(b_location, b_line_location);

}

ofFill();

this->shader.begin();

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

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

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

this->shader.setUniform3fv("colors", &this->color_list[0].x, this->number_of_targets);

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

this->shader.end();

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

if (i % 4 == 0) {

ofSetColor(this->color_list[i].x * 255, this->color_list[i].y * 255, this->color_list[i].z * 255);

ofBeginShape();

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

ofVertex(this->target_list[i] + glm::vec2(radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD)));

}

for (int deg = 360; deg >= 0; deg -= 1) {

ofVertex(this->target_list[i] + glm::vec2((radius + 1) * cos(deg * DEG_TO_RAD), (radius + 1) * sin(deg * DEG_TO_RAD)));

}

ofEndShape(true);

}

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

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 vec3 colors[number_of_targets];

out vec4 outputColor;

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 v = 0.025 / length(p - t);
	float r = v * colors[i].x;
	float g = v * colors[i].y;
	float b = v * colors[i].z;
    vec3 c = vec3(smoothstep(0.05, 1.0, r), smoothstep(0.05, 1.0, g), smoothstep(0.05, 1.0, b));
    color += c;
  }

  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 vec3 colors[number_of_targets];

out vec4 outputColor;

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 v = 0.025 / length(p - t);

float r = v * colors[i].x;

float g = v * colors[i].y;

float b = v * colors[i].z;

vec3 c = vec3(smoothstep(0.05, 1.0, r), smoothstep(0.05, 1.0, g), smoothstep(0.05, 1.0, b));

color += c;

}

outputColor = vec4(color, 1.0);

}

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

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