/**
* Returns the exponential of the Quaternion.
*
* @see #log()
*/
public final Quaternion exp() {
float theta = PApplet.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
if (theta < 1E-6f) return new Quaternion(this.x, this.y, this.z, PApplet.cos(theta));
else {
float coef = PApplet.sin(theta) / theta;
return new Quaternion(this.x * coef, this.y * coef, this.z * coef, PApplet.cos(theta));
}
}
/**
* Returns a random unit Quaternion.
*
* <p>You can create a randomly directed unit vector using:
*
* <p>{@code PVector randomDir = new PVector(1.0f, 0.0f, 0.0f);} <br>
* {@code randomDir = Quaternion.multiply(Quaternion.randomQuaternion(), randomDir);}
*/
public static final Quaternion randomQuaternion() {
float seed = (float) Math.random();
float r1 = PApplet.sqrt(1.0f - seed);
float r2 = PApplet.sqrt(seed);
float t1 = 2.0f * PI * (float) Math.random();
float t2 = 2.0f * PI * (float) Math.random();
return new Quaternion(
PApplet.sin(t1) * r1, PApplet.cos(t1) * r1, PApplet.sin(t2) * r2, PApplet.cos(t2) * r2);
}
// A function to rotate a vector
public void rotateVector(PVector v, float theta) {
float m = v.mag();
float a = v.heading2D();
a += theta;
v.x = m * PApplet.cos(a);
v.y = m * PApplet.sin(a);
}
/**
* Convenience method to calculate <code>res</code> vertices along a circle of <code>R</code>
* radius
*
* @param R Radius of circle
* @param res Number of points to calculate
* @return
*/
public static UVertexList getCircle(float R, int res) {
UVertexList vl = new UVertexList();
float D = TWO_PI / (float) (res - 1);
for (int i = 0; i < res; i++)
vl.add(PApplet.cos(D * (float) i) * R, PApplet.sin(D * (float) i) * R, 0);
return vl;
}
void randomWalk(Mimo m) {
Simulation1.app.noiseSeed(Simulation1.app.millis());
float speed = Simulation1.app.noise(Simulation1.app.frameCount * 0.1f) * maxSpeed;
if (Simulation1.app.random(1) < 0.99) {
return;
}
float a =
PApplet.map(
Simulation1.app.random(1), 0, 1, directionChangeRange.x, directionChangeRange.y);
m.vel = new PVector(PApplet.cos(a), PApplet.sin(a));
m.vel.mult(speed);
}
private void calculateCoordinates() {
float x = 0;
float y = 0;
float z = 0;
coordinates = new PVector[latDetail + 1][longDetail + 1];
for (int a = 0 + (int) (latDetail * bottomCrop); a <= latDetail - (latDetail * topCrop); a++) {
for (int b = 0 + (int) (longDetail * leftCrop);
b <= longDetail - (longDetail * rightCrop);
b++) {
System.out.println("A:" + a + " " + "B:" + b);
x =
radius
* PApplet.cos((PConstants.TWO_PI / longDetail) * b)
* PApplet.sin((PConstants.PI / latDetail) * a);
y =
radius
* PApplet.sin((PConstants.TWO_PI / longDetail) * b)
* PApplet.sin((PConstants.PI / latDetail) * a);
z = radius * PApplet.cos((PConstants.PI / latDetail) * a);
// guardo las coordenadas
// de sur a norte
// y de este a oeste.
//
coordinates[a][b] = new PVector(x, y, z);
}
}
}
/**
* Sets the Quaternion as a rotation of {@link #axis() axis} and {@link #angle() angle} (in
* radians).
*
* <p>The {@code axis} does not need to be normalized. A null {@code axis} will result in an
* identity Quaternion.
*
* @param axis the PVector representing the axis
* @param angle the angle in radians
*/
public void fromAxisAngle(PVector axis, float angle) {
float norm = axis.mag();
if (norm < 1E-8f) {
// Null rotation
this.x = 0.0f;
this.y = 0.0f;
this.z = 0.0f;
this.w = 1.0f;
} else {
float sin_half_angle = PApplet.sin(angle / 2.0f);
this.x = sin_half_angle * axis.x / norm;
this.y = sin_half_angle * axis.y / norm;
this.z = sin_half_angle * axis.z / norm;
this.w = PApplet.cos(angle / 2.0f);
}
}
private void update(Mimo m) {
if (m.ancestor
&& (m.pos.x <= 0
|| m.pos.x >= Simulation1.screenWidth
|| m.pos.y <= 0
|| m.pos.y >= Simulation1.screenHeight)) {
// orient the ancestor towards the center
float a =
PApplet.atan2(
Simulation1.screenHeight / 2 - m.pos.y, Simulation1.screenWidth / 2 - m.pos.x);
m.vel = new PVector(PApplet.cos(a), PApplet.sin(a));
float speed = Simulation1.app.noise(Simulation1.app.frameCount * 0.1f) * maxSpeed;
m.vel.mult(speed);
} else {
randomWalk(m);
}
m.pos.add(m.vel);
}
// Project each corner of the object onto the "ground"
void project(PVector[] _points) {
for (int p = 0; p < _points.length; p++) {
// Find the angle of the corner being project relative to the sun
PVector projection = _points[p].get();
projection.sub(Stage.source);
float angle = projection.heading2D();
// Calculate the distance of projection
// Based on height of the point from the "ground" as defined by the
// alt
float _alt = PApplet.abs(_points[p].y - Stage.alt);
float yOffset = _alt * PApplet.sin(angle);
float radius = yOffset / PApplet.sin(angle);
shadow[p] = _points[p].get();
shadow[p].add(new PVector(radius * PApplet.cos(angle), radius * PApplet.sin(angle)));
// println("Source: " + source + "\t" + "Point: " + p + "\t" +
// "Angle: " + degrees(angle) + "\t" + "Offset: " + offset);
}
}
/**
* Rotate the vector by an angle (only 2D vectors), magnitude remains the same
*
* @param theta the angle of rotation
*/
public void rotate(float theta) {
float xTemp = x;
// Might need to check for rounding errors like with angleBetween function?
x = x * PApplet.cos(theta) - y * PApplet.sin(theta);
y = xTemp * PApplet.sin(theta) + y * PApplet.cos(theta);
}