Java tutorial
/* * Copyright (C) 2016 Google Inc. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.google.android.apps.santatracker.doodles.shared.physics; import android.graphics.Canvas; import android.graphics.Color; import android.graphics.Paint; import com.google.android.apps.santatracker.doodles.shared.Vector2D; import com.google.android.apps.santatracker.doodles.tilt.Constants; import com.google.android.apps.santatracker.doodles.tilt.SwimmingFragment; import org.json.JSONArray; import org.json.JSONException; import org.json.JSONObject; import java.util.ArrayList; import java.util.List; /** * A general polygon class (either concave or convex) which can tell whether or not a point * is inside of it. * * <p>NOTE: vertex winding order affects the normals of the line segments, and can affect things * like collisions. A non-inverted (normals pointed out) polygon should have its vertices wound * clockwise.</p> * */ public class Polygon { private static final String TAG = Polygon.class.getSimpleName(); private static final float EPSILON = 0.0001f; private static final float VERTEX_RADIUS = 10; private Paint vertexPaint; private Paint midpointPaint; private Paint linePaint; public List<Vector2D> vertices; public List<Vector2D> normals; public Vector2D min; public Vector2D max; private boolean isInverted; public Polygon(List<Vector2D> vertices) { this.vertices = vertices; min = Vector2D.get(0, 0); max = Vector2D.get(0, 0); vertexPaint = new Paint(Paint.ANTI_ALIAS_FLAG); vertexPaint.setColor(Color.RED); midpointPaint = new Paint(Paint.ANTI_ALIAS_FLAG); midpointPaint.setColor(Color.GREEN); midpointPaint.setAlpha(100); linePaint = new Paint(Paint.ANTI_ALIAS_FLAG); linePaint.setColor(Color.WHITE); linePaint.setStrokeWidth(5); updateExtents(); updateInversionStatus(); calculateNormals(); } public void updateExtents() { min.set(this.vertices.get(0)); max.set(this.vertices.get(0)); for (int i = 0; i < vertices.size(); i++) { Vector2D point = vertices.get(i); min.x = Math.min(min.x, point.x); min.y = Math.min(min.y, point.y); max.x = Math.max(max.x, point.x); max.y = Math.max(max.y, point.y); } } public void calculateNormals() { normals = new ArrayList<>(); for (int i = 0; i < vertices.size(); i++) { Vector2D start = vertices.get(i); Vector2D end = vertices.get((i + 1) % vertices.size()); normals.add(Vector2D.get(end).subtract(start).toNormal()); } } public float getWidth() { return max.x - min.x; } public float getHeight() { return max.y - min.y; } public void moveTo(float x, float y) { float deltaX = x - min.x; float deltaY = y - min.y; move(deltaX, deltaY); } public void move(float x, float y) { for (int i = 0; i < vertices.size(); i++) { Vector2D vertex = vertices.get(i); vertex.x += x; vertex.y += y; } // Rather than update the extents by checking all of the vertices here, we can just update them // manually (they will move by the same amount as the rest of the vertices). min.x += x; min.y += y; max.x += x; max.y += y; } public void moveVertex(int index, Vector2D delta) { Vector2D vertex = vertices.get(index); vertex.x += delta.x; vertex.y += delta.y; updateExtents(); updateInversionStatus(); } public void addVertexAfter(int index) { int nextIndex = index < vertices.size() - 1 ? index + 1 : 0; Vector2D newVertex = Util.getMidpoint(vertices.get(index), vertices.get(nextIndex)); vertices.add(nextIndex, newVertex); updateExtents(); calculateNormals(); } public void removeVertexAt(int index) { vertices.remove(index); updateExtents(); } /** * Return the index of the vertex selected by the given point. * * @param point the point at which to check for a selected vertex. * @param scale the scale of the world, for slackening the selection radius if needed. * @return the index of the selected vertex, or -1 if no vertex was selected. */ public int getSelectedIndex(Vector2D point, float scale) { for (int i = 0; i < vertices.size(); i++) { Vector2D vertex = vertices.get(i); if (point.distanceTo(vertex) < Math.max(Constants.SELECTION_RADIUS, Constants.SELECTION_RADIUS / scale)) { return i; } } return -1; } public int getMidpointIndex(Vector2D point, float scale) { for (int i = 0; i < vertices.size(); i++) { Vector2D start = vertices.get(i); Vector2D end = vertices.get(i < vertices.size() - 1 ? i + 1 : 0); if (point.distanceTo(Util.getMidpoint(start, end)) < Math.max(Constants.SELECTION_RADIUS, Constants.SELECTION_RADIUS / scale)) { return i; } } return -1; } /** * Return whether or not this polygon is inverted (i.e., whether or not the polygon has a normal * which points inwards. * * @return true if the polygon is inverted, false otherwise. */ public boolean isInverted() { return isInverted; } /** * Calculate whether or not this polygon is inverted. This checks to see if the point which is one * unit in the normal direction on the polygon's first segment is within the bounds of the * polygon. If this is the case, then the normal points inwards and the polygon is inverted. * Otherwise, the polygon is not inverted. * * <p>Note: This doesn't deal with polygons which are partially inverted. These sorts of polygons * should be avoided, as they will break this function.</p> */ private void updateInversionStatus() { Vector2D start = vertices.get(0); Vector2D end = vertices.get(1); Vector2D midpoint = Util.getMidpoint(start, end); Vector2D normal = Vector2D.get(end).subtract(start).toNormal().scale(0.1f); if (contains(midpoint.add(normal))) { isInverted = true; } else { isInverted = false; } normal.release(); midpoint.release(); } /** * Return whether or not this polygon's collision boundaries contain a given point. A polygon * contains a point iff the point is contained within the polygon's collision boundaries, * regardless of the direction of the polygon's normals. * * @param point the point to check * @return true if this polygon contains the point, false otherwise. */ public boolean contains(Vector2D point) { // If the bounding box doesn't contain the point, we don't need to do any more calculations. if (!Util.pointIsWithinBounds(min, max, point)) { return false; } // Cast vertical ray from point to outside polygon and counting crossings. Point is in polygon // iff number of edges crossed is odd. // Find a Y value that's definitely outside the polygon. float maxY = max.y + 1; Vector2D outsidePoint = Vector2D.get(point.x, maxY); // Check how many edges lie between (p.x, p.y) and (p.x, maxY). boolean inside = false; for (int i = 0; i < vertices.size(); i++) { Vector2D p1 = vertices.get(i); Vector2D p2; if (i < vertices.size() - 1) { p2 = vertices.get(i + 1); } else { p2 = vertices.get(0); } // First check endpoints. Hitting left-most point counts, hitting right-most // doesn't (to weed out case where ray hits 2 lines at their joining vertex) } if (p1.y >= point.y && Math.abs(p1.x - point.x) <= EPSILON) { if (p2.x >= point.x) { inside = !inside; } continue; } else if (p2.y >= point.y && Math.abs(p2.x - point.x) <= EPSILON) { if (p1.x >= point.x) { inside = !inside; } continue; } // Now check for intersection. if (Util.lineSegmentIntersectsLineSegment(p1, p2, point, outsidePoint)) { inside = !inside; } } outsidePoint.release(); return inside; } public LineSegment getIntersectingLineSegment(Vector2D p, Vector2D q) { for (int i = 0; i < vertices.size(); i++) { Vector2D p1 = vertices.get(i); Vector2D p2; if (i < vertices.size() - 1) { p2 = vertices.get(i + 1); } else { p2 = vertices.get(0); } if (Util.lineSegmentIntersectsLineSegment(p1, p2, p, q)) { return new LineSegment(p1, p2); } } return null; } public void draw(Canvas canvas) { if (!(SwimmingFragment.editorMode)) { return; } for (int i = 0; i < vertices.size(); i++) { Vector2D start = vertices.get(i); Vector2D end; if (i < vertices.size() - 1) { end = vertices.get(i + 1); } else { end = vertices.get(0); } Vector2D midpoint = Util.getMidpoint(start, end); Vector2D normal = Vector2D.get(end).subtract(start).toNormal(); canvas.drawCircle(start.x, start.y, VERTEX_RADIUS, vertexPaint); canvas.drawLine(start.x, start.y, end.x, end.y, linePaint); canvas.drawCircle(midpoint.x, midpoint.y, VERTEX_RADIUS / 2, midpointPaint); canvas.drawLine(midpoint.x, midpoint.y, midpoint.x + normal.x * 20, midpoint.y + normal.y * 20, linePaint); midpoint.release(); normal.release(); } } public void setPaintColors(int vertexColor, int lineColor, int midpointColor) { vertexPaint.setColor(vertexColor); linePaint.setColor(lineColor); midpointPaint.setColor(midpointColor); } public JSONArray toJSON() throws JSONException { JSONArray json = new JSONArray(); for (int i = 0; i < vertices.size(); i++) { JSONObject vertexJson = new JSONObject(); Vector2D vertex = vertices.get(i); vertexJson.put("x", (double) vertex.x); vertexJson.put("y", (double) vertex.y); json.put(vertexJson); } return json; } public static Polygon fromJSON(JSONArray json) throws JSONException { List<Vector2D> vertices = new ArrayList<>(); for (int i = 0; i < json.length(); i++) { JSONObject vertexJson = json.getJSONObject(i); Vector2D vertex = Vector2D.get((float) vertexJson.getDouble("x"), (float) vertexJson.getDouble("y")); vertices.add(vertex); } return new Polygon(vertices); } /** * A class to specify the starting and ending point of a line segment. Currently only used in * determining which line segment is being collided with, so we can determine the normal vector. */ public static class LineSegment { public Vector2D start; public Vector2D end; public LineSegment(Vector2D start, Vector2D end) { this.start = start; this.end = end; } public Vector2D getDirection() { return Vector2D.get(end).subtract(start); } } }