2024年9月 – ページ 4 – プログラミング de 落描き

2024年9月21日

Round trip.

[ Video ]

[ About ]
周遊。

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

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

};

#include "ofApp.h"

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

	ofSetFrameRate(25);
	ofSetWindowTitle("openframeworks");

	ofBackground(39);
	ofSetLineWidth(2);

	ofEnableBlendMode(ofBlendMode::OF_BLENDMODE_ADD);
}

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

	ofSeedRandom(39);
}

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

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

	auto noise_seed = glm::vec2(ofRandom(1000), ofRandom(1000));
	int count = 120;
	for (int k = 0; k < count; k++) {

		ofMesh mesh;
		vector<glm::vec3> right, left, frame;

		glm::vec3 last_location;
		float last_theta;

		float random = ofRandom(1000);
		float deg = ofRandom(360);
		float span = ofRandom(0.01, 0.08);
		float head_size = 2;
		int len = 30;
		for (int i = 0; i < len; i++) {

			auto radius = ofMap(sin((random + ofGetFrameNum() + i) * span), 0, 1, 280, 320);
			auto next_radius = ofMap(sin((random + ofGetFrameNum() + i + 1) * span), 0, 1, 280, 320);

			auto location = glm::vec3(radius * cos((ofGetFrameNum() + i + deg) * DEG_TO_RAD), radius * sin((ofGetFrameNum() + i + deg) * DEG_TO_RAD), 0);
			auto next = glm::vec3(next_radius * cos((ofGetFrameNum() + i + 1 + deg) * DEG_TO_RAD), next_radius * sin((ofGetFrameNum() + i + 1 + deg) * DEG_TO_RAD), 0);

			auto direction = next - location;
			auto theta = atan2(direction.y, direction.x);

			right.push_back(location + glm::vec3(ofMap(i, 0, len, 0, head_size) * cos(theta + PI * 0.5), ofMap(i, 0, len, 0, head_size) * sin(theta + PI * 0.5), 0));
			left.push_back(location + glm::vec3(ofMap(i, 0, len, 0, head_size) * cos(theta - PI * 0.5), ofMap(i, 0, len, 0, head_size) * sin(theta - PI * 0.5), 0));

			last_location = location;
			last_theta = theta;
		}

		for (int i = 0; i < right.size(); i++) {

			mesh.addVertex(left[i]);
			mesh.addVertex(right[i]);
		}


		for (int i = 0; i < mesh.getNumVertices() - 2; i += 2) {

			mesh.addIndex(i + 0); mesh.addIndex(i + 1); mesh.addIndex(i + 3);
			mesh.addIndex(i + 0); mesh.addIndex(i + 2); mesh.addIndex(i + 3);
		}

		mesh.addVertex(last_location);
		int index = mesh.getNumVertices();
		for (auto theta = last_theta - PI * 0.5; theta <= last_theta + PI * 0.5; theta += PI / 20) {

			mesh.addVertex(last_location + glm::vec3(head_size * cos(theta), head_size * sin(theta), 0));
			frame.push_back(last_location + glm::vec3(head_size * cos(theta), head_size * sin(theta), 0));
		}

		for (int i = index; i < mesh.getNumVertices() - 1; i++) {

			mesh.addIndex(index); mesh.addIndex(i + 0); mesh.addIndex(i + 1);
		}

		ofColor color;
		color.setHsb(ofMap(k, 0, count, 0, 255), 180, 255);

		ofSetColor(color);
		ofNoFill();
		ofBeginShape();
		ofVertices(frame);
		std::reverse(right.begin(), right.end());
		ofVertices(right);
		ofVertices(left);
		ofEndShape(true);

		ofSetColor(ofColor(color, 168));
		mesh.draw();
	}

	/*
	int start = 50;
	if (ofGetFrameNum() > start) {

		ostringstream os;
		os << setw(4) << setfill('0') << ofGetFrameNum() - start;
		ofImage image;
		image.grabScreen(0, 0, ofGetWidth(), ofGetHeight());
		image.saveImage("image/cap/img_" + os.str() + ".jpg");
		if (ofGetFrameNum() - start >= 25 * 20) {

			std::exit(1);
		}
	}
	*/
}

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(25);

ofSetWindowTitle("openframeworks");

ofBackground(39);

ofSetLineWidth(2);

ofEnableBlendMode(ofBlendMode::OF_BLENDMODE_ADD);

}

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

void ofApp::update() {

ofSeedRandom(39);

}

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

void ofApp::draw() {

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

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

int count = 120;

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

ofMesh mesh;

vector<glm::vec3> right, left, frame;

glm::vec3 last_location;

float last_theta;

float random = ofRandom(1000);

float deg = ofRandom(360);

float span = ofRandom(0.01, 0.08);

float head_size = 2;

int len = 30;

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

auto radius = ofMap(sin((random + ofGetFrameNum() + i) * span), 0, 1, 280, 320);

auto next_radius = ofMap(sin((random + ofGetFrameNum() + i + 1) * span), 0, 1, 280, 320);

auto location = glm::vec3(radius * cos((ofGetFrameNum() + i + deg) * DEG_TO_RAD), radius * sin((ofGetFrameNum() + i + deg) * DEG_TO_RAD), 0);

auto next = glm::vec3(next_radius * cos((ofGetFrameNum() + i + 1 + deg) * DEG_TO_RAD), next_radius * sin((ofGetFrameNum() + i + 1 + deg) * DEG_TO_RAD), 0);

auto direction = next - location;

auto theta = atan2(direction.y, direction.x);

right.push_back(location + glm::vec3(ofMap(i, 0, len, 0, head_size) * cos(theta + PI * 0.5), ofMap(i, 0, len, 0, head_size) * sin(theta + PI * 0.5), 0));

left.push_back(location + glm::vec3(ofMap(i, 0, len, 0, head_size) * cos(theta - PI * 0.5), ofMap(i, 0, len, 0, head_size) * sin(theta - PI * 0.5), 0));

last_location = location;

last_theta = theta;

}

for (int i = 0; i < right.size(); i++) {

mesh.addVertex(left[i]);

mesh.addVertex(right[i]);

}

for (int i = 0; i < mesh.getNumVertices() - 2; i += 2) {

mesh.addIndex(i + 0); mesh.addIndex(i + 1); mesh.addIndex(i + 3);

mesh.addIndex(i + 0); mesh.addIndex(i + 2); mesh.addIndex(i + 3);

}

mesh.addVertex(last_location);

int index = mesh.getNumVertices();

for (auto theta = last_theta - PI * 0.5; theta <= last_theta + PI * 0.5; theta += PI / 20) {

mesh.addVertex(last_location + glm::vec3(head_size * cos(theta), head_size * sin(theta), 0));

frame.push_back(last_location + glm::vec3(head_size * cos(theta), head_size * sin(theta), 0));

}

for (int i = index; i < mesh.getNumVertices() - 1; i++) {

mesh.addIndex(index); mesh.addIndex(i + 0); mesh.addIndex(i + 1);

}

ofColor color;

color.setHsb(ofMap(k, 0, count, 0, 255), 180, 255);

ofSetColor(color);

ofNoFill();

ofBeginShape();

ofVertices(frame);

std::reverse(right.begin(), right.end());

ofVertices(right);

ofVertices(left);

ofEndShape(true);

ofSetColor(ofColor(color, 168));

mesh.draw();

}

int start = 50;

if (ofGetFrameNum() > start) {

ostringstream os;

os << setw(4) << setfill('0') << ofGetFrameNum() - start;

ofImage image;

image.grabScreen(0, 0, ofGetWidth(), ofGetHeight());

image.saveImage("image/cap/img_" + os.str() + ".jpg");

if (ofGetFrameNum() - start >= 25 * 20) {

std::exit(1);

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2024年9月20日

Twins.

[ Video ]

[ About ]
ツインズ。

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

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

};

#include "ofApp.h"

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

	ofSetFrameRate(25);
	ofSetWindowTitle("openframeworks");

	ofBackground(239);
	ofSetLineWidth(2);
}

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

	ofSeedRandom(39);
}

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

	ofColor color;
	vector<ofColor> color_list;
	vector<int> hex_list = { 0xef476f, 0xffd166, 0x06d6a0, 0x118ab2, /*0x073b4c*/ };
	for (auto hex : hex_list) {

		color.setHex(hex);
		color_list.push_back(color);
	}

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

	auto noise_seed = glm::vec2(ofRandom(1000), ofRandom(1000));
	for (int k = 0; k < 12; k++) {

		ofMesh mesh;
		vector<glm::vec3> right, left, frame;

		glm::vec3 last_location;
		float last_theta;

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

			auto radius = ofMap(sin((ofGetFrameNum() + i) * 0.2 + PI * (k / 6)), 0, 1, 280, 320);
			auto next_radius = ofMap(sin((ofGetFrameNum() + i + 1) * 0.2 + PI * (k / 6)), 0, 1, 280, 320);

			auto location = glm::vec3(radius * cos((ofGetFrameNum() + i + k * 60) * DEG_TO_RAD), radius * sin((ofGetFrameNum() + i + k * 60) * DEG_TO_RAD), 0);
			auto next = glm::vec3(next_radius * cos((ofGetFrameNum() + i + 1 + k * 60) * DEG_TO_RAD), next_radius * sin((ofGetFrameNum() + i + 1 + k * 60) * DEG_TO_RAD), 0);

			auto direction = next - location;
			auto theta = atan2(direction.y, direction.x);

			right.push_back(location + glm::vec3(ofMap(i, 0, 40, 0, 6) * cos(theta + PI * 0.5), ofMap(i, 0, 40, 0, 6) * sin(theta + PI * 0.5), 0));
			left.push_back(location + glm::vec3(ofMap(i, 0, 40, 0, 6) * cos(theta - PI * 0.5), ofMap(i, 0, 40, 0, 6) * sin(theta - PI * 0.5), 0));

			last_location = location;
			last_theta = theta;
		}

		for (int i = 0; i < right.size(); i++) {

			mesh.addVertex(left[i]);
			mesh.addVertex(right[i]);
		}


		for (int i = 0; i < mesh.getNumVertices() - 2; i += 2) {

			mesh.addIndex(i + 0); mesh.addIndex(i + 1); mesh.addIndex(i + 3);
			mesh.addIndex(i + 0); mesh.addIndex(i + 2); mesh.addIndex(i + 3);
		}

		mesh.addVertex(last_location);
		int index = mesh.getNumVertices();
		for (auto theta = last_theta - PI * 0.5; theta <= last_theta + PI * 0.5; theta += PI / 20) {

			mesh.addVertex(last_location + glm::vec3(6 * cos(theta), 6 * sin(theta), 0));
			frame.push_back(last_location + glm::vec3(6 * cos(theta), 6 * sin(theta), 0));
		}

		for (int i = index; i < mesh.getNumVertices() - 1; i++) {

			mesh.addIndex(index); mesh.addIndex(i + 0); mesh.addIndex(i + 1);
		}

		int color_index = k % color_list.size();

		ofSetColor(color_list[color_index]);
		ofNoFill();
		ofBeginShape();
		ofVertices(frame);
		reverse(right.begin(), right.end());
		ofVertices(right);
		ofVertices(left);
		ofEndShape();

		ofSetColor(ofColor(color_list[color_index], 64));
		mesh.draw();
	}

	/*
	int start = 50 + 18;
	if (ofGetFrameNum() > start) {

		ostringstream os;
		os << setw(4) << setfill('0') << ofGetFrameNum() - start;
		ofImage image;
		image.grabScreen(0, 0, ofGetWidth(), ofGetHeight());
		image.saveImage("image/cap/img_" + os.str() + ".jpg");
		if (ofGetFrameNum() - start >= 25 * 20) {

			std::exit(1);
		}
	}
	*/
}

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(25);

ofSetWindowTitle("openframeworks");

ofBackground(239);

ofSetLineWidth(2);

}

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

void ofApp::update() {

ofSeedRandom(39);

}

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

void ofApp::draw() {

ofColor color;

vector<ofColor> color_list;

vector<int> hex_list = { 0xef476f, 0xffd166, 0x06d6a0, 0x118ab2, /*0x073b4c*/ };

for (auto hex : hex_list) {

color.setHex(hex);

color_list.push_back(color);

}

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

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

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

ofMesh mesh;

vector<glm::vec3> right, left, frame;

glm::vec3 last_location;

float last_theta;

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

auto radius = ofMap(sin((ofGetFrameNum() + i) * 0.2 + PI * (k / 6)), 0, 1, 280, 320);

auto next_radius = ofMap(sin((ofGetFrameNum() + i + 1) * 0.2 + PI * (k / 6)), 0, 1, 280, 320);

auto location = glm::vec3(radius * cos((ofGetFrameNum() + i + k * 60) * DEG_TO_RAD), radius * sin((ofGetFrameNum() + i + k * 60) * DEG_TO_RAD), 0);

auto next = glm::vec3(next_radius * cos((ofGetFrameNum() + i + 1 + k * 60) * DEG_TO_RAD), next_radius * sin((ofGetFrameNum() + i + 1 + k * 60) * DEG_TO_RAD), 0);

auto direction = next - location;

auto theta = atan2(direction.y, direction.x);

right.push_back(location + glm::vec3(ofMap(i, 0, 40, 0, 6) * cos(theta + PI * 0.5), ofMap(i, 0, 40, 0, 6) * sin(theta + PI * 0.5), 0));

left.push_back(location + glm::vec3(ofMap(i, 0, 40, 0, 6) * cos(theta - PI * 0.5), ofMap(i, 0, 40, 0, 6) * sin(theta - PI * 0.5), 0));

last_location = location;

last_theta = theta;

}

for (int i = 0; i < right.size(); i++) {

mesh.addVertex(left[i]);

mesh.addVertex(right[i]);

}

for (int i = 0; i < mesh.getNumVertices() - 2; i += 2) {

mesh.addIndex(i + 0); mesh.addIndex(i + 1); mesh.addIndex(i + 3);

mesh.addIndex(i + 0); mesh.addIndex(i + 2); mesh.addIndex(i + 3);

}

mesh.addVertex(last_location);

int index = mesh.getNumVertices();

for (auto theta = last_theta - PI * 0.5; theta <= last_theta + PI * 0.5; theta += PI / 20) {

mesh.addVertex(last_location + glm::vec3(6 * cos(theta), 6 * sin(theta), 0));

frame.push_back(last_location + glm::vec3(6 * cos(theta), 6 * sin(theta), 0));

}

for (int i = index; i < mesh.getNumVertices() - 1; i++) {

mesh.addIndex(index); mesh.addIndex(i + 0); mesh.addIndex(i + 1);

}

int color_index = k % color_list.size();

ofSetColor(color_list[color_index]);

ofNoFill();

ofBeginShape();

ofVertices(frame);

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

ofVertices(right);

ofVertices(left);

ofEndShape();

ofSetColor(ofColor(color_list[color_index], 64));

mesh.draw();

}

int start = 50 + 18;

if (ofGetFrameNum() > start) {

ostringstream os;

os << setw(4) << setfill('0') << ofGetFrameNum() - start;

ofImage image;

image.grabScreen(0, 0, ofGetWidth(), ofGetHeight());

image.saveImage("image/cap/img_" + os.str() + ".jpg");

if (ofGetFrameNum() - start >= 25 * 20) {

std::exit(1);

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2024年9月19日

Zoom in/out.

[ Video ]

[ About ]
ズームイン・アウト。

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

	ofMesh mesh;
	float noise_span;
};

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

ofMesh mesh;

float noise_span;

};

#include "ofApp.h"

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

	ofSetFrameRate(25);
	ofSetWindowTitle("openFrameworks");

	ofBackground(39);
}

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

	this->mesh.clear();

	if (ofGetFrameNum() % 100 < 50) {

		this->noise_span = ofMap(ofGetFrameNum() % 100, 0, 50, 0.02, 0.00005);
	}
	else {

		this->noise_span = ofMap(ofGetFrameNum() % 100, 51, 100, 0.00005, 0.02);
	}

	float span = 1;
	ofColor color;
	for (float x = ofGetWindowWidth() * -0.5 + 30 ; x <= ofGetWindowWidth() * 0.5 - span - 30; x += span) {

		for (float y = ofGetWindowHeight() * -0.5 + 30; y <= ofGetWindowHeight() * 0.5 - span - 30 ; y += span) {

			this->mesh.addVertex(glm::vec3(x, y, 0));
			this->mesh.addVertex(glm::vec3(x + span, y, 0));
			this->mesh.addVertex(glm::vec3(x + span, y + span, 0));
			this->mesh.addVertex(glm::vec3(x, y + span, 0));

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

				auto noise_location = this->mesh.getVertex(i) * this->noise_span;
				auto noise_value = ofMap(ofNoise(noise_location.x, noise_location.y, ofGetFrameNum() * 0.06), 0, 1, 0, 4);
				int int_noise_value = noise_value;
				float param = noise_value - int_noise_value;
				param = abs(param - 0.5);
				auto alpha = param < 0.3 ? ofMap(param, 0, 0.3, 255, 0) : 0;

				color.setHsb(ofMap(int_noise_value, 0, 4, 0, 255), 200, 255);
				this->mesh.addColor(ofColor(color, alpha));
			}

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

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

	ofTranslate(ofGetWindowSize() * 0.5);
	this->mesh.draw();

	/*
	int start = 50 + 18;
	if (ofGetFrameNum() > start) {

		ostringstream os;
		os << setw(4) << setfill('0') << ofGetFrameNum() - start;
		ofImage image;
		image.grabScreen(0, 0, ofGetWidth(), ofGetHeight());
		image.saveImage("image/cap/img_" + os.str() + ".jpg");
		if (ofGetFrameNum() - start >= 25 * 20) {

			std::exit(1);
		}
	}
	*/
}

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

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(25);

ofSetWindowTitle("openFrameworks");

ofBackground(39);

}

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

void ofApp::update() {

this->mesh.clear();

if (ofGetFrameNum() % 100 < 50) {

this->noise_span = ofMap(ofGetFrameNum() % 100, 0, 50, 0.02, 0.00005);

}

else {

this->noise_span = ofMap(ofGetFrameNum() % 100, 51, 100, 0.00005, 0.02);

}

float span = 1;

ofColor color;

for (float x = ofGetWindowWidth() * -0.5 + 30 ; x <= ofGetWindowWidth() * 0.5 - span - 30; x += span) {

for (float y = ofGetWindowHeight() * -0.5 + 30; y <= ofGetWindowHeight() * 0.5 - span - 30 ; y += span) {

this->mesh.addVertex(glm::vec3(x, y, 0));

this->mesh.addVertex(glm::vec3(x + span, y, 0));

this->mesh.addVertex(glm::vec3(x + span, y + span, 0));

this->mesh.addVertex(glm::vec3(x, y + span, 0));

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

auto noise_location = this->mesh.getVertex(i) * this->noise_span;

auto noise_value = ofMap(ofNoise(noise_location.x, noise_location.y, ofGetFrameNum() * 0.06), 0, 1, 0, 4);

int int_noise_value = noise_value;

float param = noise_value - int_noise_value;

param = abs(param - 0.5);

auto alpha = param < 0.3 ? ofMap(param, 0, 0.3, 255, 0) : 0;

color.setHsb(ofMap(int_noise_value, 0, 4, 0, 255), 200, 255);

this->mesh.addColor(ofColor(color, alpha));

}

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

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

}

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

void ofApp::draw() {

ofTranslate(ofGetWindowSize() * 0.5);

this->mesh.draw();

int start = 50 + 18;

if (ofGetFrameNum() > start) {

ostringstream os;

os << setw(4) << setfill('0') << ofGetFrameNum() - start;

ofImage image;

image.grabScreen(0, 0, ofGetWidth(), ofGetHeight());

image.saveImage("image/cap/img_" + os.str() + ".jpg");

if (ofGetFrameNum() - start >= 25 * 20) {

std::exit(1);

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

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