@Override
public void nextFrame(StageGameState b) {
// if animation is halfway through
MeshAnimationController animControl =
(MeshAnimationController) character.model.getController(0);
if (phase == 0
&& animControl.getCurTime() + b.tpf >= animControl.getAnimationLength("cast") / 2) {
phase++;
// calculate transformations
Vector3f rotation = character.rotationVector;
float angle = FastMath.atan2(rotation.x, rotation.z);
Vector3f translation = new Vector3f(2 * FastMath.sin(angle), 3.7f, 2 * FastMath.cos(angle));
Echo e = (Echo) LoadingQueue.quickLoad(new Echo(getUsers(), target), b);
e.rotate(rotation);
e.setVelocity(rotation.mult(e.speed));
e.model.setLocalTranslation(character.model.getWorldTranslation().add(translation));
b.getRootNode().updateRenderState();
} else if (character.play("cast", b.tpf)) {
finish();
}
}
private static boolean coplanarTriTri(
Vector3f n, Vector3f v0, Vector3f v1, Vector3f v2, Vector3f u0, Vector3f u1, Vector3f u2) {
Vector3f a = new Vector3f();
short i0, i1;
a.x = FastMath.abs(n.x);
a.y = FastMath.abs(n.y);
a.z = FastMath.abs(n.z);
if (a.x > a.y) {
if (a.x > a.z) {
i0 = 1; /* a[0] is greatest */
i1 = 2;
} else {
i0 = 0; /* a[2] is greatest */
i1 = 1;
}
} else /* a[0] <=a[1] */ {
if (a.z > a.y) {
i0 = 0; /* a[2] is greatest */
i1 = 1;
} else {
i0 = 0; /* a[1] is greatest */
i1 = 2;
}
}
/* test all edges of triangle 1 against the edges of triangle 2 */
float[] v0f = new float[3];
v0.toArray(v0f);
float[] v1f = new float[3];
v1.toArray(v1f);
float[] v2f = new float[3];
v2.toArray(v2f);
float[] u0f = new float[3];
u0.toArray(u0f);
float[] u1f = new float[3];
u1.toArray(u1f);
float[] u2f = new float[3];
u2.toArray(u2f);
if (edgeAgainstTriEdges(v0f, v1f, u0f, u1f, u2f, i0, i1)) {
return true;
}
if (edgeAgainstTriEdges(v1f, v2f, u0f, u1f, u2f, i0, i1)) {
return true;
}
if (edgeAgainstTriEdges(v2f, v0f, u0f, u1f, u2f, i0, i1)) {
return true;
}
/* finally, test if tri1 is totally contained in tri2 or vice versa */
pointInTri(v0f, u0f, u1f, u2f, i0, i1);
pointInTri(u0f, v0f, v1f, v2f, i0, i1);
return false;
}
private void readNormal(Vector3f norm) {
int zenith = file.readByte();
int azimuth = file.readByte();
float lat = (zenith * 2 * FastMath.PI) / 255;
float lng = (azimuth * 2 * FastMath.PI) / 255;
norm.x = FastMath.cos(lat) * FastMath.sin(lng);
norm.y = FastMath.sin(lat) * FastMath.sin(lng);
norm.z = FastMath.cos(lng);
}
public float getHeight(float x, float z, float time) {
float zval = z * scaleybig * 4f + time * speedbig * 4f;
float height = FastMath.sin(zval);
height *= heightbig;
if (octaves > 0) {
float height2 =
(float) ImprovedNoise.noise(x * scaleybig, z * scalexbig, time * speedbig) * heightbig;
height = height * 0.4f + height2 * 0.6f;
}
if (octaves > 1)
height +=
ImprovedNoise.noise(x * scaleysmall, z * scalexsmall, time * speedsmall) * heightsmall;
if (octaves > 2)
height +=
ImprovedNoise.noise(
x * scaleysmall * 2.0f, z * scalexsmall * 2.0f, time * speedsmall * 1.5f)
* heightsmall
* 0.5f;
if (octaves > 3)
height +=
ImprovedNoise.noise(
x * scaleysmall * 4.0f, z * scalexsmall * 4.0f, time * speedsmall * 2.0f)
* heightsmall
* 0.25f;
return height; // + waterHeight
}
public void updateRotationMatrix() {
if (oldEmit.equals(worldEmit)) return;
float upDotEmit = upVector.dot(worldEmit);
if (FastMath.abs(upDotEmit) > 1.0d - FastMath.DBL_EPSILON) {
absUpVector.x = upVector.x <= 0.0f ? -upVector.x : upVector.x;
absUpVector.y = upVector.y <= 0.0f ? -upVector.y : upVector.y;
absUpVector.z = upVector.z <= 0.0f ? -upVector.z : upVector.z;
if (absUpVector.x < absUpVector.y) {
if (absUpVector.x < absUpVector.z) {
absUpVector.x = 1.0f;
absUpVector.y = absUpVector.z = 0.0f;
} else {
absUpVector.z = 1.0f;
absUpVector.x = absUpVector.y = 0.0f;
}
} else if (absUpVector.y < absUpVector.z) {
absUpVector.y = 1.0f;
absUpVector.x = absUpVector.z = 0.0f;
} else {
absUpVector.z = 1.0f;
absUpVector.x = absUpVector.y = 0.0f;
}
absUpVector.subtract(upVector, abUpMinUp);
absUpVector.subtract(worldEmit, upXemit);
float f4 = 2.0f / abUpMinUp.dot(abUpMinUp);
float f6 = 2.0f / upXemit.dot(upXemit);
float f8 = f4 * f6 * abUpMinUp.dot(upXemit);
float af1[] = {abUpMinUp.x, abUpMinUp.y, abUpMinUp.z};
float af2[] = {upXemit.x, upXemit.y, upXemit.z};
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
matData[i][j] = (-f4 * af1[i] * af1[j] - f6 * af2[i] * af2[j]) + f8 * af2[i] * af1[j];
}
matData[i][i]++;
}
} else {
upVector.cross(worldEmit, upXemit);
float f2 = 1.0f / (1.0f + upDotEmit);
float f5 = f2 * upXemit.x;
float f7 = f2 * upXemit.z;
float f9 = f5 * upXemit.y;
float f10 = f5 * upXemit.z;
float f11 = f7 * upXemit.y;
matData[0][0] = upDotEmit + f5 * upXemit.x;
matData[0][1] = f9 - upXemit.z;
matData[0][2] = f10 + upXemit.y;
matData[1][0] = f9 + upXemit.z;
matData[1][1] = upDotEmit + f2 * upXemit.y * upXemit.y;
matData[1][2] = f11 - upXemit.x;
matData[2][0] = f10 - upXemit.y;
matData[2][1] = f11 + upXemit.x;
matData[2][2] = upDotEmit + f7 * upXemit.z;
}
rotMatrix.set(matData);
oldEmit.set(worldEmit);
}
@Override
public void nextFrame(StageGameState b) {
if (phase == 0 && character.play("raiseUp", b.tpf)) {
// allow to animate
character.animationLock = false;
phase++;
} else if (phase >= 1 && phase < numFires + 1 && frameCount % delay == 0) {
// determine spawn point
float a = FastMath.nextRandomFloat() * FastMath.PI * 2;
float p = FastMath.nextRandomFloat() * FastMath.PI * 2;
Vector3f translation =
new Vector3f(
radius * FastMath.sin(p) * FastMath.sin(a),
radius * FastMath.cos(p),
radius * FastMath.sin(p) * FastMath.cos(a));
Fire fire = (Fire) LoadingQueue.quickLoad(new Fire(getUsers()), b);
fire.setVelocity(translation.mult(.2f / (float) radius));
fire.model.setLocalTranslation(character.model.getLocalTranslation().add(translation));
b.getRootNode().updateRenderState();
phase++;
} else if (phase >= numFires + 1) {
finish();
}
}
/**
* Initialize a chase camera with the given dynamic view as target.
*
* @param view The target <code>DynamicView</code> instance.
*/
public void initializeCameraHandler(DynamicView view) {
view.updateGeometricState(0, false);
this.cameraHandler =
new SnowmanCameraHandler(
DisplaySystem.getDisplaySystem().getRenderer().getCamera(), view, this.game);
Vector3f targetOffset = new Vector3f(0, 0, 0);
targetOffset.setY(((BoundingBox) view.getWorldBound()).yExtent * 1.5f);
this.cameraHandler.setTargetOffset(targetOffset);
Vector3f dir = view.getLocalRotation().mult(new Vector3f(0, 0, -1));
Vector3f store = new Vector3f();
this.cameraHandler.setAzimuth(FastMath.cartesianToSpherical(dir, store).y);
}
/**
* Generate a random velocity within the parameters of max angle and the rotation matrix.
*
* @param pSpeed a vector to store the results in.
*/
protected Vector3f getRandomVelocity(Vector3f pSpeed) {
float randDir = FastMath.TWO_PI * FastMath.nextRandomFloat();
float randAngle = getRandomAngle();
if (pSpeed == null) pSpeed = new Vector3f();
pSpeed.x = FastMath.cos(randDir) * FastMath.sin(randAngle);
pSpeed.y = FastMath.cos(randAngle);
pSpeed.z = FastMath.sin(randDir) * FastMath.sin(randAngle);
rotateVectorSpeed(pSpeed);
pSpeed.multLocal(getInitialVelocity());
return pSpeed;
}
/**
* generate a random lifespan between the min and max lifespan of the particle system.
*
* @return the generated lifespan value
*/
public float getRandomLifeSpan() {
return getMinimumLifeTime()
+ ((getMaximumLifeTime() - getMinimumLifeTime()) * FastMath.nextRandomFloat());
}
/**
* Returns a random angle between the min and max angles.
*
* @return the random angle.
*/
public float getRandomAngle() {
return getMinimumAngle() + FastMath.nextRandomFloat() * (getMaximumAngle() - getMinimumAngle());
}
/**
* Calculates an object's distance from the 0,0,0 location
*
* @param s The object who's distance is being calculated.
* @return The distance wrapped into a Vector3f
*/
public static Vector3f getDistanceFromZero(Spatial s) {
logger.debug("Examining " + s.getName());
Vector3f closest = null;
Vector3f temp = new Vector3f(0, 0, 0);
int faceCount;
if (s instanceof TriMesh) {
faceCount = ((TriMesh) s).getTriangleCount();
FloatBuffer vb = ((TriMesh) s).getVertexBuffer();
vb.rewind();
for (int i = 0; i < faceCount; i++) {
// If we are on the first run, then the first
// vertex is the closest.
if (i == 0) {
closest = new Vector3f(vb.get(0), vb.get(1), vb.get(2));
continue;
}
// if this isn't the first run, set the temp vertex
temp.x = vb.get(i * 3);
temp.y = vb.get(i * 3 + 1);
temp.z = vb.get(i * 3 + 2);
// compare i, all three values need to be closer to 0
if (FastMath.abs(temp.x) < FastMath.abs(closest.x)
&& FastMath.abs(temp.y) < FastMath.abs(closest.y)
&& FastMath.abs(temp.z) < FastMath.abs(closest.z)) {
closest = temp.clone();
}
}
return closest;
}
if (s instanceof QuadMesh) {
faceCount = ((QuadMesh) s).getQuadCount();
FloatBuffer vb = ((QuadMesh) s).getVertexBuffer();
vb.rewind();
for (int i = 0; i < faceCount; i++) {
// If we are on the first run, then the first
// vertex is the closest.
if (i == 0) {
closest = new Vector3f(vb.get(0), vb.get(1), vb.get(2));
continue;
}
// if this isn't the first run, set the temp vertex
temp.x = vb.get(i * 4);
temp.y = vb.get(i * 4 + 1);
temp.z = vb.get(i * 4 + 2);
// compare i, all three values need to be closer to 0
if (FastMath.abs(temp.x) < FastMath.abs(closest.x)
&& FastMath.abs(temp.y) < FastMath.abs(closest.y)
&& FastMath.abs(temp.z) < FastMath.abs(closest.z)) {
closest = temp.clone();
}
}
return closest;
}
if (s instanceof Node) {
if (((Node) s).getChildren() == null) {
logger.warn("initial node null");
return new Vector3f(0, 0, 0);
}
for (Spatial child : ((Node) s).getChildren()) {
// if the child is a node with no children, don't pass it
if (child instanceof Node) {
if (((Node) child).getChildren() == null) {
logger.debug("Ignoring Node: " + child.getName() + " with no children.");
continue;
}
}
Vector3f childLocation = getDistanceFromZero(child);
// check if distance was returned null. This should only happen
// if a Node with no children was checked against.
if (childLocation == null) continue;
// closest will be null on the first run
if (closest == null) {
closest = childLocation.clone();
continue;
}
if (FastMath.abs(childLocation.x) < FastMath.abs(closest.x)
&& FastMath.abs(childLocation.y) < FastMath.abs(closest.y)
&& FastMath.abs(childLocation.z) < FastMath.abs(closest.z)) {
closest = childLocation.clone();
}
}
if (closest == null) return new Vector3f(0, 0, 0);
else return closest;
}
logger.warn("Un-Implemented Geometry Type Given");
throw new IllegalArgumentException("Un-Implemented Geometry Type Given");
}
/**
* This method tests for the intersection between two triangles defined by their vertexes.
* Converted to java from C code found at http://www.acm.org/jgt/papers/Moller97/tritri.html
*
* @param v0 First triangle's first vertex.
* @param v1 First triangle's second vertex.
* @param v2 First triangle's third vertex.
* @param u0 Second triangle's first vertex.
* @param u1 Second triangle's second vertex.
* @param u2 Second triangle's third vertex.
* @return True if the two triangles intersect, false otherwise.
*/
public static boolean intersection(
Vector3f v0, Vector3f v1, Vector3f v2, Vector3f u0, Vector3f u1, Vector3f u2) {
Vector3f e1 = tempVa;
Vector3f e2 = tempVb;
Vector3f n1 = tempVc;
Vector3f n2 = tempVd;
float d1, d2;
float du0, du1, du2, dv0, dv1, dv2;
Vector3f d = tempVe;
float[] isect1 = tempFa;
float[] isect2 = tempFb;
float du0du1, du0du2, dv0dv1, dv0dv2;
short index;
float vp0, vp1, vp2;
float up0, up1, up2;
float bb, cc, max;
float xx, yy, xxyy, tmp;
/* compute plane equation of triangle(v0,v1,v2) */
v1.subtract(v0, e1);
v2.subtract(v0, e2);
e1.cross(e2, n1);
d1 = -n1.dot(v0);
/* plane equation 1: n1.X+d1=0 */
/*
* put u0,u1,u2 into plane equation 1 to compute signed distances to the
* plane
*/
du0 = n1.dot(u0) + d1;
du1 = n1.dot(u1) + d1;
du2 = n1.dot(u2) + d1;
/* coplanarity robustness check */
if (FastMath.abs(du0) < EPSILON) du0 = 0.0f;
if (FastMath.abs(du1) < EPSILON) du1 = 0.0f;
if (FastMath.abs(du2) < EPSILON) du2 = 0.0f;
du0du1 = du0 * du1;
du0du2 = du0 * du2;
if (du0du1 > 0.0f && du0du2 > 0.0f) {
return false;
}
/* compute plane of triangle (u0,u1,u2) */
u1.subtract(u0, e1);
u2.subtract(u0, e2);
e1.cross(e2, n2);
d2 = -n2.dot(u0);
/* plane equation 2: n2.X+d2=0 */
/* put v0,v1,v2 into plane equation 2 */
dv0 = n2.dot(v0) + d2;
dv1 = n2.dot(v1) + d2;
dv2 = n2.dot(v2) + d2;
if (FastMath.abs(dv0) < EPSILON) dv0 = 0.0f;
if (FastMath.abs(dv1) < EPSILON) dv1 = 0.0f;
if (FastMath.abs(dv2) < EPSILON) dv2 = 0.0f;
dv0dv1 = dv0 * dv1;
dv0dv2 = dv0 * dv2;
if (dv0dv1 > 0.0f && dv0dv2 > 0.0f) {
/*
* same sign on all of them + not
* equal 0 ?
*/
return false; /* no intersection occurs */
}
/* compute direction of intersection line */
n1.cross(n2, d);
/* compute and index to the largest component of d */
max = FastMath.abs(d.x);
index = 0;
bb = FastMath.abs(d.y);
cc = FastMath.abs(d.z);
if (bb > max) {
max = bb;
index = 1;
}
if (cc > max) {
max = cc;
vp0 = v0.z;
vp1 = v1.z;
vp2 = v2.z;
up0 = u0.z;
up1 = u1.z;
up2 = u2.z;
} else if (index == 1) {
vp0 = v0.y;
vp1 = v1.y;
vp2 = v2.y;
up0 = u0.y;
up1 = u1.y;
up2 = u2.y;
} else {
vp0 = v0.x;
vp1 = v1.x;
vp2 = v2.x;
up0 = u0.x;
up1 = u1.x;
up2 = u2.x;
}
/* compute interval for triangle 1 */
Vector3f abc = tempVa;
Vector2f x0x1 = tempV2a;
if (newComputeIntervals(vp0, vp1, vp2, dv0, dv1, dv2, dv0dv1, dv0dv2, abc, x0x1)) {
return coplanarTriTri(n1, v0, v1, v2, u0, u1, u2);
}
/* compute interval for triangle 2 */
Vector3f def = tempVb;
Vector2f y0y1 = tempV2b;
if (newComputeIntervals(up0, up1, up2, du0, du1, du2, du0du1, du0du2, def, y0y1)) {
return coplanarTriTri(n1, v0, v1, v2, u0, u1, u2);
}
xx = x0x1.x * x0x1.y;
yy = y0y1.x * y0y1.y;
xxyy = xx * yy;
tmp = abc.x * xxyy;
isect1[0] = tmp + abc.y * x0x1.y * yy;
isect1[1] = tmp + abc.z * x0x1.x * yy;
tmp = def.x * xxyy;
isect2[0] = tmp + def.y * xx * y0y1.y;
isect2[1] = tmp + def.z * xx * y0y1.x;
sort(isect1);
sort(isect2);
if (isect1[1] < isect2[0] || isect2[1] < isect1[0]) {
return false;
}
return true;
}