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

Example 6 with Image

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

the class JavaImageTest method testMissingImage.

@Test
public void testMissingImage() {
    final StringBuilder buf = new StringBuilder();
    PlayN.log().setCollector(new Log.Collector() {

        public void logged(Log.Level level, String msg, Throwable cause) {
            buf.append(msg).append("\n");
        }
    });
    Image missing;
    try {
        missing = PlayN.assets().getImageSync("missing.png");
    } finally {
        PlayN.log().setCollector(null);
    }
    assertNotNull(missing);
    // ensure that width/height do not NPE
    missing.width();
    missing.height();
    // TODO: depending on the error text is somewhat fragile, but I want to be sure that a
    // reasonably appropriate error was logged
    String errlog = buf.toString();
    assertTrue(errlog + " must contain 'Could not load image'", errlog.startsWith("Could not load image"));
    assertTrue(errlog + " must contain 'missing.png'", errlog.contains("missing.png"));
}

Example 7 with Image

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

the class ShaderTest method init.

@Override
public void init() {
    // TODO: display some text saying shaders aren't supported
    if (graphics().ctx() == null)
        return;
    Image orange = assets().getImage("images/orange.png");
    orange.addCallback(new Callback<Image>() {

        public void onSuccess(Image orange) {
            init(orange);
        }

        public void onFailure(Throwable err) {
            log().warn("Failed to load orange image", err);
        }
    });
}

Example 8 with Image

use of playn.core.Image 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 9 with Image

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

the class ImageScalingTest method init.

@Override
public void init() {
    Image princess1 = assets().getImage("images/princess.png");
    Image princess2 = assets().getImage("images/princess.png");
    Image star1 = assets().getImage("images/star.png");
    Image star2 = assets().getImage("images/star.png");
    // configure the second princess and (64x64) star images as mipmapped
    princess2.setMipmapped(true);
    star2.setMipmapped(true);
    // avoid having to wait for images
    float phwidth = 101 / 2f, phheight = 171 / 2f;
    player1 = graphics().createImageLayer(princess1);
    player1.setOrigin(phwidth, phheight);
    graphics().rootLayer().addAt(player1, 100, 100);
    player2 = graphics().createImageLayer(princess2);
    player2.setOrigin(phwidth, phheight);
    graphics().rootLayer().addAt(player2, 250, 100);
    // avoid having to wait for images
    float shwidth = 64 / 2, shheight = 64 / 2;
    slayer1 = graphics().createImageLayer(star1);
    slayer1.setOrigin(shwidth, shheight);
    graphics().rootLayer().addAt(slayer1, 100, 250);
    slayer2 = graphics().createImageLayer(star2);
    slayer2.setOrigin(shwidth, shheight);
    graphics().rootLayer().addAt(slayer2, 250, 250);
    pointer().setListener(new Pointer.Adapter() {

        @Override
        public void onPointerStart(Pointer.Event event) {
            pointerPressed = true;
        }

        @Override
        public void onPointerEnd(Pointer.Event event) {
            pointerPressed = false;
        }

        @Override
        public void onPointerCancel(Pointer.Event event) {
            pointerPressed = false;
        }
    });
}

Example 10 with Image

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

the class ImageTypeTest method init.

@Override
public void init() {
    rootLayer = graphics().rootLayer();
    // add a half white, half blue background
    SurfaceImage bg = graphics().createSurface((int) (4 * width), (int) (4 * height));
    bg.surface().setFillColor(Color.rgb(255, 255, 255));
    bg.surface().fillRect(0, 0, bg.surface().width(), bg.surface().height());
    bg.surface().setFillColor(Color.rgb(0, 0, 255));
    bg.surface().fillRect(0, bg.surface().width() / 2, bg.surface().width(), bg.surface().height() / 2);
    rootLayer.add(graphics().createImageLayer(bg));
    image1 = assets().getImage(imageSrc);
    image1.addCallback(new Callback<Image>() {

        @Override
        public void onSuccess(Image image) {
            // once the image loads, create our layers
            imageLayer1 = graphics().createImageLayer(image);
            SurfaceImage surface1 = graphics().createSurface(image.width(), image.height());
            surface1.surface().drawImage(image, 0, 0);
            surfaceLayer1 = graphics().createImageLayer(surface1);
            CanvasImage canvas1 = graphics().createImage(image.width(), image.height());
            canvas1.canvas().drawImage(image, 0, 0);
            canvasLayer1 = graphics().createImageLayer(canvas1);
            imageLayer2 = graphics().createImageLayer(image);
            SurfaceImage surface2 = graphics().createSurface(image.width(), image.height());
            surface2.surface().drawImage(image, 0, 0);
            surfaceLayer2 = graphics().createImageLayer(surface2);
            CanvasImage canvas2 = graphics().createImage(image.width(), image.height());
            canvas2.canvas().drawImage(image, 0, 0);
            canvasLayer2 = graphics().createImageLayer(canvas2);
            // add layers to the rootLayer
            rootLayer.addAt(imageLayer1, offset, offset);
            rootLayer.addAt(surfaceLayer1, offset + width, offset);
            rootLayer.addAt(canvasLayer1, offset + 2 * width, offset);
            rootLayer.addAt(imageLayer2, offset, offset + 2 * height);
            rootLayer.addAt(surfaceLayer2, offset + width, offset + 2 * height);
            rootLayer.addAt(canvasLayer2, offset + 2 * width, offset + 2 * height);
        }

        @Override
        public void onFailure(Throwable err) {
            log().error("Error loading image", err);
        }
    });
    // add ground truth image
    imageGroundTruth = assets().getImage(imageGroundTruthSrc);
    imageGroundTruth.addCallback(new Callback<Image>() {

        @Override
        public void onSuccess(Image image) {
            groundTruthLayer = graphics().createImageLayer(image);
            rootLayer.addAt(groundTruthLayer, 3 * width, 0);
        }

        @Override
        public void onFailure(Throwable err) {
            log().error("Error loading image", err);
        }
    });
}