public Vector getSurfaceNormal(Coordinates c) { Vector s = immerseVector(c, ddu); Vector t = immerseVector(c, ddv); s.normalize(); t.normalize(); return s.crossProduct(t); }
public static Transform rotate(final double angle, final Vector vector) { vector.normalize(); final double sin = Math.sin(Math.toRadians(angle)); final double cos = Math.cos(Math.toRadians(angle)); final double[][] m = new double[4][4]; m[0][0] = vector.getX() * vector.getX() + (1.0D - vector.getX() * vector.getX()) * cos; m[0][1] = vector.getX() * vector.getY() * (1.0D - cos) - vector.getZ() * sin; m[0][2] = vector.getX() * vector.getZ() * (1.0D - cos) + vector.getY() * sin; m[0][3] = 0.0D; m[1][0] = vector.getX() * vector.getY() * (1.0D - cos) + vector.getZ() * sin; m[1][1] = vector.getY() * vector.getY() + (1.0D - vector.getY() * vector.getY()) * cos; m[1][2] = vector.getY() * vector.getZ() * (1.0D - cos) - vector.getX() * sin; m[1][3] = 0.0D; m[2][0] = vector.getX() * vector.getZ() * (1.0D - cos) - vector.getY() * sin; m[2][1] = vector.getY() * vector.getZ() * (1.0D - cos) + vector.getX() * sin; m[2][2] = vector.getZ() * vector.getZ() + (1.0D - vector.getZ() * vector.getZ()) * cos; m[2][3] = 0.0D; m[3][0] = 0.0D; m[3][1] = 0.0D; m[3][2] = 0.0D; m[3][3] = 1.0D; final Matrix matrix = Matrix.newInstance(m); final Matrix matrixInversed = matrix.transpose(); return newInstance(matrix, matrixInversed); }
void Update(Vector target, List<Enemy> enem, int i, Background BACK) { if (State == 2 || State == 3) { timeRecoil++; if (timeRecoil >= timerRecoil) { State = 0; timeRecoil = 0; recoilVel = new Vector(0, 0); } } if (State != 1) { Vector deltaPos = new Vector(0, 0); if (State == 2 || State == 3) { deltaPos = recoilVel; } else { vel = new Vector(target.x - pos.x, target.y - pos.y); vel.normalize(); deltaPos = new Vector(vel.x * speed, vel.y * speed); } for (int k = 0; k < enem.size(); k++) { if (k != i) { Vector4 A = collisions.Coll(this, enem.get(k)); if (A.B < 0) { Vector proj = deltaPos.proj(A.A); Vector perp = deltaPos.proj(new Vector(-A.A.y, A.A.x)); if (proj.SizeSQ() > A.B * A.B) { Vector M = new Vector(A.A.x * A.B, A.A.y * A.B); if (M.dot(proj) < 0) { deltaPos = new Vector(perp.x, perp.y); } else { deltaPos = new Vector(A.A.x * A.B + perp.x, A.A.y * A.B + perp.y); } } } } } deltaPos.normalize(); vel = deltaPos; this.UpdatePos(BACK); if (State != 2 && State != 3) { angle = Math.atan2(vel.y, vel.x); angle = (angle * 360) / (2 * Math.PI); } this.animate(); } else if (State == 1) { if (AttackTimer >= ATTACKT) { State = 0; AttackTimer = 0; } else { AttackTimer++; } } }
private void calculateReflectionVector() { r = Vector.add( l, Vector.multiplyVector( n, (2 * Vector.dotProduct(l, n) / (Math.pow(n.getMagnitude(), 2)))) .neg()); r.normalize(); }
// This method is wrong, but yields an OK approximation. public Coordinates move(Coordinates start, Vector direction, double distance) { Vector v = new Vector(direction); v.normalize(); v.scale(distance); Coordinates retval = new Coordinates(start.u, start.v); retval.u += v.components[0]; retval.v += v.components[1]; return retval; }
public void testNormalize() throws Exception { Vector val = test.normalize(); double mag = Math.sqrt(1.1 * 1.1 + 2.2 * 2.2 + 3.3 * 3.3); for (int i = 0; i < test.size(); i++) { if (i % 2 == 0) { assertEquals("get [" + i + ']', 0.0, val.get(i)); } else { assertEquals("dot", values[i / 2] / mag, val.get(i)); } } }
@Override public boolean onTouchEvent(MotionEvent event) { int x = (int) event.getX(); int y = (int) event.getY(); int[] colors = new int[] {Color.RED, Color.GREEN, Color.BLUE, Color.YELLOW}; // color = colors[new Random().nextInt(colors.length)]; // radius = new Random().nextInt(30) + 50; // 引力 Vector touch = new Vector(x, y); acc = Vector.sub(touch, loca); acc.normalize(); acc.mult(15.0f); return super.onTouchEvent(event); }
@Override public final Vector getNormal() { if (normal != null) { return normal; } else if (vectors.size() < 3) { return null; } else { Vector vector1 = vectors.get(0).copy(); Vector vector2 = vectors.get(1); Vector vector3 = vectors.get(2).copy(); Vector vector4; vector1.subtract(vector2); vector3.subtract(vector2); vector4 = Vector.toCrossProduct(vector3, vector1); vector4.normalize(); return vector4; } }
public static Transform lookAt(final Point source, final Point target, final Vector up) { final double[][] m = new double[4][4]; m[0][3] = source.getX(); m[1][3] = source.getY(); m[2][3] = source.getZ(); m[3][3] = 1.0D; final Vector direction = Vector.copyAndSubtract(target, source).normalize(); final Vector vector0 = Vector.copyAndNormalize(up); final Vector vector1 = Vector.toCrossProduct(vector0, direction); if (vector1.length() == 0.0D) { return newInstance(); } final Vector vector2 = vector1.normalize(); final Vector vector3 = Vector.toCrossProduct(direction, vector2); m[0][0] = vector2.getX(); m[1][0] = vector2.getY(); m[2][0] = vector2.getZ(); m[3][0] = 0.0D; m[0][1] = vector3.getX(); m[1][1] = vector3.getY(); m[2][1] = vector3.getZ(); m[3][1] = 0.0D; m[0][2] = direction.getX(); m[1][2] = direction.getY(); m[2][2] = direction.getZ(); m[3][2] = 0.0D; final Matrix matrix = Matrix.newInstance(m); return newInstance(matrix.inverse(), matrix); }
public void display(GLAutoDrawable drawable) { update(); GL2 gl = drawable.getGL().getGL2(); // Clear Color Buffer, Depth Buffer gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT); Matrix TmpMatrix = new Matrix(); // Temporary MATRIX Structure ( NEW ) Vector TmpVector = new Vector(), TmpNormal = new Vector(); // Temporary // VECTOR // Structures // ( NEW ) gl.glLoadIdentity(); // Reset The Matrix if (outlineSmooth) { // Check To See If We Want Anti-Aliased Lines ( NEW // ) gl.glHint(GL2.GL_LINE_SMOOTH_HINT, GL2.GL_NICEST); // Use The Good // Calculations // ( NEW ) gl.glEnable(GL2.GL_LINE_SMOOTH); // Enable Anti-Aliasing ( NEW ) } else // We Don't Want Smooth Lines ( NEW ) gl.glDisable(GL2.GL_LINE_SMOOTH); // Disable Anti-Aliasing ( NEW ) gl.glTranslatef(0.0f, 0.0f, -2.0f); // Move 2 Units Away From The Screen // ( NEW ) gl.glRotatef(modelAngle, 0.0f, 1.0f, 0.0f); // Rotate The Model On It's // Y-Axis ( NEW ) gl.glGetFloatv(GLMatrixFunc.GL_MODELVIEW_MATRIX, TmpMatrix.Data, 0); // Get // The // Generated // Matrix // ( // NEW // ) // Cel-Shading Code // gl.glEnable(GL2.GL_TEXTURE_1D); // Enable 1D Texturing ( NEW ) gl.glBindTexture(GL2.GL_TEXTURE_1D, shaderTexture[0]); // Bind Our // Texture ( NEW // ) gl.glColor3f(1.0f, 1.0f, 1.0f); // Set The Color Of The Model ( NEW ) gl.glBegin(GL2.GL_TRIANGLES); // Tell OpenGL That We're Drawing // Triangles // Loop Through Each Polygon for (int i = 0; i < polyNum; i++) // Loop Through Each Vertex for (int j = 0; j < 3; j++) { // Fill Up The TmpNormal Structure With TmpNormal.X = polyData[i].Verts[j].Nor.X; // The Current Vertices' Normal Values TmpNormal.Y = polyData[i].Verts[j].Nor.Y; TmpNormal.Z = polyData[i].Verts[j].Nor.Z; // Rotate This By The Matrix TmpMatrix.rotateVector(TmpNormal, TmpVector); // Normalize The New Normal TmpVector.normalize(); // Calculate The Shade Value float TmpShade = Vector.dotProduct(TmpVector, lightAngle); // Clamp The Value to 0 If Negative ( NEW ) if (TmpShade < 0.0f) { TmpShade = 0.0f; } // Set The Texture Co-ordinate As The Shade Value gl.glTexCoord1f(TmpShade); // Send The Vertex Position gl.glVertex3f( polyData[i].Verts[j].Pos.X, polyData[i].Verts[j].Pos.Y, polyData[i].Verts[j].Pos.Z); } gl.glEnd(); // Tell OpenGL To Finish Drawing gl.glDisable(GL2.GL_TEXTURE_1D); // Disable 1D Textures ( NEW ) // Outline Code // Check To See If We Want To Draw The Outline if (outlineDraw) { // Enable Blending gl.glEnable(GL2.GL_BLEND); // Set The Blend Mode gl.glBlendFunc(GL2.GL_SRC_ALPHA, GL2.GL_ONE_MINUS_SRC_ALPHA); // Draw Backfacing Polygons As Wireframes gl.glPolygonMode(GL2.GL_BACK, GL2.GL_LINE); // Set The Line Width gl.glLineWidth(outlineWidth); // Don't Draw Any Front-Facing Polygons gl.glCullFace(GL2.GL_FRONT); // Change The Depth Mode gl.glDepthFunc(GL2.GL_LEQUAL); // Set The Outline Color gl.glColor3fv(outlineColor, 0); // Tell OpenGL What We Want To Draw gl.glBegin(GL2.GL_TRIANGLES); // Loop Through Each Polygon for (int i = 0; i < polyNum; i++) { // Loop Through Each Vertex for (int j = 0; j < 3; j++) { // Send The Vertex Position gl.glVertex3f( polyData[i].Verts[j].Pos.X, polyData[i].Verts[j].Pos.Y, polyData[i].Verts[j].Pos.Z); } } gl.glEnd(); // Tell OpenGL We've Finished // Reset The Depth-Testing Mode gl.glDepthFunc(GL2.GL_LESS); // Reset The Face To Be Culled gl.glCullFace(GL2.GL_BACK); // Reset Back-Facing Polygon Drawing Mode gl.glPolygonMode(GL2.GL_BACK, GL2.GL_FILL); // Disable Blending gl.glDisable(GL2.GL_BLEND); } // Check To See If Rotation Is Enabled if (modelRotate) { // Update Angle Based On The Clock modelAngle += .2f; } }
public void init(GLAutoDrawable drawable) { GL2 gl = drawable.getGL().getGL2(); // Storage for the 96 Shader Values ( NEW ) FloatBuffer shaderData = GLBuffers.newDirectFloatBuffer(96); // Start Of User Initialization // Really Nice perspective calculations Light Grey Background gl.glHint(GL2.GL_PERSPECTIVE_CORRECTION_HINT, GL2.GL_NICEST); gl.glClearColor(0.7f, 0.7f, 0.7f, 0.0f); // Depth Buffer Setup gl.glClearDepth(1.0f); // Enable Depth Testing gl.glEnable(GL2.GL_DEPTH_TEST); // The Type Of Depth Test To Do gl.glDepthFunc(GL2.GL_LESS); // Enables Smooth Color Shading ( NEW ) gl.glShadeModel(GL2.GL_SMOOTH); // Initially Disable Line Smoothing ( NEW ) gl.glDisable(GL2.GL_LINE_SMOOTH); // Enable OpenGL Face Culling ( NEW ) gl.glEnable(GL2.GL_CULL_FACE); // Disable OpenGL Lighting ( NEW ) gl.glDisable(GL2.GL_LIGHTING); StringBuffer readShaderData = new StringBuffer(); try { InputStream inputStream = ResourceRetriever.getResourceAsStream("demos/data/models/Shader.txt"); int info; while ((info = inputStream.read()) != -1) readShaderData.append((char) info); inputStream.close(); } catch (IOException e) { e.printStackTrace(); throw new RuntimeException(e); } StringTokenizer tokenizer = new StringTokenizer(readShaderData.toString()); // Loop Though The 32 Greyscale Values while (tokenizer.hasMoreTokens()) { float value = Float.parseFloat(tokenizer.nextToken()); shaderData.put(value); shaderData.put(value); shaderData.put(value); } shaderData.flip(); gl.glGenTextures(1, shaderTexture, 0); // Get A Free Texture ID ( NEW ) gl.glBindTexture(GL2.GL_TEXTURE_1D, shaderTexture[0]); // Bind This // Texture. From // Now On It // Will Be 1D // For Crying Out Loud Don't Let OpenGL Use Bi/Trilinear Filtering! gl.glTexParameteri(GL2.GL_TEXTURE_1D, GL2.GL_TEXTURE_MAG_FILTER, GL2.GL_NEAREST); gl.glTexParameteri(GL2.GL_TEXTURE_1D, GL2.GL_TEXTURE_MIN_FILTER, GL2.GL_NEAREST); gl.glTexImage1D( GL2.GL_TEXTURE_1D, 0, GL2.GL_RGB, 32, 0, GL2.GL_RGB, GL2.GL_FLOAT, shaderData); // Upload // Set The X Direction lightAngle.X = 0.0f; // Set The Y Direction lightAngle.Y = 0.0f; // Set The Z Direction lightAngle.Z = 1.0f; lightAngle.normalize(); try { // Return The Value Of ReadMesh readMesh(); } catch (IOException e) { throw new RuntimeException(e); } }
private void normalizeVectors() { l.normalize(); v.normalize(); n.normalize(); }
@Override public final BoundingBox getBounds() { BoundingBox boundingBox = BoundingBox.newInstance(); double minimum = Double.MAX_VALUE; Vector u = Vector.newInstance(0.0D, 0.0D, 0.0D); Vector v; Vector d = Vector.newInstance(0.0D, 0.0D, 0.0D); int size = vectors.size(); for (int i = 0; i < size; i++) { Vector vector1 = vectors.get((i + 1) % size); Vector vector2 = vectors.get(i); u.set(vector1); u.subtract(vector2); u.normalize(); v = Vector.toCrossProduct(getNormal(), u); v.normalize(); double uMaximum = 0.0D; double uMinimum = 0.0D; double vMaximum = 0.0D; double vMinimum = 0.0D; for (int j = 0; j < size; j++) { if (i != j) { Vector vector3 = vectors.get(j); d.set(vector3); d.subtract(vector2); double uLength = d.getDotProduct(u); double vLength = d.getDotProduct(v); uMaximum = Math.max(uLength, uMaximum); uMinimum = Math.min(uLength, uMinimum); vMaximum = Math.max(vLength, vMaximum); vMinimum = Math.min(vLength, vMinimum); } } double current = (uMaximum - uMinimum) * (vMaximum - vMinimum); if (current < minimum) { minimum = current; Vector origin = boundingBox.getOrigin(); origin.set(vector2); d.set(u); d.multiply(uMinimum); origin.add(d); d.set(v); d.multiply(vMinimum); origin.add(d); boundingBox.getU().set(u); boundingBox.getV().set(v); boundingBox.setHeight(vMaximum - vMinimum); boundingBox.setWidth(uMaximum - uMinimum); } } return boundingBox; }