Java 类com.badlogic.gdx.utils.FloatArray 实例源码

private void aabbCompute () {
    float minX = Integer.MAX_VALUE, minY = Integer.MAX_VALUE, maxX = Integer.MIN_VALUE, maxY = Integer.MIN_VALUE;
    Array<FloatArray> polygons = this.polygons;
    for (int i = 0, n = polygons.size; i < n; i++) {
        FloatArray polygon = polygons.get(i);
        float[] vertices = polygon.items;
        for (int ii = 0, nn = polygon.size; ii < nn; ii += 2) {
            float x = vertices[ii];
            float y = vertices[ii + 1];
            minX = Math.min(minX, x);
            minY = Math.min(minY, y);
            maxX = Math.max(maxX, x);
            maxY = Math.max(maxY, y);
        }
    }
    this.minX = minX;
    this.minY = minY;
    this.maxX = maxX;
    this.maxY = maxY;
}

/** Returns true if the polygon contains the point. */
public boolean containsPoint (FloatArray polygon, float x, float y) {
    float[] vertices = polygon.items;
    int nn = polygon.size;

    int prevIndex = nn - 2;
    boolean inside = false;
    for (int ii = 0; ii < nn; ii += 2) {
        float vertexY = vertices[ii + 1];
        float prevY = vertices[prevIndex + 1];
        if ((vertexY < y && prevY >= y) || (prevY < y && vertexY >= y)) {
            float vertexX = vertices[ii];
            if (vertexX + (y - vertexY) / (prevY - vertexY) * (vertices[prevIndex] - vertexX) < x) inside = !inside;
        }
        prevIndex = ii;
    }
    return inside;
}

/** Returns true if the polygon contains any part of the line segment. */
public boolean intersectsSegment (FloatArray polygon, float x1, float y1, float x2, float y2) {
    float[] vertices = polygon.items;
    int nn = polygon.size;

    float width12 = x1 - x2, height12 = y1 - y2;
    float det1 = x1 * y2 - y1 * x2;
    float x3 = vertices[nn - 2], y3 = vertices[nn - 1];
    for (int ii = 0; ii < nn; ii += 2) {
        float x4 = vertices[ii], y4 = vertices[ii + 1];
        float det2 = x3 * y4 - y3 * x4;
        float width34 = x3 - x4, height34 = y3 - y4;
        float det3 = width12 * height34 - height12 * width34;
        float x = (det1 * width34 - width12 * det2) / det3;
        if (((x >= x3 && x <= x4) || (x >= x4 && x <= x3)) && ((x >= x1 && x <= x2) || (x >= x2 && x <= x1))) {
            float y = (det1 * height34 - height12 * det2) / det3;
            if (((y >= y3 && y <= y4) || (y >= y4 && y <= y3)) && ((y >= y1 && y <= y2) || (y >= y2 && y <= y1))) return true;
        }
        x3 = x4;
        y3 = y4;
    }
    return false;
}

private Vertices readVertices (DataInput input, int vertexCount) throws IOException {
    int verticesLength = vertexCount << 1;
    Vertices vertices = new Vertices();
    if (!input.readBoolean()) {
        vertices.vertices = readFloatArray(input, verticesLength, scale);
        return vertices;
    }
    FloatArray weights = new FloatArray(verticesLength * 3 * 3);
    IntArray bonesArray = new IntArray(verticesLength * 3);
    for (int i = 0; i < vertexCount; i++) {
        int boneCount = input.readInt(true);
        bonesArray.add(boneCount);
        for (int ii = 0; ii < boneCount; ii++) {
            bonesArray.add(input.readInt(true));
            weights.add(input.readFloat() * scale);
            weights.add(input.readFloat() * scale);
            weights.add(input.readFloat());
        }
    }
    vertices.vertices = weights.toArray();
    vertices.bones = bonesArray.toArray();
    return vertices;
}

private void readVertices (JsonValue map, VertexAttachment attachment, int verticesLength) {
    attachment.setWorldVerticesLength(verticesLength);
    float[] vertices = map.require("vertices").asFloatArray();
    if (verticesLength == vertices.length) {
        if (scale != 1) {
            for (int i = 0, n = vertices.length; i < n; i++)
                vertices[i] *= scale;
        }
        attachment.setVertices(vertices);
        return;
    }
    FloatArray weights = new FloatArray(verticesLength * 3 * 3);
    IntArray bones = new IntArray(verticesLength * 3);
    for (int i = 0, n = vertices.length; i < n;) {
        int boneCount = (int)vertices[i++];
        bones.add(boneCount);
        for (int nn = i + boneCount * 4; i < nn; i += 4) {
            bones.add((int)vertices[i]);
            weights.add(vertices[i + 1] * scale);
            weights.add(vertices[i + 2] * scale);
            weights.add(vertices[i + 3]);
        }
    }
    attachment.setBones(bones.toArray());
    attachment.setVertices(weights.toArray());
}

public float[] getFlatPixelArray() {
    FloatArray floats = new FloatArray();
    flatPixelArray = new float[width * height * 3];

    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            float r = pixels[y][x][0];
            float g = pixels[y][x][1];
            float b = pixels[y][x][2];

            floats.addAll(r, g, b);
        }
    }

    for (int i = 0; i < floats.size; i++) {
        flatPixelArray[i] = floats.get(i);
    }

    floats.clear();

    return flatPixelArray;
}

/** Creates chain light from specified vertices
 * 
 * @param rayHandler not {@code null} instance of RayHandler
 * @param rays number of rays - more rays make light to look more realistic but will decrease performance, can't be less than
 *           MIN_RAYS
 * @param color color, set to {@code null} to use the default color
 * @param distance distance of light
 * @param rayDirection direction of rays
 *           <ul>
 *           <li>1 = left</li>
 *           <li>-1 = right</li>
 *           </ul>
 * @param chain float array of (x, y) vertices from which rays will be evenly distributed */
public RavChainLight (RayHandler rayHandler, int rays, Color color, float distance, int rayDirection, float[] chain) {
    super(rayHandler, rays, color, distance, 0f);

    rayStartOffset = ChainLight.defaultRayStartOffset;
    this.rayDirection = rayDirection;
    vertexNum = (vertexNum - 1) * 2;
    endX = new float[rays];
    endY = new float[rays];
    startX = new float[rays];
    startY = new float[rays];
    this.chain = (chain != null) ? new FloatArray(chain) : new FloatArray();

    lightMesh = new Mesh(VertexDataType.VertexArray, false, vertexNum, 0,
        new VertexAttribute(Usage.Position, 2, "vertex_positions"), new VertexAttribute(Usage.ColorPacked, 4, "quad_colors"),
        new VertexAttribute(Usage.Generic, 1, "s"));
    softShadowMesh = new Mesh(VertexDataType.VertexArray, false, vertexNum * 2, 0,
        new VertexAttribute(Usage.Position, 2, "vertex_positions"), new VertexAttribute(Usage.ColorPacked, 4, "quad_colors"),
        new VertexAttribute(Usage.Generic, 1, "s"));
    setMesh();
}

/** Draws a polygon, using ray start and end points as vertices */
public void debugRender (PolygonShapeRenderer shapeRenderer) {
    shapeRenderer.setColor(Color.BLUE);
    FloatArray vertices = Pools.obtain(FloatArray.class);
    vertices.clear();
    for (int i = 0; i < rayNum; i++) {
        vertices.addAll(mx[i], my[i]);
    }
    for (int i = rayNum - 1; i > -1; i--) {
        vertices.addAll(startX[i], startY[i]);
    }
    vertices.add(vertices.get(0));
    vertices.add(vertices.get(1));
    shapeRenderer.polyline(vertices.shrink());
    Pools.free(vertices);
}

private void aabbCompute () {
    float minX = Integer.MAX_VALUE, minY = Integer.MAX_VALUE, maxX = Integer.MIN_VALUE, maxY = Integer.MIN_VALUE;
    Array<FloatArray> polygons = this.polygons;
    for (int i = 0, n = polygons.size; i < n; i++) {
        FloatArray polygon = polygons.get(i);
        float[] vertices = polygon.items;
        for (int ii = 0, nn = polygon.size; ii < nn; ii += 2) {
            float x = vertices[ii];
            float y = vertices[ii + 1];
            minX = Math.min(minX, x);
            minY = Math.min(minY, y);
            maxX = Math.max(maxX, x);
            maxY = Math.max(maxY, y);
        }
    }
    this.minX = minX;
    this.minY = minY;
    this.maxX = maxX;
    this.maxY = maxY;
}

/** Returns true if the polygon contains the point. */
public boolean containsPoint (FloatArray polygon, float x, float y) {
    float[] vertices = polygon.items;
    int nn = polygon.size;

    int prevIndex = nn - 2;
    boolean inside = false;
    for (int ii = 0; ii < nn; ii += 2) {
        float vertexY = vertices[ii + 1];
        float prevY = vertices[prevIndex + 1];
        if ((vertexY < y && prevY >= y) || (prevY < y && vertexY >= y)) {
            float vertexX = vertices[ii];
            if (vertexX + (y - vertexY) / (prevY - vertexY) * (vertices[prevIndex] - vertexX) < x) inside = !inside;
        }
        prevIndex = ii;
    }
    return inside;
}

/** Returns true if the polygon contains the line segment. */
public boolean intersectsSegment (FloatArray polygon, float x1, float y1, float x2, float y2) {
    float[] vertices = polygon.items;
    int nn = polygon.size;

    float width12 = x1 - x2, height12 = y1 - y2;
    float det1 = x1 * y2 - y1 * x2;
    float x3 = vertices[nn - 2], y3 = vertices[nn - 1];
    for (int ii = 0; ii < nn; ii += 2) {
        float x4 = vertices[ii], y4 = vertices[ii + 1];
        float det2 = x3 * y4 - y3 * x4;
        float width34 = x3 - x4, height34 = y3 - y4;
        float det3 = width12 * height34 - height12 * width34;
        float x = (det1 * width34 - width12 * det2) / det3;
        if (((x >= x3 && x <= x4) || (x >= x4 && x <= x3)) && ((x >= x1 && x <= x2) || (x >= x2 && x <= x1))) {
            float y = (det1 * height34 - height12 * det2) / det3;
            if (((y >= y3 && y <= y4) || (y >= y4 && y <= y3)) && ((y >= y1 && y <= y2) || (y >= y2 && y <= y1))) return true;
        }
        x3 = x4;
        y3 = y4;
    }
    return false;
}

private void aabbCompute () {
    float minX = Integer.MAX_VALUE, minY = Integer.MAX_VALUE, maxX = Integer.MIN_VALUE, maxY = Integer.MIN_VALUE;
    Array<FloatArray> polygons = this.polygons;
    for (int i = 0, n = polygons.size; i < n; i++) {
        FloatArray polygon = polygons.get(i);
        float[] vertices = polygon.items;
        for (int ii = 0, nn = polygon.size; ii < nn; ii += 2) {
            float x = vertices[ii];
            float y = vertices[ii + 1];
            minX = Math.min(minX, x);
            minY = Math.min(minY, y);
            maxX = Math.max(maxX, x);
            maxY = Math.max(maxY, y);
        }
    }
    this.minX = minX;
    this.minY = minY;
    this.maxX = maxX;
    this.maxY = maxY;
}

/** Returns true if the polygon contains the point. */
public boolean containsPoint (FloatArray polygon, float x, float y) {
    float[] vertices = polygon.items;
    int nn = polygon.size;

    int prevIndex = nn - 2;
    boolean inside = false;
    for (int ii = 0; ii < nn; ii += 2) {
        float vertexY = vertices[ii + 1];
        float prevY = vertices[prevIndex + 1];
        if ((vertexY < y && prevY >= y) || (prevY < y && vertexY >= y)) {
            float vertexX = vertices[ii];
            if (vertexX + (y - vertexY) / (prevY - vertexY) * (vertices[prevIndex] - vertexX) < x) inside = !inside;
        }
        prevIndex = ii;
    }
    return inside;
}

/** Returns true if the polygon contains the line segment. */
public boolean intersectsSegment (FloatArray polygon, float x1, float y1, float x2, float y2) {
    float[] vertices = polygon.items;
    int nn = polygon.size;

    float width12 = x1 - x2, height12 = y1 - y2;
    float det1 = x1 * y2 - y1 * x2;
    float x3 = vertices[nn - 2], y3 = vertices[nn - 1];
    for (int ii = 0; ii < nn; ii += 2) {
        float x4 = vertices[ii], y4 = vertices[ii + 1];
        float det2 = x3 * y4 - y3 * x4;
        float width34 = x3 - x4, height34 = y3 - y4;
        float det3 = width12 * height34 - height12 * width34;
        float x = (det1 * width34 - width12 * det2) / det3;
        if (((x >= x3 && x <= x4) || (x >= x4 && x <= x3)) && ((x >= x1 && x <= x2) || (x >= x2 && x <= x1))) {
            float y = (det1 * height34 - height12 * det2) / det3;
            if (((y >= y3 && y <= y4) || (y >= y4 && y <= y3)) && ((y >= y1 && y <= y2) || (y >= y2 && y <= y1))) return true;
        }
        x3 = x4;
        y3 = y4;
    }
    return false;
}

/** @see #intersectSegments(float, float, float, float, float[], boolean, com.badlogic.gdx.utils.FloatArray) */
public static void intersectSegments(Vector2 a, Vector2 b, float[] segments, boolean polygon, Array<Vector2> intersections) {
    FloatArray fa = Pools.obtain(FloatArray.class);
    intersectSegments(a.x, a.y, b.x, b.y, segments, polygon, fa);
    if(fa.size < 1) {
        intersections.clear();
        Pools.free(fa);
        return;
    }
    intersections.ensureCapacity(fa.size / 2 - intersections.size);
    for(int i = 1; i < fa.size; i += 2)
        if(intersections.size > i / 2)
            intersections.get(i / 2).set(fa.get(i - 1), fa.get(i));
        else
            intersections.add(new Vector2(fa.get(i - 1), fa.get(i)));
    Pools.free(fa);
}

/** @param segments the segments
 *  @param polygon if the segments represent a closed polygon
 *  @param intersections the array to store the intersections in */
public static void intersectSegments(float x1, float y1, float x2, float y2, float[] segments, boolean polygon, FloatArray intersections) {
    if(polygon && segments.length < 6)
        throw new IllegalArgumentException("a polygon consists of at least 3 points: " + segments.length);
    else if(segments.length < 4)
        throw new IllegalArgumentException("segments does not contain enough vertices to represent at least one segment: " + segments.length);
    if(segments.length % 2 != 0)
        throw new IllegalArgumentException("malformed segments; the number of vertices is not dividable by 2: " + segments.length);
    intersections.clear();
    Vector2 tmp = Pools.obtain(Vector2.class);
    for(int i = 0, n = segments.length - (polygon ? 0 : 2); i < n; i += 2) {
        float x3 = segments[i], y3 = segments[i + 1], x4 = wrapIndex(i + 2, segments), y4 = wrapIndex(i + 3, segments);
        if(Intersector.intersectSegments(x1, y1, x2, y2, x3, y3, x4, y4, tmp)) {
            intersections.add(tmp.x);
            intersections.add(tmp.y);
        }
    }
    Pools.free(tmp);
}

@Override
public void mesh() {
    if (meshRequest && !meshing) {
        if (!loaded) return;
        meshing = true;
        opaqueMeshData = new FloatArray();
        transpMeshData = new FloatArray();
        try {
            getVertices();
            int opaqueNumVerts = opaqueMeshData.size / VERTEX_SIZE;
            int transpNumVerts = transpMeshData.size / VERTEX_SIZE;
            opaqueVerts = opaqueNumVerts / 4 * 6;
            transpVerts = transpNumVerts / 4 * 6;
            meshRequest = false;
            doneMeshing = true;
            meshing = false;
        } catch (Exception e) {
            meshing = true;
        }
    }
}

public static void buildMeshes() {
    if (indices == null) {
        int len = 3 * 6 * 6 / 3;
        indices = new short[len];
        short j = 0;
        for (int i = 0; i < len; i += 6, j += 4) {
            indices[i + 0] = (short) (j + 0);
            indices[i + 1] = (short) (j + 1);
            indices[i + 2] = (short) (j + 2);
            indices[i + 3] = (short) (j + 2);
            indices[i + 4] = (short) (j + 3);
            indices[i + 5] = (short) (j + 0);
        }
    }

    for (Voxel v : voxels.values()) {
        v.mesh = new Mesh(true, 24, indices.length, VertexAttribute.Position(), VertexAttribute.Normal(), VertexAttribute.ColorPacked(), VertexAttribute.TexCoords(0), VertexAttribute.TexCoords(1));
        v.mesh.setIndices(indices);
        verts = new FloatArray();
        for (Direction d : Direction.values())
            new TextureFace(d, new Vector3(), v.getTextureUV(0, 0, 0, d)).getVertexData(verts);
        v.mesh.setVertices(verts.items, 0, verts.size);
    }
}

public void update (Skeleton skeleton, boolean updateAabb) {
    if (skeleton == null) throw new IllegalArgumentException("skeleton cannot be null.");
    Array<BoundingBoxAttachment> boundingBoxes = this.boundingBoxes;
    Array<FloatArray> polygons = this.polygons;
    Array<Slot> slots = skeleton.slots;
    int slotCount = slots.size;

    boundingBoxes.clear();
    polygonPool.freeAll(polygons);
    polygons.clear();

    for (int i = 0; i < slotCount; i++) {
        Slot slot = slots.get(i);
        Attachment attachment = slot.attachment;
        if (attachment instanceof BoundingBoxAttachment) {
            BoundingBoxAttachment boundingBox = (BoundingBoxAttachment)attachment;
            boundingBoxes.add(boundingBox);

            FloatArray polygon = polygonPool.obtain();
            polygons.add(polygon);
            boundingBox.computeWorldVertices(slot, polygon.setSize(boundingBox.getWorldVerticesLength()));
        }
    }

    if (updateAabb) aabbCompute();
}

private void aabbCompute () {
    float minX = Integer.MAX_VALUE, minY = Integer.MAX_VALUE, maxX = Integer.MIN_VALUE, maxY = Integer.MIN_VALUE;
    Array<FloatArray> polygons = this.polygons;
    for (int i = 0, n = polygons.size; i < n; i++) {
        FloatArray polygon = polygons.get(i);
        float[] vertices = polygon.items;
        for (int ii = 0, nn = polygon.size; ii < nn; ii += 2) {
            float x = vertices[ii];
            float y = vertices[ii + 1];
            minX = Math.min(minX, x);
            minY = Math.min(minY, y);
            maxX = Math.max(maxX, x);
            maxY = Math.max(maxY, y);
        }
    }
    this.minX = minX;
    this.minY = minY;
    this.maxX = maxX;
    this.maxY = maxY;
}

/** Returns true if the polygon contains the point. */
public boolean containsPoint (FloatArray polygon, float x, float y) {
    float[] vertices = polygon.items;
    int nn = polygon.size;

    int prevIndex = nn - 2;
    boolean inside = false;
    for (int ii = 0; ii < nn; ii += 2) {
        float vertexY = vertices[ii + 1];
        float prevY = vertices[prevIndex + 1];
        if ((vertexY < y && prevY >= y) || (prevY < y && vertexY >= y)) {
            float vertexX = vertices[ii];
            if (vertexX + (y - vertexY) / (prevY - vertexY) * (vertices[prevIndex] - vertexX) < x) inside = !inside;
        }
        prevIndex = ii;
    }
    return inside;
}

/** Returns true if the polygon contains any part of the line segment. */
public boolean intersectsSegment (FloatArray polygon, float x1, float y1, float x2, float y2) {
    float[] vertices = polygon.items;
    int nn = polygon.size;

    float width12 = x1 - x2, height12 = y1 - y2;
    float det1 = x1 * y2 - y1 * x2;
    float x3 = vertices[nn - 2], y3 = vertices[nn - 1];
    for (int ii = 0; ii < nn; ii += 2) {
        float x4 = vertices[ii], y4 = vertices[ii + 1];
        float det2 = x3 * y4 - y3 * x4;
        float width34 = x3 - x4, height34 = y3 - y4;
        float det3 = width12 * height34 - height12 * width34;
        float x = (det1 * width34 - width12 * det2) / det3;
        if (((x >= x3 && x <= x4) || (x >= x4 && x <= x3)) && ((x >= x1 && x <= x2) || (x >= x2 && x <= x1))) {
            float y = (det1 * height34 - height12 * det2) / det3;
            if (((y >= y3 && y <= y4) || (y >= y4 && y <= y3)) && ((y >= y1 && y <= y2) || (y >= y2 && y <= y1))) return true;
        }
        x3 = x4;
        y3 = y4;
    }
    return false;
}

private Vertices readVertices (DataInput input, int vertexCount) throws IOException {
    int verticesLength = vertexCount << 1;
    Vertices vertices = new Vertices();
    if (!input.readBoolean()) {
        vertices.vertices = readFloatArray(input, verticesLength, scale);
        return vertices;
    }
    FloatArray weights = new FloatArray(verticesLength * 3 * 3);
    IntArray bonesArray = new IntArray(verticesLength * 3);
    for (int i = 0; i < vertexCount; i++) {
        int boneCount = input.readInt(true);
        bonesArray.add(boneCount);
        for (int ii = 0; ii < boneCount; ii++) {
            bonesArray.add(input.readInt(true));
            weights.add(input.readFloat() * scale);
            weights.add(input.readFloat() * scale);
            weights.add(input.readFloat());
        }
    }
    vertices.vertices = weights.toArray();
    vertices.bones = bonesArray.toArray();
    return vertices;
}

private void readVertices (JsonValue map, VertexAttachment attachment, int verticesLength) {
    attachment.setWorldVerticesLength(verticesLength);
    float[] vertices = map.require("vertices").asFloatArray();
    if (verticesLength == vertices.length) {
        if (scale != 1) {
            for (int i = 0, n = vertices.length; i < n; i++)
                vertices[i] *= scale;
        }
        attachment.setVertices(vertices);
        return;
    }
    FloatArray weights = new FloatArray(verticesLength * 3 * 3);
    IntArray bones = new IntArray(verticesLength * 3);
    for (int i = 0, n = vertices.length; i < n;) {
        int boneCount = (int)vertices[i++];
        bones.add(boneCount);
        for (int nn = i + boneCount * 4; i < nn; i += 4) {
            bones.add((int)vertices[i]);
            weights.add(vertices[i + 1] * scale);
            weights.add(vertices[i + 2] * scale);
            weights.add(vertices[i + 3]);
        }
    }
    attachment.setBones(bones.toArray());
    attachment.setVertices(weights.toArray());
}

/**
 * Calculates the travel time of each segment to allow for 
 * smooth lerping along the path between 0 and 1
 */
private void calculateTimes()
{
    //find total length of the path
    float length = 0, dst = 0;
    for (int i = 1; i < points.size; i++)
    {
        dst = points.get(i).dst(points.get(i-1));
        length += dst;
    }

    //calculate percentage that each segment takes of the path's total length
    times = new FloatArray();
    times.add(0);
    float l = 0;
    for (int i = 1; i < points.size; i++)
    {
        dst = points.get(i).dst(points.get(i-1));
        l += dst;
        times.add(l/length);
    }
}

private float a(FloatArray paramFloatArray, float paramFloat1, float paramFloat2, float paramFloat3)
{
  int i1 = 0;
  if (i1 < paramFloatArray.size)
  {
    float f = paramFloatArray.items[i1];
    if (Math.abs(f - paramFloat1) < this.e.getHeight())
      if (f >= (paramFloat2 + paramFloat3) / 2.0F)
        break label67;
    label67: for (paramFloat1 += this.e.getHeight(); ; paramFloat1 -= this.e.getHeight())
    {
      i1++;
      break;
    }
  }
  return paramFloat1;
}

@Override
public void write(Kryo kryo, Output output, FloatArray array) {
    output.writeVarInt(array.size, true);
    output.writeBoolean(array.ordered);
    for (int i = 0; i < array.size; i++) {
        output.writeFloat(array.get(i));
    }
}

@Override
public FloatArray read(Kryo kryo, Input input, Class<FloatArray> type) {
    int length = input.readVarInt(true);
    boolean ordered = input.readBoolean();
    FloatArray array = new FloatArray(ordered, length);
    for (int i = 0; i < length; i++) {
        array.add(input.readFloat());
    }
    return array;
}

/** Clears any previous polygons, finds all visible bounding box attachments, and computes the world vertices for each bounding
 * box's polygon.
 * @param updateAabb If true, the axis aligned bounding box containing all the polygons is computed. If false, the
 *           SkeletonBounds AABB methods will always return true. */
public void update (Skeleton skeleton, boolean updateAabb) {
    if (skeleton == null) throw new IllegalArgumentException("skeleton cannot be null.");
    Array<BoundingBoxAttachment> boundingBoxes = this.boundingBoxes;
    Array<FloatArray> polygons = this.polygons;
    Array<Slot> slots = skeleton.slots;
    int slotCount = slots.size;

    boundingBoxes.clear();
    polygonPool.freeAll(polygons);
    polygons.clear();

    for (int i = 0; i < slotCount; i++) {
        Slot slot = slots.get(i);
        Attachment attachment = slot.attachment;
        if (attachment instanceof BoundingBoxAttachment) {
            BoundingBoxAttachment boundingBox = (BoundingBoxAttachment)attachment;
            boundingBoxes.add(boundingBox);

            FloatArray polygon = polygonPool.obtain();
            polygons.add(polygon);
            boundingBox.computeWorldVertices(slot, polygon.setSize(boundingBox.getWorldVerticesLength()));
        }
    }

    if (updateAabb)
        aabbCompute();
    else {
        minX = Integer.MIN_VALUE;
        minY = Integer.MIN_VALUE;
        maxX = Integer.MAX_VALUE;
        maxY = Integer.MAX_VALUE;
    }
}

/** Returns the first bounding box attachment that contains the point, or null. When doing many checks, it is usually more
 * efficient to only call this method if {@link #aabbContainsPoint(float, float)} returns true. */
public BoundingBoxAttachment containsPoint (float x, float y) {
    Array<FloatArray> polygons = this.polygons;
    for (int i = 0, n = polygons.size; i < n; i++)
        if (containsPoint(polygons.get(i), x, y)) return boundingBoxes.get(i);
    return null;
}

/** Returns the first bounding box attachment that contains any part of the line segment, or null. When doing many checks, it
 * is usually more efficient to only call this method if {@link #aabbIntersectsSegment(float, float, float, float)} returns
 * true. */
public BoundingBoxAttachment intersectsSegment (float x1, float y1, float x2, float y2) {
    Array<FloatArray> polygons = this.polygons;
    for (int i = 0, n = polygons.size; i < n; i++)
        if (intersectsSegment(polygons.get(i), x1, y1, x2, y2)) return boundingBoxes.get(i);
    return null;
}

/**
 * Creates chain light from specified vertices
 * 
 * @param rayHandler
 *            not {@code null} instance of RayHandler
 * @param rays
 *            number of rays - more rays make light to look more realistic
 *            but will decrease performance, can't be less than MIN_RAYS
 * @param color
 *            color, set to {@code null} to use the default color
 * @param distance
 *            distance of light
 * @param rayDirection
 *            direction of rays
 *            <ul>
 *            <li>1 = left</li>
 *            <li>-1 = right</li>
 *            </ul>
 * @param chain
 *            float array of (x, y) vertices from which rays will be
 *            evenly distributed
 */
public ChainLight(RayHandler rayHandler, int rays, Color color,
        float distance, int rayDirection, float[] chain) {

    super(rayHandler, rays, color, distance, 0f);
    rayStartOffset = ChainLight.defaultRayStartOffset;
    this.rayDirection = rayDirection;
    vertexNum = (vertexNum - 1) * 2;
    endX = new float[rays];
    endY = new float[rays];
    startX = new float[rays];
    startY = new float[rays];
    this.chain = (chain != null) ?
                 new FloatArray(chain) : new FloatArray();

    lightMesh = new Mesh(
            VertexDataType.VertexArray, false, vertexNum, 0,
            new VertexAttribute(Usage.Position, 2, "vertex_positions"),
            new VertexAttribute(Usage.ColorPacked, 4, "quad_colors"),
            new VertexAttribute(Usage.Generic, 1, "s"));
    softShadowMesh = new Mesh(
            VertexDataType.VertexArray, false, vertexNum * 2,
            0, new VertexAttribute(Usage.Position, 2, "vertex_positions"),
            new VertexAttribute(Usage.ColorPacked, 4, "quad_colors"),
            new VertexAttribute(Usage.Generic, 1, "s"));
    setMesh();
}

/**
 * Draws a polygon, using ray start and end points as vertices
 */
public void debugRender(ShapeRenderer shapeRenderer) {
    shapeRenderer.setColor(Color.YELLOW);
    FloatArray vertices = Pools.obtain(FloatArray.class);
    vertices.clear();
    for (int i = 0; i < rayNum; i++) {
        vertices.addAll(mx[i], my[i]);
    }
    for (int i = rayNum - 1; i > -1; i--) {
        vertices.addAll(startX[i], startY[i]);
    }
    shapeRenderer.polygon(vertices.shrink());
    Pools.free(vertices);
}

@Override
public boolean contains(float x, float y) {
    // fast fail
    if (!this.chainLightBounds.contains(x, y))
        return false;
    // actual check
    FloatArray vertices = Pools.obtain(FloatArray.class);
    vertices.clear();

    for (int i = 0; i < rayNum; i++) {
        vertices.addAll(mx[i], my[i]);
    }
    for (int i = rayNum - 1; i > -1; i--) {
        vertices.addAll(startX[i], startY[i]);
    }

    int intersects = 0;
    for (int i = 0; i < vertices.size; i += 2) {
        float x1 = vertices.items[i];
        float y1 = vertices.items[i + 1];
        float x2 = vertices.items[(i + 2) % vertices.size];
        float y2 = vertices.items[(i + 3) % vertices.size];
        if (((y1 <= y && y < y2) || (y2 <= y && y < y1)) &&
                x < ((x2 - x1) / (y2 - y1) * (y - y1) + x1))
            intersects++;
    }
    boolean result = (intersects & 1) == 1;

    Pools.free(vertices);
    return result;
}

/**
 * Resizes list to exact size, filling with given value when expanding.
 */
public static void resize(FloatArray list, int size, float value) {
    while (list.size < size) {
        list.add(value);
    }

    while (list.size > size) {
        list.removeIndex(list.size - 1);
    }
}

@Override
public boolean contains (float x, float y) {
    // fast fail
    if (!this.chainLightBounds.contains(x, y))
        return false;
    // actual check
    FloatArray vertices = Pools.obtain(FloatArray.class);
    vertices.clear();

    for (int i = 0; i < rayNum; i++) {
        vertices.addAll(mx[i], my[i]);
    }
    for (int i = rayNum - 1; i > -1; i--) {
        vertices.addAll(startX[i], startY[i]);
    }

    int intersects = 0;
    for (int i = 0; i < vertices.size; i += 2) {
        float x1 = vertices.items[i];
        float y1 = vertices.items[i + 1];
        float x2 = vertices.items[(i + 2) % vertices.size];
        float y2 = vertices.items[(i + 3) % vertices.size];
        if (((y1 <= y && y < y2) || (y2 <= y && y < y1)) && x < ((x2 - x1) / (y2 - y1) * (y - y1) + x1))
            intersects++;
    }
    boolean result = (intersects & 1) == 1;

    Pools.free(vertices);
    return result;
}

public void update (Skeleton skeleton, boolean updateAabb) {
    Array<BoundingBoxAttachment> boundingBoxes = this.boundingBoxes;
    Array<FloatArray> polygons = this.polygons;
    Array<Slot> slots = skeleton.slots;
    int slotCount = slots.size;

    boundingBoxes.clear();
    polygonPool.freeAll(polygons);
    polygons.clear();

    for (int i = 0; i < slotCount; i++) {
        Slot slot = slots.get(i);
        Attachment attachment = slot.attachment;
        if (attachment instanceof BoundingBoxAttachment) {
            BoundingBoxAttachment boundingBox = (BoundingBoxAttachment)attachment;
            boundingBoxes.add(boundingBox);

            FloatArray polygon = polygonPool.obtain();
            polygons.add(polygon);
            int vertexCount = boundingBox.getVertices().length;
            polygon.ensureCapacity(vertexCount);
            polygon.size = vertexCount;

            boundingBox.computeWorldVertices(slot.bone, polygon.items);
        }
    }

    if (updateAabb) aabbCompute();
}

/** Returns the first bounding box attachment that contains the point, or null. When doing many checks, it is usually more
 * efficient to only call this method if {@link #aabbContainsPoint(float, float)} returns true. */
public BoundingBoxAttachment containsPoint (float x, float y) {
    Array<FloatArray> polygons = this.polygons;
    for (int i = 0, n = polygons.size; i < n; i++)
        if (containsPoint(polygons.get(i), x, y)) return boundingBoxes.get(i);
    return null;
}

/** Returns the first bounding box attachment that contains the line segment, or null. When doing many checks, it is usually
 * more efficient to only call this method if {@link #aabbIntersectsSegment(float, float, float, float)} returns true. */
public BoundingBoxAttachment intersectsSegment (float x1, float y1, float x2, float y2) {
    Array<FloatArray> polygons = this.polygons;
    for (int i = 0, n = polygons.size; i < n; i++)
        if (intersectsSegment(polygons.get(i), x1, y1, x2, y2)) return boundingBoxes.get(i);
    return null;
}

public void update (Skeleton skeleton, boolean updateAabb) {
    Array<BoundingBoxAttachment> boundingBoxes = this.boundingBoxes;
    Array<FloatArray> polygons = this.polygons;
    Array<Slot> slots = skeleton.slots;
    int slotCount = slots.size;

    boundingBoxes.clear();
    polygonPool.freeAll(polygons);
    polygons.clear();

    for (int i = 0; i < slotCount; i++) {
        Slot slot = slots.get(i);
        Attachment attachment = slot.attachment;
        if (attachment instanceof BoundingBoxAttachment) {
            BoundingBoxAttachment boundingBox = (BoundingBoxAttachment)attachment;
            boundingBoxes.add(boundingBox);

            FloatArray polygon = polygonPool.obtain();
            polygons.add(polygon);
            int vertexCount = boundingBox.getVertices().length;
            polygon.ensureCapacity(vertexCount);
            polygon.size = vertexCount;

            boundingBox.computeWorldVertices(slot.bone, polygon.items);
        }
    }

    if (updateAabb) aabbCompute();
}