openFrameworks – ページ 475 – プログラミング de 落描き

2021年4月3日2021年4月3日

Torus 20210403. Draw by openFrameworks

[ Video ]

[ About ]
Torus.

[ 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::vec3 make_point(float R, float r, float u, float v);

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

glm::vec3 make_point(float R, float r, float u, float v);

ofEasyCam cam;

ofMesh face, frame;

};

#include "ofApp.h"	

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

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

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

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

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

	ofSeedRandom(39);

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

	float R = 300;
	int v_span = 4;
	int u_span = 8;

	for (int v = 0; v < 360; v += v_span) {

		for (auto u = 0; u < 360; u += u_span) {

			auto r = 80.f;
			auto noise_value = ofNoise(glm::vec4(this->make_point(R, 90, u + u_span * 0.5, v) * 0.01, ofGetFrameNum() * 0.008));
			if (noise_value < 0.3) { r = ofMap(noise_value, 0, 0.3, 10, 80); }
			if (noise_value > 0.7) { r = ofMap(noise_value, 0.7, 1, 80, 200); }

			vector<glm::vec3> vertices;
			vertices.push_back(this->make_point(R, r, u, v - v_span * 0.5));
			vertices.push_back(this->make_point(R, r, u + u_span, v - v_span * 0.5));
			vertices.push_back(this->make_point(R, r, u + u_span, v + v_span * 0.5));
			vertices.push_back(this->make_point(R, r, u, v + v_span * 0.5));

			int index = face.getNumVertices();
			this->face.addVertices(vertices);

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

			this->frame.addVertices(vertices);

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

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

	this->cam.begin();
	ofRotateX(ofGetFrameNum() * 0.37);
	ofRotateY(ofGetFrameNum() * 0.72);

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

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

	this->cam.end();
}

//--------------------------------------------------------------
glm::vec3 ofApp::make_point(float R, float r, float u, float v) {

	// 数学デッサン教室 描いて楽しむ数学たち　P.31

	u *= DEG_TO_RAD;
	v *= DEG_TO_RAD;

	auto x = (R + r * cos(u)) * cos(v);
	auto y = (R + r * cos(u)) * sin(v);
	auto z = r * sin(u);

	return glm::vec3(x, y, z);
}

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

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openFrameworks");

ofBackground(239);

ofSetLineWidth(3);

ofEnableDepthTest();

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

}

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

void ofApp::update() {

ofSeedRandom(39);

this->face.clear();

this->frame.clear();

float R = 300;

int v_span = 4;

int u_span = 8;

for (int v = 0; v < 360; v += v_span) {

for (auto u = 0; u < 360; u += u_span) {

auto r = 80.f;

auto noise_value = ofNoise(glm::vec4(this->make_point(R, 90, u + u_span * 0.5, v) * 0.01, ofGetFrameNum() * 0.008));

if (noise_value < 0.3) { r = ofMap(noise_value, 0, 0.3, 10, 80); }

if (noise_value > 0.7) { r = ofMap(noise_value, 0.7, 1, 80, 200); }

vector<glm::vec3> vertices;

vertices.push_back(this->make_point(R, r, u, v - v_span * 0.5));

vertices.push_back(this->make_point(R, r, u + u_span, v - v_span * 0.5));

vertices.push_back(this->make_point(R, r, u + u_span, v + v_span * 0.5));

vertices.push_back(this->make_point(R, r, u, v + v_span * 0.5));

int index = face.getNumVertices();

this->face.addVertices(vertices);

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

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

this->frame.addVertices(vertices);

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

this->frame.addIndex(index + 1); this->frame.addIndex(index + 2);

this->frame.addIndex(index + 2); this->frame.addIndex(index + 3);

this->frame.addIndex(index + 3); this->frame.addIndex(index + 0);

}

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

void ofApp::draw() {

this->cam.begin();

ofRotateX(ofGetFrameNum() * 0.37);

ofRotateY(ofGetFrameNum() * 0.72);

ofSetColor(39);

this->face.draw();

ofSetColor(239);

this->frame.drawWireframe();

this->cam.end();

}

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

glm::vec3 ofApp::make_point(float R, float r, float u, float v) {

// 数学デッサン教室描いて楽しむ数学たち　P.31

u *= DEG_TO_RAD;

v *= DEG_TO_RAD;

auto x = (R + r * cos(u)) * cos(v);

auto y = (R + r * cos(u)) * sin(v);

auto z = r * sin(u);

return glm::vec3(x, y, z);

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

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

Two screen, one source. Draw by openFrameworks

[ Video ]

[ About ]
Two screen, one source.

[ Source ]

#pragma once
#include "ofMain.h"
#include "opencv2/opencv.hpp"

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;

	cv::VideoCapture cap;
	cv::Size cap_size;

	ofImage image;
	cv::Mat frame;
};

#pragma once

#include "ofMain.h"

#include "opencv2/opencv.hpp"

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;

cv::VideoCapture cap;

cv::Size cap_size;

ofImage image;

cv::Mat frame;

};

#include "ofApp.h"

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

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

	ofBackground(239);
	ofSetLineWidth(2);
	ofEnableDepthTest();

	this->cap.open("D:\\MP4\\Pexels Videos 1739010.mp4");
	this->cap_size = cv::Size(1280, 720);

	this->image.allocate(this->cap_size.width, this->cap_size.height, OF_IMAGE_COLOR);
	this->frame = cv::Mat(cv::Size(this->image.getWidth(), this->image.getHeight()), CV_MAKETYPE(CV_8UC3, this->image.getPixels().getNumChannels()), this->image.getPixels().getData(), 0);
}

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

	ofSeedRandom(39);

	cv::Mat src;
	this->cap >> src;
	if (src.empty()) {

		this->cap.set(cv::CAP_PROP_POS_FRAMES, 0);
		return;
	}

	cv::cvtColor(src, src, cv::COLOR_BGR2RGB);
	cv::resize(src, this->frame, this->cap_size);
	cv::flip(this->frame, this->frame, 0);

	this->image.update();
}

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

	this->cam.begin();
	ofTranslate(-640, -360);

	vector<ofMesh> mesh_list;
	for (int x = 0; x < 1280; x += 40) {

		for (int y = 0; y < 720; y += 40) {

			auto noise_value = ofNoise(x * 0.005, y * 0.001 + ofGetFrameNum() * 0.005);

			ofMesh mesh_1, mesh_2;

			mesh_1.addVertex(glm::vec3(x, y, 0));
			mesh_1.addVertex(glm::vec3(x + 40, y, 0));
			mesh_1.addVertex(glm::vec3(x + 40, y + 40, 0));

			mesh_1.addTexCoord(glm::vec3(x, y, 0));
			mesh_1.addTexCoord(glm::vec3(x + 40, y, 0));
			mesh_1.addTexCoord(glm::vec3(x + 40, y + 40, 0));

			mesh_2.addVertex(glm::vec3(x, y + 40, 0));
			mesh_2.addVertex(glm::vec3(x + 40, y + 40, 0));
			mesh_2.addVertex(glm::vec3(x, y, 0));

			mesh_2.addTexCoord(glm::vec3(x, y + 40, 0));
			mesh_2.addTexCoord(glm::vec3(x + 40, y + 40, 0));
			mesh_2.addTexCoord(glm::vec3(x, y, 0));

			mesh_list.push_back(mesh_1);
			mesh_list.push_back(mesh_2);
		}
	}

	for (auto& mesh : mesh_list) {

		auto rotate = glm::vec3(ofRandom(360), ofRandom(360), ofRandom(360));
		auto speed = glm::vec3(ofRandom(5, 10), ofRandom(5, 10), ofRandom(5, 10));

		auto avg = (mesh.getVertex(0) + mesh.getVertex(1) + mesh.getVertex(2)) / 3;
		mesh.setVertex(0, mesh.getVertex(0) - avg);
		mesh.setVertex(1, mesh.getVertex(1) - avg);
		mesh.setVertex(2, mesh.getVertex(2) - avg);

		auto noise_value = ofNoise(glm::vec4(avg * 0.001, ofGetFrameNum() * 0.005));
		if (noise_value < 0.48) {
						
			avg += glm::vec3(0, 0, -250);
			rotate = glm::vec3();
		}
		else if (noise_value < 0.52) {

			avg += glm::vec3(0, 0, ofMap(noise_value, 0.48, 0.52, -250, 250));
			rotate.x += ofGetFrameNum() * speed.x;
			rotate.y += ofGetFrameNum() * speed.y;
			rotate.z += ofGetFrameNum() * speed.z;
		}
		else {

			avg += glm::vec3(0, 0, 250);
			rotate = glm::vec3();
		}

		ofPushMatrix();
		ofTranslate(avg);
		ofRotateZ(rotate.z);
		ofRotateY(rotate.y);
		ofRotateX(rotate.x);

		ofSetColor(255);
		this->image.bind();
		mesh.draw();
		this->image.unbind();

		if (glm::length(rotate) > 0) {
		
			ofSetColor(39);
			mesh.drawWireframe();
		}

		ofPopMatrix();
	}

	ofNoFill();
	ofSetColor(39);
	ofDrawRectangle(glm::vec3(0, 0, -250), 1280, 720);
	ofDrawRectangle(glm::vec3(0, 0, 250), 1280, 720);

	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

133

134

135

136

137

138

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openframeworks");

ofBackground(239);

ofSetLineWidth(2);

ofEnableDepthTest();

this->cap.open("D:\\MP4\\Pexels Videos 1739010.mp4");

this->cap_size = cv::Size(1280, 720);

this->image.allocate(this->cap_size.width, this->cap_size.height, OF_IMAGE_COLOR);

this->frame = cv::Mat(cv::Size(this->image.getWidth(), this->image.getHeight()), CV_MAKETYPE(CV_8UC3, this->image.getPixels().getNumChannels()), this->image.getPixels().getData(), 0);

}

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

void ofApp::update() {

ofSeedRandom(39);

cv::Mat src;

this->cap >> src;

if (src.empty()) {

this->cap.set(cv::CAP_PROP_POS_FRAMES, 0);

return;

}

cv::cvtColor(src, src, cv::COLOR_BGR2RGB);

cv::resize(src, this->frame, this->cap_size);

cv::flip(this->frame, this->frame, 0);

this->image.update();

}

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

void ofApp::draw() {

this->cam.begin();

ofTranslate(-640, -360);

vector<ofMesh> mesh_list;

for (int x = 0; x < 1280; x += 40) {

for (int y = 0; y < 720; y += 40) {

auto noise_value = ofNoise(x * 0.005, y * 0.001 + ofGetFrameNum() * 0.005);

ofMesh mesh_1, mesh_2;

mesh_1.addVertex(glm::vec3(x, y, 0));

mesh_1.addVertex(glm::vec3(x + 40, y, 0));

mesh_1.addVertex(glm::vec3(x + 40, y + 40, 0));

mesh_1.addTexCoord(glm::vec3(x, y, 0));

mesh_1.addTexCoord(glm::vec3(x + 40, y, 0));

mesh_1.addTexCoord(glm::vec3(x + 40, y + 40, 0));

mesh_2.addVertex(glm::vec3(x, y + 40, 0));

mesh_2.addVertex(glm::vec3(x + 40, y + 40, 0));

mesh_2.addVertex(glm::vec3(x, y, 0));

mesh_2.addTexCoord(glm::vec3(x, y + 40, 0));

mesh_2.addTexCoord(glm::vec3(x + 40, y + 40, 0));

mesh_2.addTexCoord(glm::vec3(x, y, 0));

mesh_list.push_back(mesh_1);

mesh_list.push_back(mesh_2);

}

for (auto& mesh : mesh_list) {

auto rotate = glm::vec3(ofRandom(360), ofRandom(360), ofRandom(360));

auto speed = glm::vec3(ofRandom(5, 10), ofRandom(5, 10), ofRandom(5, 10));

auto avg = (mesh.getVertex(0) + mesh.getVertex(1) + mesh.getVertex(2)) / 3;

mesh.setVertex(0, mesh.getVertex(0) - avg);

mesh.setVertex(1, mesh.getVertex(1) - avg);

mesh.setVertex(2, mesh.getVertex(2) - avg);

auto noise_value = ofNoise(glm::vec4(avg * 0.001, ofGetFrameNum() * 0.005));

if (noise_value < 0.48) {

avg += glm::vec3(0, 0, -250);

rotate = glm::vec3();

}

else if (noise_value < 0.52) {

avg += glm::vec3(0, 0, ofMap(noise_value, 0.48, 0.52, -250, 250));

rotate.x += ofGetFrameNum() * speed.x;

rotate.y += ofGetFrameNum() * speed.y;

rotate.z += ofGetFrameNum() * speed.z;

}

else {

avg += glm::vec3(0, 0, 250);

rotate = glm::vec3();

}

ofPushMatrix();

ofTranslate(avg);

ofRotateZ(rotate.z);

ofRotateY(rotate.y);

ofRotateX(rotate.x);

ofSetColor(255);

this->image.bind();

mesh.draw();

this->image.unbind();

if (glm::length(rotate) > 0) {

ofSetColor(39);

mesh.drawWireframe();

}

ofPopMatrix();

}

ofNoFill();

ofSetColor(39);

ofDrawRectangle(glm::vec3(0, 0, -250), 1280, 720);

ofDrawRectangle(glm::vec3(0, 0, 250), 1280, 720);

this->cam.end();

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

2021年4月1日2021年4月1日

Peel off. Draw by openFrameworks

[ Video ]

[ About ]
Peel off.

[ Source ]

#pragma once
#include "ofMain.h"
#include "opencv2/opencv.hpp"

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;

	cv::VideoCapture cap;
	cv::Size cap_size;

	ofImage image;
	cv::Mat frame;
};

#pragma once

#include "ofMain.h"

#include "opencv2/opencv.hpp"

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;

cv::VideoCapture cap;

cv::Size cap_size;

ofImage image;

cv::Mat frame;

};

#include "ofApp.h"

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

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

	ofBackground(239);
	ofSetLineWidth(2);
	ofEnableDepthTest();

	this->cap.open("D:\\MP4\\Pexels Videos 1739010.mp4");
	this->cap_size = cv::Size(1280, 720);

	this->image.allocate(this->cap_size.width, this->cap_size.height, OF_IMAGE_COLOR);
	this->frame = cv::Mat(cv::Size(this->image.getWidth(), this->image.getHeight()), CV_MAKETYPE(CV_8UC3, this->image.getPixels().getNumChannels()), this->image.getPixels().getData(), 0);
}

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

	ofSeedRandom(39);

	cv::Mat src;
	this->cap >> src;
	if (src.empty()) {

		this->cap.set(cv::CAP_PROP_POS_FRAMES, 0);
		return;
	}

	cv::cvtColor(src, src, cv::COLOR_BGR2RGB);
	cv::resize(src, this->frame, this->cap_size);
	cv::flip(this->frame, this->frame, 0);

	this->image.update();
}

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

	this->cam.begin();
	ofTranslate(-640, -360);

	vector<ofMesh> mesh_list;
	for (int x = 0; x < 1280; x += 40) {

		for (int y = 0; y < 720; y += 40) {

			auto noise_value = ofNoise(x * 0.005, y * 0.001 + ofGetFrameNum() * 0.005);

			ofMesh mesh_1, mesh_2;

			mesh_1.addVertex(glm::vec3(x, y, 0));
			mesh_1.addVertex(glm::vec3(x + 40, y, 0));
			mesh_1.addVertex(glm::vec3(x + 40, y + 40, 0));

			mesh_1.addTexCoord(glm::vec3(x, y, 0));
			mesh_1.addTexCoord(glm::vec3(x + 40, y, 0));
			mesh_1.addTexCoord(glm::vec3(x + 40, y + 40, 0));

			mesh_2.addVertex(glm::vec3(x, y + 40, 0));
			mesh_2.addVertex(glm::vec3(x + 40, y + 40, 0));
			mesh_2.addVertex(glm::vec3(x, y, 0));

			mesh_2.addTexCoord(glm::vec3(x, y + 40, 0));
			mesh_2.addTexCoord(glm::vec3(x + 40, y + 40, 0));
			mesh_2.addTexCoord(glm::vec3(x, y, 0));

			mesh_list.push_back(mesh_1);
			mesh_list.push_back(mesh_2);
		}
	}

	for (auto& mesh : mesh_list) {

		auto rotate = glm::vec3(ofRandom(360), ofRandom(360), ofRandom(360));
		auto speed = glm::vec3(ofRandom(5, 10), ofRandom(5, 10), ofRandom(5, 10));

		auto avg = (mesh.getVertex(0) + mesh.getVertex(1) + mesh.getVertex(2)) / 3;
		mesh.setVertex(0, mesh.getVertex(0) - avg);
		mesh.setVertex(1, mesh.getVertex(1) - avg);
		mesh.setVertex(2, mesh.getVertex(2) - avg);

		auto noise_value = ofNoise(glm::vec4(avg * 0.005, ofGetFrameNum() * 0.005));
		if (noise_value > 0.7) {

			avg += glm::vec3(0, 0, ofMap(noise_value, 0.7, 1, 0, 500));
			rotate.x += ofGetFrameNum() * speed.x;
			rotate.y += ofGetFrameNum() * speed.y;
			rotate.z += ofGetFrameNum() * speed.z;

			mesh.setVertex(0, mesh.getVertex(0) * ofMap(noise_value, 0.75, 1, 1, 3));
			mesh.setVertex(1, mesh.getVertex(1) * ofMap(noise_value, 0.75, 1, 1, 3));
			mesh.setVertex(2, mesh.getVertex(2) * ofMap(noise_value, 0.75, 1, 1, 3));
		}
		else {

			rotate = glm::vec3();
		}

		ofPushMatrix();
		ofTranslate(avg);
		ofRotateZ(rotate.z);
		ofRotateY(rotate.y);
		ofRotateX(rotate.x);

		ofSetColor(255);
		this->image.bind();
		mesh.draw();
		this->image.unbind();

		if (avg.z > 0) {
		
			ofSetColor(39);
			mesh.drawWireframe();
		}

		ofPopMatrix();
	}

	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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openframeworks");

ofBackground(239);

ofSetLineWidth(2);

ofEnableDepthTest();

this->cap.open("D:\\MP4\\Pexels Videos 1739010.mp4");

this->cap_size = cv::Size(1280, 720);

this->image.allocate(this->cap_size.width, this->cap_size.height, OF_IMAGE_COLOR);

this->frame = cv::Mat(cv::Size(this->image.getWidth(), this->image.getHeight()), CV_MAKETYPE(CV_8UC3, this->image.getPixels().getNumChannels()), this->image.getPixels().getData(), 0);

}

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

void ofApp::update() {

ofSeedRandom(39);

cv::Mat src;

this->cap >> src;

if (src.empty()) {

this->cap.set(cv::CAP_PROP_POS_FRAMES, 0);

return;

}

cv::cvtColor(src, src, cv::COLOR_BGR2RGB);

cv::resize(src, this->frame, this->cap_size);

cv::flip(this->frame, this->frame, 0);

this->image.update();

}

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

void ofApp::draw() {

this->cam.begin();

ofTranslate(-640, -360);

vector<ofMesh> mesh_list;

for (int x = 0; x < 1280; x += 40) {

for (int y = 0; y < 720; y += 40) {

auto noise_value = ofNoise(x * 0.005, y * 0.001 + ofGetFrameNum() * 0.005);

ofMesh mesh_1, mesh_2;

mesh_1.addVertex(glm::vec3(x, y, 0));

mesh_1.addVertex(glm::vec3(x + 40, y, 0));

mesh_1.addVertex(glm::vec3(x + 40, y + 40, 0));

mesh_1.addTexCoord(glm::vec3(x, y, 0));

mesh_1.addTexCoord(glm::vec3(x + 40, y, 0));

mesh_1.addTexCoord(glm::vec3(x + 40, y + 40, 0));

mesh_2.addVertex(glm::vec3(x, y + 40, 0));

mesh_2.addVertex(glm::vec3(x + 40, y + 40, 0));

mesh_2.addVertex(glm::vec3(x, y, 0));

mesh_2.addTexCoord(glm::vec3(x, y + 40, 0));

mesh_2.addTexCoord(glm::vec3(x + 40, y + 40, 0));

mesh_2.addTexCoord(glm::vec3(x, y, 0));

mesh_list.push_back(mesh_1);

mesh_list.push_back(mesh_2);

}

for (auto& mesh : mesh_list) {

auto rotate = glm::vec3(ofRandom(360), ofRandom(360), ofRandom(360));

auto speed = glm::vec3(ofRandom(5, 10), ofRandom(5, 10), ofRandom(5, 10));

auto avg = (mesh.getVertex(0) + mesh.getVertex(1) + mesh.getVertex(2)) / 3;

mesh.setVertex(0, mesh.getVertex(0) - avg);

mesh.setVertex(1, mesh.getVertex(1) - avg);

mesh.setVertex(2, mesh.getVertex(2) - avg);

auto noise_value = ofNoise(glm::vec4(avg * 0.005, ofGetFrameNum() * 0.005));

if (noise_value > 0.7) {

avg += glm::vec3(0, 0, ofMap(noise_value, 0.7, 1, 0, 500));

rotate.x += ofGetFrameNum() * speed.x;

rotate.y += ofGetFrameNum() * speed.y;

rotate.z += ofGetFrameNum() * speed.z;

mesh.setVertex(0, mesh.getVertex(0) * ofMap(noise_value, 0.75, 1, 1, 3));

mesh.setVertex(1, mesh.getVertex(1) * ofMap(noise_value, 0.75, 1, 1, 3));

mesh.setVertex(2, mesh.getVertex(2) * ofMap(noise_value, 0.75, 1, 1, 3));

}

else {

rotate = glm::vec3();

}

ofPushMatrix();

ofTranslate(avg);

ofRotateZ(rotate.z);

ofRotateY(rotate.y);

ofRotateX(rotate.x);

ofSetColor(255);

this->image.bind();

mesh.draw();

this->image.unbind();

if (avg.z > 0) {

ofSetColor(39);

mesh.drawWireframe();

}

ofPopMatrix();

}

this->cam.end();

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

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