public void processKeyboard() {
if (isKeyDown(GLFW_KEY_W)) position = position.add(getLookVector());
if (isKeyDown(GLFW_KEY_S)) position = position.add(getLookVector().negate());
if (isKeyDown(GLFW_KEY_A)) position = position.add(getLookVector().cross(new Vec3(0, 1, 0)));
if (isKeyDown(GLFW_KEY_D))
position = position.add(getLookVector().cross(new Vec3(0, 1, 0).negate()));
if (isKeyDown(GLFW_KEY_LEFT_SHIFT)) position.y += speed;
if (isKeyDown(GLFW_KEY_SPACE)) position.y -= speed;
}
// Build table that maps vertex indices to
// vertex positions for "even vertices" in
// Loop subdivision scheme.
//
protected Hashtable<Integer, Vec3> evenLoopVerts() {
Hashtable<Integer, Vec3> evenVerts = new Hashtable<Integer, Vec3>();
for (int i = 0; i < V.size(); i++) {
Vector<Vec3> adjVerts = new Vector<Vec3>();
Vert v = V.get(i);
Vec3 vCoord = (Vec3) v.coord.clone();
// grow a list of adjacent verts, use the
// number of adjacent verts to calculate B
// then scale and combine adjacent verts
Edge e = E.get(v.e);
Edge nextEdge = e;
do {
nextEdge = E.get(nextEdge.next);
adjVerts.add((Vec3) V.get(nextEdge.v).coord.clone());
nextEdge = E.get(E.get(nextEdge.next).sym);
} while (nextEdge.i != e.i);
float n = adjVerts.size();
float B;
if (n > 3) B = 3.0f / (8 * n);
else B = 3.0f / 16.0f;
// scale vCoord and the adjacent verts
// and combine them
vCoord = vCoord.scale(1 - n * B);
for (int j = 0; j < adjVerts.size(); j++) vCoord = Vec3.add(vCoord, adjVerts.get(j).scale(B));
// vCoord is now our new even loop vert Vec3
evenVerts.put(v.i, vCoord);
}
return evenVerts;
}
public void setNormals() {
// first get normals for all faces
int numFaces = F.size();
for (Face f : F) {
Edge e = E.get(f.e);
Vec3 v1 = V.get(e.v).coord;
e = E.get(e.next);
Vec3 v2 = V.get(e.v).coord;
e = E.get(e.next);
Vec3 v3 = V.get(e.v).coord;
// set the normal for this face
Vec3 U = Vec3.sub(v2, v1);
Vec3 V = Vec3.sub(v3, v1);
float nx = U.y * V.z - U.z * V.y;
float ny = U.z * V.x - U.x * V.z;
float nz = U.x * V.y - U.y * V.x;
f.norm = new Vec3(nx, ny, nz);
f.norm.normalize();
}
// next set normals for all vertices
for (Vert v : V) {
Vector<Vec3> norms = new Vector<Vec3>();
Edge e = E.get(v.e);
Edge eNext = e; // E.get(E.get(e.sym).next);
do {
// get eNext's Face's norm and store it for combining later
norms.add(F.get(eNext.f).norm);
eNext = E.get(E.get(eNext.sym).next);
} while (e.i != eNext.i);
// combine scaled norms here and set v.norm
float scale = 1.0f / norms.size();
Vec3 vNorm = new Vec3(0, 0, 0);
for (int i = 0; i < norms.size(); i++)
vNorm = Vec3.add(vNorm, norms.get(i)); // .scale(scale));
v.norm = vNorm;
v.norm.normalize();
}
}
//
// Build table that maps edge indices to
// vertex positions for "odd vertices" in
// Loop subdivision scheme.
//
protected Hashtable<Integer, Vec3> oddLoopVerts() {
// get and store index of sym edges for each
// edge index we map to a vertex position
// so we don't replicate odd vertices
Hashtable<Integer, Vec3> oddVerts = new Hashtable<Integer, Vec3>();
for (int i = 0; i < E.size(); i++) {
Edge edge = E.get(i);
if (edge.i < E.get(edge.sym).i) {
// current edge indexed for this face hasn't been split yet
// get the 4 relative vertices, then scale and combine
Vec3 v1 = (Vec3) V.get(edge.v).coord.clone();
Vec3 v2 = (Vec3) V.get(E.get(edge.next).v).coord.clone();
Vec3 v3 = (Vec3) V.get(E.get(edge.prev).v).coord.clone();
Vec3 v4 = (Vec3) V.get(E.get(E.get(edge.sym).prev).v).coord.clone();
v1 = v1.scale(3.0f / 8.0f);
v2 = v2.scale(3.0f / 8.0f);
v3 = v3.scale(1.0f / 8.0f);
v4 = v4.scale(1.0f / 8.0f);
Vec3 finalVert = Vec3.add(v1, Vec3.add(v2, Vec3.add(v3, v4)));
oddVerts.put(edge.i, Vec3.add(v1, Vec3.add(v2, Vec3.add(v3, v4))));
}
}
return oddVerts;
}
public void draw(GL2 gl) {
if (particles.size() == 0) return;
switch (blendMode) {
case 0: // '\0'
gl.glDisable(3042);
gl.glDisable(3008);
break;
case 1: // '\001'
gl.glEnable(3042);
gl.glDisable(3008);
gl.glBlendFunc(768, 1);
break;
case 2: // '\002'
gl.glEnable(3042);
gl.glDisable(3008);
gl.glBlendFunc(770, 1);
break;
case 3: // '\003'
gl.glDisable(3042);
gl.glEnable(3008);
break;
case 4: // '\004'
gl.glEnable(3042);
gl.glDisable(3008);
gl.glBlendFunc(770, 1);
break;
}
gl.glBindTexture(3553, model.mMaterials[texture].mTextureId);
gl.glPushMatrix();
if (particleType == 0 || particleType == 2) {
if ((flags & 0x1000) == 0) {
Vec3 view = new Vec3(viewer.getCamera().getPosition());
view.normalize();
Vec3 right = Vec3.cross(view, new Vec3(0.0F, 0.0F, 1.0F)).normalize();
Vec3 up = Vec3.cross(right, view).normalize();
int tcStart = 0;
if (flags == 0x40019) tcStart++;
gl.glBegin(7);
int count = particles.size();
Vec3 pos = new Vec3();
Vec3 cPos = new Vec3();
Vec3 ofs = new Vec3();
for (int i = 0; i < count; i++) {
Particle p = (Particle) particles.get(i);
if (p.tile < texCoords.size()) {
gl.glColor4f(p.color.x, p.color.y, p.color.z, p.color.w);
Point2f tc[] = (Point2f[]) texCoords.get(p.tile);
Vec3.add(right, up, ofs);
cPos.set(p.pos);
Vec3.sub(cPos, ofs.scale(p.size), pos);
gl.glTexCoord2f(tc[tcStart % 4].x, tc[tcStart % 4].y);
gl.glVertex3f(pos.x, pos.y, pos.z);
Vec3.sub(right, up, ofs);
Vec3.add(cPos, ofs.scale(p.size), pos);
gl.glTexCoord2f(tc[(tcStart + 1) % 4].x, tc[(tcStart + 1) % 4].y);
gl.glVertex3f(pos.x, pos.y, pos.z);
Vec3.add(right, up, ofs);
Vec3.add(cPos, ofs.scale(p.size), pos);
gl.glTexCoord2f(tc[(tcStart + 2) % 4].x, tc[(tcStart + 2) % 4].y);
gl.glVertex3f(pos.x, pos.y, pos.z);
Vec3.sub(right, up, ofs);
Vec3.sub(cPos, ofs.scale(p.size), pos);
gl.glTexCoord2f(tc[(tcStart + 3) % 4].x, tc[(tcStart + 3) % 4].y);
gl.glVertex3f(pos.x, pos.y, pos.z);
}
}
gl.glEnd();
} else {
gl.glBegin(7);
int count = particles.size();
Vec3 pos = new Vec3();
Vec3 ofs = new Vec3();
for (int i = 0; i < count; i++) {
Particle p = (Particle) particles.get(i);
if (p.tile < texCoords.size()) {
gl.glColor4f(p.color.x, p.color.y, p.color.z, p.color.w);
Point2f tc[] = (Point2f[]) texCoords.get(p.tile);
Vec3.add(p.pos, Vec3.scale(p.corners[0], p.size, ofs), pos);
gl.glTexCoord2f(tc[0].x, tc[0].y);
gl.glVertex3f(pos.x, pos.y, pos.z);
Vec3.add(p.pos, Vec3.scale(p.corners[1], p.size, ofs), pos);
gl.glTexCoord2f(tc[1].x, tc[1].y);
gl.glVertex3f(pos.x, pos.y, pos.z);
Vec3.add(p.pos, Vec3.scale(p.corners[2], p.size, ofs), pos);
gl.glTexCoord2f(tc[2].x, tc[2].y);
gl.glVertex3f(pos.x, pos.y, pos.z);
Vec3.add(p.pos, Vec3.scale(p.corners[3], p.size, ofs), pos);
gl.glTexCoord2f(tc[3].x, tc[3].y);
gl.glVertex3f(pos.x, pos.y, pos.z);
}
}
gl.glEnd();
}
} else if (particleType == 1) {
gl.glBegin(7);
int count = particles.size();
Vec3 pos = new Vec3();
Vec3 ofs = new Vec3();
float f = 1.0F;
Vec3 bv0 = new Vec3(-f, f, 0.0F);
Vec3 bv1 = new Vec3(f, f, 0.0F);
for (int i = 0; i < count; i++) {
Particle p = (Particle) particles.get(i);
if (p.tile >= texCoords.size() - 1) break;
gl.glColor4f(p.color.x, p.color.y, p.color.z, p.color.w);
Point2f tc[] = (Point2f[]) texCoords.get(p.tile);
Vec3.add(p.pos, Vec3.scale(bv0, p.size, ofs), pos);
gl.glTexCoord2f(tc[0].x, tc[0].y);
gl.glVertex3f(pos.x, pos.y, pos.z);
Vec3.add(p.pos, Vec3.scale(bv1, p.size, ofs), pos);
gl.glTexCoord2f(tc[1].x, tc[1].y);
gl.glVertex3f(pos.x, pos.y, pos.z);
Vec3.add(p.origin, Vec3.scale(bv1, p.size, ofs), pos);
gl.glTexCoord2f(tc[2].x, tc[2].y);
gl.glVertex3f(pos.x, pos.y, pos.z);
Vec3.add(p.origin, Vec3.scale(bv0, p.size, ofs), pos);
gl.glTexCoord2f(tc[3].x, tc[3].y);
gl.glVertex3f(pos.x, pos.y, pos.z);
}
gl.glEnd();
}
gl.glPopMatrix();
}
