Examples with ImageLayer playn.core.ImageLayer used on opensource projects

Example 11 with ImageLayer

use of playn.core.ImageLayer in project playn by threerings.

the class SurfaceTest method addTests.

protected void addTests(final Image orange, Image tile) {
    final Pattern pattern = tile.toPattern();
    // make samples big enough to force a buffer size increase
    final int samples = 128, hsamples = samples / 2;
    final float[] verts = new float[(samples + 1) * 4];
    final int[] indices = new int[samples * 6];
    tessellateCurve(0, 40 * (float) Math.PI, verts, indices, new F() {

        public float apply(float x) {
            return (float) Math.sin(x / 20) * 50;
        }
    });
    float ygap = 20, ypos = 10;
    // draw some wide lines
    ypos = ygap + addTest(10, ypos, new ImmediateLayer.Renderer() {

        public void render(Surface surf) {
            drawLine(surf, 0, 0, 50, 50, 15);
            drawLine(surf, 70, 50, 120, 0, 10);
            drawLine(surf, 0, 70, 120, 120, 10);
        }
    }, 120, 120, "drawLine with width");
    ypos = ygap + addTest(20, ypos, new ImmediateLayer.Renderer() {

        public void render(Surface surf) {
            surf.setFillColor(0xFF0000FF).fillRect(0, 0, 100, 25);
            // these two alpha fills should look the same
            surf.setFillColor(0x80FF0000).fillRect(0, 0, 50, 25);
            surf.setAlpha(0.5f).setFillColor(0xFFFF0000).fillRect(50, 0, 50, 25).setAlpha(1f);
        }
    }, 100, 25, "left and right half both same color");
    ypos = ygap + addTest(20, ypos, new ImmediateLayer.Renderer() {

        public void render(Surface surf) {
            surf.setFillColor(0xFF0000FF).fillRect(0, 0, 100, 50);
            surf.setAlpha(0.5f);
            surf.drawImage(orange, 55, 5);
            surf.fillRect(0, 50, 50, 50);
            surf.drawImage(orange, 55, 55);
            surf.setAlpha(1f);
        }
    }, 100, 100, "fillRect and drawImage at 50% alpha");
    ypos = 10;
    ypos = ygap + addTest(160, ypos, new ImmediateLayer.Renderer() {

        public void render(Surface surf) {
            // fill some shapes with patterns
            surf.setFillPattern(pattern).fillRect(10, 0, 100, 100);
            // use same fill pattern for the triangles
            surf.translate(0, 160);
            // render a sliding window of half of our triangles to test the slice rendering
            surf.fillTriangles(verts, offset * 4, (hsamples + 1) * 4, indices, offset * 6, hsamples * 6, offset * 2);
            offset += doff;
            if (offset == 0)
                doff = 1;
            else if (offset == hsamples)
                doff = -1;
        }

        private int offset = 0, doff = 1;
    }, 120, 210, "ImmediateLayer patterned fillRect, fillTriangles");
    SurfaceImage patted = graphics().createSurface(100, 100);
    patted.surface().setFillPattern(pattern).fillRect(0, 0, 100, 100);
    ypos = ygap + addTest(170, ypos, graphics().createImageLayer(patted), "SurfaceImage patterned fillRect");
    ypos = 10;
    // fill a patterned quad in a clipped group layer
    final int twidth = 150, theight = 75;
    GroupLayer group = graphics().createGroupLayer();
    ypos = ygap + addTest(315, 10, group, twidth, theight, "Clipped pattern should not exceed grey rectangle");
    group.add(graphics().createImmediateLayer(new ImmediateLayer.Renderer() {

        public void render(Surface surf) {
            surf.setFillColor(0xFFCCCCCC).fillRect(0, 0, twidth, theight);
        }
    }));
    group.add(graphics().createImmediateLayer(twidth, theight, new ImmediateLayer.Renderer() {

        public void render(Surface surf) {
            surf.setFillPattern(pattern).fillRect(-10, -10, twidth + 20, theight + 20);
        }
    }));
    // draw some randomly jiggling dots inside a bounded region
    dotBox = new Rectangle(315, ypos, 200, 100);
    ypos = ygap + addTest(dotBox.x, dotBox.y, new ImmediateLayer.Renderer() {

        public void render(Surface surf) {
            surf.setFillColor(0xFFCCCCCC).fillRect(0, 0, dotBox.width, dotBox.height);
        }
    }, dotBox.width, dotBox.height, "Randomly positioned SurfaceImages");
    for (int ii = 0; ii < 10; ii++) {
        SurfaceImage dot = graphics().createSurface(10, 10);
        dot.surface().setFillColor(0xFFFF0000);
        dot.surface().fillRect(0, 0, 5, 5);
        dot.surface().fillRect(5, 5, 5, 5);
        dot.surface().setFillColor(0xFF0000FF);
        dot.surface().fillRect(5, 0, 5, 5);
        dot.surface().fillRect(0, 5, 5, 5);
        ImageLayer dotl = graphics().createImageLayer(dot);
        dotl.setTranslation(dotBox.x + random() * (dotBox.width - 10), dotBox.y + random() * (dotBox.height - 10));
        dots.add(dotl);
        // System.err.println("Created dot at " + dotl.transform());
        graphics().rootLayer().add(dotl);
    }
    // add a surface layer that is updated on every call to paint (a bad practice, but one that
    // should actually work)
    paintUpped = graphics().createSurface(100, 100);
    ypos = ygap + addTest(315, ypos, graphics().createImageLayer(paintUpped), "SurfaceImage updated in paint()");
}

Example 12 with ImageLayer

use of playn.core.ImageLayer in project playn by threerings.

the class SurfaceTest method paint.

@Override
public void paint(float alpha) {
    for (ImageLayer dot : dots) {
        if (random() > 0.95) {
            dot.setTranslation(dotBox.x + random() * (dotBox.width - 10), dotBox.y + random() * (dotBox.height - 10));
        }
    }
    if (paintUpped != null) {
        float now = (elapsed + UPDATE_RATE * alpha) / 1000;
        float sin = Math.abs(FloatMath.sin(now)), cos = Math.abs(FloatMath.cos(now));
        int sinColor = (int) (sin * 255), cosColor = (int) (cos * 255);
        int c1 = (0xFF << 24) | (sinColor << 16) | (cosColor << 8);
        int c2 = (0xFF << 24) | (cosColor << 16) | (sinColor << 8);
        paintUpped.surface().clear();
        paintUpped.surface().setFillColor(c1).fillRect(0, 0, 50, 50);
        paintUpped.surface().setFillColor(c2).fillRect(50, 50, 50, 50);
    }
}

Example 13 with ImageLayer

use of playn.core.ImageLayer in project playn by threerings.

the class CanvasTest method init.

@Override
public void init() {
    nextX = nextY = GAP;
    lastSecs = -1;
    addTestCanvas("radial fill gradient", 100, 100, new Drawer() {

        public void draw(Canvas canvas) {
            canvas.setFillGradient(graphics().createRadialGradient(0, 0, 50, new int[] { 0xFFFF0000, 0xFF00FF00 }, new float[] { 0, 1 }));
            canvas.fillRect(0, 0, 100, 100);
        }
    });
    addTestCanvas("linear fill gradient", 100, 100, new Drawer() {

        public void draw(Canvas canvas) {
            canvas.setFillGradient(graphics().createLinearGradient(0, 0, 100, 100, new int[] { 0xFF0000FF, 0xFF00FF00 }, new float[] { 0, 1 }));
            canvas.fillRect(0, 0, 100, 100);
        }
    });
    addTestCanvas("image fill pattern", 100, 100, "images/tile.png", new ImageDrawer() {

        public void draw(Canvas canvas, Image tile) {
            canvas.setFillPattern(tile.toPattern());
            canvas.fillRect(0, 0, 100, 100);
        }
    });
    addTestCanvas("lines and circles", 100, 100, new Drawer() {

        public void draw(Canvas canvas) {
            canvas.setFillColor(0xFF99CCFF);
            canvas.fillRect(0, 0, 100, 100);
            // draw a point and some lines
            canvas.setStrokeColor(0xFFFF0000);
            canvas.drawPoint(50, 50);
            canvas.drawLine(0, 25, 100, 25);
            canvas.drawLine(0, 75, 100, 75);
            canvas.drawLine(25, 0, 25, 100);
            canvas.drawLine(75, 0, 75, 100);
            // stroke and fill a circle
            canvas.strokeCircle(25, 75, 10);
            canvas.setFillColor(0xFF0000FF);
            canvas.fillCircle(75, 75, 10);
        }
    });
    addTestCanvas("image, subimage", 100, 100, "images/orange.png", new ImageDrawer() {

        public void draw(Canvas canvas, Image orange) {
            canvas.setFillColor(0xFF99CCFF);
            canvas.fillRect(0, 0, 100, 100);
            // draw an image normally, scaled, cropped, cropped and scaled, etc.
            float half = 37 / 2f;
            canvas.drawImage(orange, 10, 10);
            canvas.drawImage(orange, 55, 10, 37, 37, half, half, half, half);
            canvas.drawImage(orange, 10, 55, 37, 37, half, 0, half, half);
            canvas.drawImage(orange, 55, 55, 37, 37, half, half / 2, half, half);
        }
    });
    CanvasImage repimg = createCanvasImage(30, 30, new Drawer() {

        public void draw(Canvas canvas) {
            canvas.setFillColor(0xFF99CCFF);
            canvas.fillCircle(15, 15, 15);
            canvas.setStrokeColor(0xFF000000);
            canvas.strokeRect(0, 0, 30, 30);
        }
    });
    repimg.setRepeat(true, true);
    ImageLayer layer = graphics().createImageLayer(repimg);
    layer.setSize(100, 100);
    addTestLayer("ImageLayer repeat x/y", 100, 100, layer);
    timeImg = graphics().createImage(100, 100);
    addTestLayer("updated canvas", 100, 100, graphics().createImageLayer(timeImg));
    addTestCanvas("filled bezier path", 100, 100, new Drawer() {

        public void draw(Canvas canvas) {
            // draw a rounded rect with bezier curves
            Path path = canvas.createPath();
            path.moveTo(10, 0);
            path.lineTo(90, 0);
            path.bezierTo(95, 0, 100, 5, 100, 10);
            path.lineTo(100, 90);
            path.bezierTo(100, 95, 95, 100, 90, 100);
            path.lineTo(10, 100);
            path.bezierTo(5, 100, 0, 95, 0, 90);
            path.lineTo(0, 10);
            path.bezierTo(0, 5, 5, 0, 10, 0);
            path.close();
            canvas.setFillGradient(graphics().createLinearGradient(0, 0, 100, 100, new int[] { 0xFF0000FF, 0xFF00FF00 }, new float[] { 0, 1 }));
            canvas.fillPath(path);
        }
    });
    addTestCanvas("gradient round rect", 100, 100, new Drawer() {

        public void draw(Canvas canvas) {
            // draw a rounded rect directly
            canvas.setFillGradient(graphics().createLinearGradient(0, 0, 100, 100, new int[] { 0xFF0000FF, 0xFF00FF00 }, new float[] { 0, 1 }));
            canvas.fillRoundRect(0, 0, 100, 100, 10);
        }
    });
    addTestCanvas("gradient filled text", 100, 100, new Drawer() {

        public void draw(Canvas canvas) {
            // draw a rounded rect directly
            canvas.setFillGradient(graphics().createLinearGradient(0, 0, 100, 100, new int[] { 0xFF0000FF, 0xFF00FF00 }, new float[] { 0, 1 }));
            TextLayout capF = graphics().layoutText("F", new TextFormat().withFont(F_FONT.derive(96)));
            canvas.fillText(capF, 15, 5);
        }
    });
    addTestCanvas("nested round rect", 100, 100, new Drawer() {

        public void draw(Canvas canvas) {
            // demonstrates a bug (now worked around) in Android round-rect drawing
            canvas.setFillColor(0xFFFFCC99);
            canvas.fillRoundRect(0, 0, 98.32f, 29.5f, 12f);
            canvas.setFillColor(0xFF99CCFF);
            canvas.fillRoundRect(3, 3, 92.32f, 23.5f, 9.5f);
        }
    });
    addTestCanvas("android fill/stroke bug", 100, 100, new Drawer() {

        public void draw(Canvas canvas) {
            float dotRadius = 40;
            canvas.save();
            canvas.setFillGradient(graphics().createRadialGradient(100 / 3, 100 / 2.5f, dotRadius, new int[] { 0xFFFFFFFF, 0xFFCC66FF }, new float[] { 0f, 1f }));
            canvas.fillCircle(50, 50, dotRadius);
            canvas.restore();
            canvas.setStrokeColor(0xFF000000);
            canvas.setStrokeWidth(1.5f);
            canvas.strokeCircle(50, 50, dotRadius);
        }
    });
    addTestCanvas("transform test", 100, 100, new Drawer() {

        public void draw(Canvas canvas) {
            canvas.setFillColor(0xFFCCCCCC).fillRect(0, 0, 50, 50);
            canvas.setFillColor(0xFFCCCCCC).fillRect(50, 50, 50, 50);
            TextLayout capF = graphics().layoutText("F", new TextFormat().withFont(F_FONT));
            float theta = -FloatMath.PI / 4, tsin = FloatMath.sin(theta), tcos = FloatMath.cos(theta);
            canvas.setFillColor(0xFF000000).fillText(capF, 0, 0);
            canvas.transform(tcos, -tsin, tsin, tcos, 50, 50);
            canvas.setFillColor(0xFF000000).fillText(capF, 0, 0);
        }
    });
    addTestCanvas("round rect precision", 100, 100, new Drawer() {

        float bwid = 4;

        void outer(Canvas canvas, float y) {
            canvas.setFillColor(0xFF000000);
            canvas.fillRect(2, y, 94, 30);
        }

        void inner(Canvas canvas, float y) {
            canvas.setFillColor(0xFF555555);
            canvas.fillRect(2 + bwid, y + bwid, 94 - bwid * 2, 30 - bwid * 2);
        }

        void stroke(Canvas canvas, float y) {
            canvas.setStrokeColor(0xFF99CCFF);
            canvas.setStrokeWidth(bwid);
            canvas.strokeRoundRect(2 + bwid / 2, y + bwid / 2, 94 - bwid, 30 - bwid, 10);
        }

        public void draw(Canvas canvas) {
            float y = 1;
            outer(canvas, y);
            inner(canvas, y);
            stroke(canvas, y);
            y += 34;
            outer(canvas, y);
            stroke(canvas, y);
            inner(canvas, y);
            y += 34;
            stroke(canvas, y);
            outer(canvas, y);
            inner(canvas, y);
        }
    });
    Image tileimg = assets().getImage("images/tile.png");
    tileimg.setRepeat(true, true);
    addTestLayer("img layer anim setWidth", 100, 100, tileLayer = graphics().createImageLayer(tileimg));
    tileLayer.setSize(0, 100);
}

Example 14 with ImageLayer

use of playn.core.ImageLayer in project playn by threerings.

the class CanvasTest method addTestLayer.

private void addTestLayer(String descrip, int width, int height, Layer layer) {
    // if this layer won't fit in this row, wrap down to the next
    if (nextX + width > graphics().width()) {
        nextY += (maxY + GAP);
        nextX = GAP;
        maxY = 0;
    }
    // add the layer and its description below
    graphics().rootLayer().addAt(layer, nextX, nextY);
    ImageLayer dlayer = createDescripLayer(descrip, width);
    graphics().rootLayer().addAt(dlayer, nextX + Math.round((width - dlayer.width()) / 2), nextY + height + 2);
    // update our positioning info
    nextX += (width + GAP);
    maxY = Math.max(maxY, height + dlayer.height() + 2);
}

Example 15 with ImageLayer

use of playn.core.ImageLayer in project playn by threerings.

the class FullscreenTest method init.

@Override
public void init() {
    final float spacing = 5;
    float y = spacing, x = spacing, nextX = spacing;
    for (final Mode mode : host.enumerateModes()) {
        ImageLayer button = createButton(mode.toString(), new Runnable() {

            @Override
            public void run() {
                host.setMode(mode);
            }
        });
        graphics().rootLayer().add(button);
        if (y + button.height() + spacing >= graphics().height()) {
            x = nextX + spacing;
            y = spacing;
        }
        button.setTranslation(x, y);
        y += button.height() + spacing;
        nextX = Math.max(nextX, x + button.width());
    }
}