box2d – ページ 14 – プログラミング de 落描き

2018年8月8日2018年8月8日

Rain of Particles. openframeworks

[ Video ]

[ About ]
パーティクル同士が衝突すると、速度の高い方の色が伝達して変化します。物理エンジンはofxBox2dを使ってます。

When particles collide with each other, color change to color of faster particle. I use physics engine is ofxBox2d.

[ Source ]

#pragma once
#include "ofMain.h"
#include "ofxBox2d.h"

#include "Particle.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 contactStart(ofxBox2dContactArgs &e);
	void contactEnd(ofxBox2dContactArgs &e);

	ofxBox2d box2d;
	vector<unique_ptr<Particle>> particles;
	vector<shared_ptr<ofxBox2dJoint>> joints;
};

#pragma once

#include "ofMain.h"

#include "ofxBox2d.h"

#include "Particle.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 contactStart(ofxBox2dContactArgs &e);

void contactEnd(ofxBox2dContactArgs &e);

ofxBox2d box2d;

vector<unique_ptr<Particle>> particles;

vector<shared_ptr<ofxBox2dJoint>> joints;

};

#include "ofApp.h"

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

	ofSetFrameRate(60);
	ofSetWindowTitle("Insta");

	ofBackground(239);

	this->box2d.init();
	this->box2d.enableEvents();
	this->box2d.setGravity(0, 10);
	this->box2d.createBounds();
	this->box2d.setFPS(60);
	this->box2d.registerGrabbing();

	ofAddListener(box2d.contactStartEvents, this, &ofApp::contactStart);
	ofAddListener(box2d.contactEndEvents, this, &ofApp::contactEnd);
}

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

	if (ofGetFrameNum() % 1 == 0) {

		ofPoint point(ofRandom(ofGetWidth()), ofRandom(ofGetHeight() * 0.1));
		float radius = ofRandom(10, 15);
		unique_ptr<Particle> p(new Particle(this->box2d, point, radius));

		this->particles.push_back(std::move(p));
	}

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

		this->particles[i]->Update();
		if (this->particles[i]->IsDead()) {

			this->particles.erase(this->particles.begin() + i);
		}
	}

	this->box2d.update();
}

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

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

		this->particles[i]->Draw();
	}
}

//--------------------------------------------------------------
void ofApp::contactStart(ofxBox2dContactArgs &e) {

	if (e.a != NULL && e.b != NULL) {

		Particle* p_a = (Particle*)e.a->GetBody()->GetUserData();
		Particle* p_b = (Particle*)e.b->GetBody()->GetUserData();
		if (p_a != nullptr && p_b != nullptr) {

			ofPoint p_a_velocity = p_a->GetVelocity();
			ofPoint p_b_velocity = p_b->GetVelocity();
			if (p_a_velocity.length() < p_b_velocity.length()) {

				p_a->SetColor(p_b->GetColor());
			}
			else {

				p_b->SetColor(p_a->GetColor());
			}
		}
	}
}

//--------------------------------------------------------------
void ofApp::contactEnd(ofxBox2dContactArgs &e) {

	if (e.a != NULL && e.b != NULL) {

		// do nothing
	}
}

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

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("Insta");

ofBackground(239);

this->box2d.init();

this->box2d.enableEvents();

this->box2d.setGravity(0, 10);

this->box2d.createBounds();

this->box2d.setFPS(60);

this->box2d.registerGrabbing();

ofAddListener(box2d.contactStartEvents, this, &ofApp::contactStart);

ofAddListener(box2d.contactEndEvents, this, &ofApp::contactEnd);

}

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

void ofApp::update() {

if (ofGetFrameNum() % 1 == 0) {

ofPoint point(ofRandom(ofGetWidth()), ofRandom(ofGetHeight() * 0.1));

float radius = ofRandom(10, 15);

unique_ptr<Particle> p(new Particle(this->box2d, point, radius));

this->particles.push_back(std::move(p));

}

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

this->particles[i]->Update();

if (this->particles[i]->IsDead()) {

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

}

this->box2d.update();

}

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

void ofApp::draw() {

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

this->particles[i]->Draw();

}

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

void ofApp::contactStart(ofxBox2dContactArgs &e) {

if (e.a != NULL && e.b != NULL) {

Particle* p_a = (Particle*)e.a->GetBody()->GetUserData();

Particle* p_b = (Particle*)e.b->GetBody()->GetUserData();

if (p_a != nullptr && p_b != nullptr) {

ofPoint p_a_velocity = p_a->GetVelocity();

ofPoint p_b_velocity = p_b->GetVelocity();

if (p_a_velocity.length() < p_b_velocity.length()) {

p_a->SetColor(p_b->GetColor());

}

else {

p_b->SetColor(p_a->GetColor());

}

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

void ofApp::contactEnd(ofxBox2dContactArgs &e) {

if (e.a != NULL && e.b != NULL) {

// do nothing

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

#pragma once
#include "ofMain.h"
#include "ofxBox2d.h"

class Particle
{
public:

	Particle(ofxBox2d& box2d, ofPoint point, float radius);
	~Particle();

	void Update();
	void Draw();

	void SetColor(ofColor color);
	ofColor GetColor();
	ofPoint GetVelocity();
	bool IsDead();
private:

	ofxBox2dCircle* circle = nullptr;
	ofColor color;
	float life;
};

#pragma once

#include "ofMain.h"

#include "ofxBox2d.h"

class Particle

{

public:

Particle(ofxBox2d& box2d, ofPoint point, float radius);

~Particle();

void Update();

void Draw();

void SetColor(ofColor color);

ofColor GetColor();

ofPoint GetVelocity();

bool IsDead();

private:

ofxBox2dCircle* circle = nullptr;

ofColor color;

float life;

};

#include "Particle.h"

Particle::Particle(ofxBox2d& box2d, ofPoint point, float radius)
{
	this->circle = new ofxBox2dCircle();
	this->circle->setPhysics(1.0, 0.5, 1.0);
	this->circle->setup(box2d.getWorld(), point.x, point.y, radius);
	this->circle->setData(this);

	this->color.setHsb(ofRandom(255), 255, 230);
	this->life = 255;
}

Particle::~Particle()
{
	if (this->circle != nullptr) {

		this->circle->destroy();
		delete this->circle;
	}
}

void Particle::Update() {

	this->life -= 0.75;
}

void Particle::Draw() {

	ofSetColor(this->color, this->life > 64 ? 255 : ofMap(this->life, 0, 64, 0, 255));
	ofDrawCircle(this->circle->getPosition(), this->circle->getRadius());
}

// Setter 
void Particle::SetColor(ofColor color) { this->color = color; }

// Getter
ofColor Particle::GetColor() { return this->color; }
ofPoint Particle::GetVelocity() { return this->circle->getVelocity(); }
bool Particle::IsDead() { return this->life <= 0 ? true : false; }

#include "Particle.h"

Particle::Particle(ofxBox2d& box2d, ofPoint point, float radius)

{

this->circle = new ofxBox2dCircle();

this->circle->setPhysics(1.0, 0.5, 1.0);

this->circle->setup(box2d.getWorld(), point.x, point.y, radius);

this->circle->setData(this);

this->color.setHsb(ofRandom(255), 255, 230);

this->life = 255;

}

Particle::~Particle()

{

if (this->circle != nullptr) {

this->circle->destroy();

delete this->circle;

}

void Particle::Update() {

this->life -= 0.75;

}

void Particle::Draw() {

ofSetColor(this->color, this->life > 64 ? 255 : ofMap(this->life, 0, 64, 0, 255));

ofDrawCircle(this->circle->getPosition(), this->circle->getRadius());

}

// Setter

void Particle::SetColor(ofColor color) { this->color = color; }

// Getter

ofColor Particle::GetColor() { return this->color; }

ofPoint Particle::GetVelocity() { return this->circle->getVelocity(); }

bool Particle::IsDead() { return this->life <= 0 ? true : false; }

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2018年8月6日2018年8月6日

Long long arrow. openframeworks

[ Video ]

[ About ]
矢印の線を軌跡にしてみました。Long long agoと掛けたLong long arrowというオヤジギャグを思いついて発作的に

Long long arrows.

[ Source ]

#pragma once
#include "ofMain.h"
#include "ofxBox2d.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) {}

	ofxBox2d box2d;
	vector<shared_ptr<ofxBox2dCircle>> circles;
	vector<deque<ofPoint>> circles_log;
	vector<ofPoint> force_fields;
	int force_field_radius;
};

#pragma once

#include "ofMain.h"

#include "ofxBox2d.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) {}

ofxBox2d box2d;

vector<shared_ptr<ofxBox2dCircle>> circles;

vector<deque<ofPoint>> circles_log;

vector<ofPoint> force_fields;

int force_field_radius;

};

#include "ofApp.h"

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

	ofSetFrameRate(30);
	ofSetWindowTitle("Insta");

	ofBackground(39);
	ofSetColor(239);
	ofSetLineWidth(2);

	this->box2d.init();
	this->box2d.setGravity(0, 0);
	this->box2d.createBounds();
	this->box2d.setFPS(30);
	this->box2d.registerGrabbing();

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

		float radius = 15;
		auto circle = make_shared<ofxBox2dCircle>();
		circle->setPhysics(1.0, 0.63, 1.0);
		circle->setup(this->box2d.getWorld(), ofRandom(ofGetWidth() / 2), ofRandom(ofGetHeight() / 2), radius);

		this->circles.push_back(circle);

		deque<ofPoint> log;
		this->circles_log.push_back(log);
	}

	this->force_fields.push_back(ofPoint(ofGetWidth() / 4, ofGetHeight() / 4));
	this->force_fields.push_back(ofPoint(ofGetWidth() / 4 * 3, ofGetHeight() / 4));
	this->force_fields.push_back(ofPoint(ofGetWidth() / 4 * 3, ofGetHeight() / 4 * 3));
	this->force_fields.push_back(ofPoint(ofGetWidth() / 4, ofGetHeight() / 4 * 3));

	this->force_field_radius = 300;
}

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

	ofSeedRandom(39);

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

		shared_ptr<ofxBox2dCircle> circle = this->circles[i];
		ofPoint point = circle->getPosition();

		for (int field_index = 0; field_index < this->force_fields.size(); field_index++) {

			float distance = point.distance(this->force_fields[field_index]);
			if (distance < this->force_field_radius) {

				ofPoint p = ofPoint(this->force_field_radius * cos((field_index * 90 + 10) * DEG_TO_RAD), this->force_field_radius * sin((field_index * 90 + 10) * DEG_TO_RAD));
				circle->addForce(p, ofMap(distance, 0, this->force_field_radius, 0.1, 0.01));
			}
		}
	}

	this->box2d.update();

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

		this->circles_log[i].push_front(this->circles[i]->getPosition());
		while (this->circles_log[i].size() > 10) {

			this->circles_log[i].pop_back();
		}
	}
}

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

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

		float radius = this->circles[i]->getRadius();
		ofPoint point = this->circles[i]->getPosition();
		ofPoint velocity = this->circles[i]->getVelocity();

		ofPushMatrix();
		ofTranslate(point);

		float velocity_deg = atan2f(velocity.y, velocity.x) * RAD_TO_DEG;
		ofFill();
		ofBeginShape();
		for (int deg = velocity_deg; deg < velocity_deg + 270; deg += 120) {

			ofVertex(radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD));
		}
		ofEndShape(true);

		ofPopMatrix();

		ofNoFill();
		ofBeginShape();
		for (int log_index = 0; log_index < this->circles_log[i].size(); log_index++) {

			ofVertex(this->circles_log[i][log_index]);
		}
		ofEndShape(false);
	}
}

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

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

100

101

102

103

104

105

106

107

108

109

110

111

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(30);

ofSetWindowTitle("Insta");

ofBackground(39);

ofSetColor(239);

ofSetLineWidth(2);

this->box2d.init();

this->box2d.setGravity(0, 0);

this->box2d.createBounds();

this->box2d.setFPS(30);

this->box2d.registerGrabbing();

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

float radius = 15;

auto circle = make_shared<ofxBox2dCircle>();

circle->setPhysics(1.0, 0.63, 1.0);

circle->setup(this->box2d.getWorld(), ofRandom(ofGetWidth() / 2), ofRandom(ofGetHeight() / 2), radius);

this->circles.push_back(circle);

deque<ofPoint> log;

this->circles_log.push_back(log);

}

this->force_fields.push_back(ofPoint(ofGetWidth() / 4, ofGetHeight() / 4));

this->force_fields.push_back(ofPoint(ofGetWidth() / 4 * 3, ofGetHeight() / 4));

this->force_fields.push_back(ofPoint(ofGetWidth() / 4 * 3, ofGetHeight() / 4 * 3));

this->force_fields.push_back(ofPoint(ofGetWidth() / 4, ofGetHeight() / 4 * 3));

this->force_field_radius = 300;

}

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

void ofApp::update() {

ofSeedRandom(39);

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

shared_ptr<ofxBox2dCircle> circle = this->circles[i];

ofPoint point = circle->getPosition();

for (int field_index = 0; field_index < this->force_fields.size(); field_index++) {

float distance = point.distance(this->force_fields[field_index]);

if (distance < this->force_field_radius) {

ofPoint p = ofPoint(this->force_field_radius * cos((field_index * 90 + 10) * DEG_TO_RAD), this->force_field_radius * sin((field_index * 90 + 10) * DEG_TO_RAD));

circle->addForce(p, ofMap(distance, 0, this->force_field_radius, 0.1, 0.01));

}

this->box2d.update();

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

this->circles_log[i].push_front(this->circles[i]->getPosition());

while (this->circles_log[i].size() > 10) {

this->circles_log[i].pop_back();

}

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

void ofApp::draw() {

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

float radius = this->circles[i]->getRadius();

ofPoint point = this->circles[i]->getPosition();

ofPoint velocity = this->circles[i]->getVelocity();

ofPushMatrix();

ofTranslate(point);

float velocity_deg = atan2f(velocity.y, velocity.x) * RAD_TO_DEG;

ofFill();

ofBeginShape();

for (int deg = velocity_deg; deg < velocity_deg + 270; deg += 120) {

ofVertex(radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD));

}

ofEndShape(true);

ofPopMatrix();

ofNoFill();

ofBeginShape();

for (int log_index = 0; log_index < this->circles_log[i].size(); log_index++) {

ofVertex(this->circles_log[i][log_index]);

}

ofEndShape(false);

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2018年8月4日2018年8月4日

Arrows tornade. openframewrosk

[ Video ]

[ About ]
矢印の線長は速度とリンクしています

Arrow is linked to speed with line length.

[ Source ]

#pragma once
#include "ofMain.h"
#include "ofxBox2d.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) {}

	ofxBox2d box2d;
	vector<shared_ptr<ofxBox2dCircle>> circles;
	vector<ofPoint> force_fields;
	int force_field_radius;
};

#pragma once

#include "ofMain.h"

#include "ofxBox2d.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) {}

ofxBox2d box2d;

vector<shared_ptr<ofxBox2dCircle>> circles;

vector<ofPoint> force_fields;

int force_field_radius;

};

#include "ofApp.h"

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

	ofSetFrameRate(60);
	ofSetWindowTitle("Insta");

	ofBackground(39);
	ofSetColor(239);
	ofSetLineWidth(2);

	this->box2d.init();
	this->box2d.setGravity(0, 0);
	this->box2d.createBounds();
	this->box2d.setFPS(60);
	this->box2d.registerGrabbing();

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

		float radius = 15;
		auto circle = make_shared<ofxBox2dCircle>();
		circle->setPhysics(0.8, 0.63, 0.1);
		circle->setup(this->box2d.getWorld(), ofRandom(ofGetWidth() / 2), ofRandom(ofGetHeight() / 2), radius);

		this->circles.push_back(circle);
	}

	this->force_fields.push_back(ofPoint(ofGetWidth() / 4, ofGetHeight() / 4));
	this->force_fields.push_back(ofPoint(ofGetWidth() / 4 * 3, ofGetHeight() / 4));
	this->force_fields.push_back(ofPoint(ofGetWidth() / 4 * 3, ofGetHeight() / 4 * 3));
	this->force_fields.push_back(ofPoint(ofGetWidth() / 4, ofGetHeight() / 4 * 3));

	this->force_field_radius = 300;
}

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

	ofSeedRandom(39);

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

		shared_ptr<ofxBox2dCircle> circle = this->circles[i];
		ofPoint point = circle->getPosition();
		for (int field_index = 0; field_index < this->force_fields.size(); field_index++) {

			float distance = point.distance(this->force_fields[field_index]);
			if (distance < this->force_field_radius) {

				ofPoint p = ofPoint(this->force_field_radius * cos((field_index * 90 + 10) * DEG_TO_RAD), this->force_field_radius * sin((field_index * 90 + 10) * DEG_TO_RAD));
				circle->addForce(p, ofMap(distance, 0, this->force_field_radius, 0.1, 0.05));
			}
		}
	}

	this->box2d.update();
}


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

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

		float radius = this->circles[i]->getRadius();
		ofPoint point = this->circles[i]->getPosition();
		ofPoint velocity = this->circles[i]->getVelocity();

		ofPushMatrix();
		ofTranslate(point);

		ofColor tmp_color;
		tmp_color.setHsb(ofRandom(255), 230, 255);
		ofSetColor(tmp_color);

		float velocity_deg = atan2f(velocity.y, velocity.x) * RAD_TO_DEG;
		ofBeginShape();
		for (int deg = velocity_deg; deg < velocity_deg + 270; deg += 120) {

			ofVertex(radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD));
		}
		ofEndShape(true);
		ofDrawLine(ofPoint(radius * cos(velocity_deg * DEG_TO_RAD), radius * sin(velocity_deg * DEG_TO_RAD)), velocity * -1.0);

		ofPopMatrix();
	}
}

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

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("Insta");

ofBackground(39);

ofSetColor(239);

ofSetLineWidth(2);

this->box2d.init();

this->box2d.setGravity(0, 0);

this->box2d.createBounds();

this->box2d.setFPS(60);

this->box2d.registerGrabbing();

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

float radius = 15;

auto circle = make_shared<ofxBox2dCircle>();

circle->setPhysics(0.8, 0.63, 0.1);

circle->setup(this->box2d.getWorld(), ofRandom(ofGetWidth() / 2), ofRandom(ofGetHeight() / 2), radius);

this->circles.push_back(circle);

}

this->force_fields.push_back(ofPoint(ofGetWidth() / 4, ofGetHeight() / 4));

this->force_fields.push_back(ofPoint(ofGetWidth() / 4 * 3, ofGetHeight() / 4));

this->force_fields.push_back(ofPoint(ofGetWidth() / 4 * 3, ofGetHeight() / 4 * 3));

this->force_fields.push_back(ofPoint(ofGetWidth() / 4, ofGetHeight() / 4 * 3));

this->force_field_radius = 300;

}

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

void ofApp::update() {

ofSeedRandom(39);

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

shared_ptr<ofxBox2dCircle> circle = this->circles[i];

ofPoint point = circle->getPosition();

for (int field_index = 0; field_index < this->force_fields.size(); field_index++) {

float distance = point.distance(this->force_fields[field_index]);

if (distance < this->force_field_radius) {

ofPoint p = ofPoint(this->force_field_radius * cos((field_index * 90 + 10) * DEG_TO_RAD), this->force_field_radius * sin((field_index * 90 + 10) * DEG_TO_RAD));

circle->addForce(p, ofMap(distance, 0, this->force_field_radius, 0.1, 0.05));

}

this->box2d.update();

}

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

void ofApp::draw() {

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

float radius = this->circles[i]->getRadius();

ofPoint point = this->circles[i]->getPosition();

ofPoint velocity = this->circles[i]->getVelocity();

ofPushMatrix();

ofTranslate(point);

ofColor tmp_color;

tmp_color.setHsb(ofRandom(255), 230, 255);

ofSetColor(tmp_color);

float velocity_deg = atan2f(velocity.y, velocity.x) * RAD_TO_DEG;

ofBeginShape();

for (int deg = velocity_deg; deg < velocity_deg + 270; deg += 120) {

ofVertex(radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD));

}

ofEndShape(true);

ofDrawLine(ofPoint(radius * cos(velocity_deg * DEG_TO_RAD), radius * sin(velocity_deg * DEG_TO_RAD)), velocity * -1.0);

ofPopMatrix();

}

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

int main() {

ofSetupOpenGL(1280, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

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