Example usage for com.badlogic.gdx.graphics.glutils ShapeRenderer line

List of usage examples for com.badlogic.gdx.graphics.glutils ShapeRenderer line

  1. HOME
  2. Java
  3. com.badlogic.gdx
  4. com.badlogic.gdx.graphics.glutils.*
  5. ShapeRenderer
  6. line

Introduction

In this page you can find the example usage for com.badlogic.gdx.graphics.glutils ShapeRenderer line.

Prototype

public final void line(float x, float y, float x2, float y2)

Source Link

Usage

From source file:broken.shotgun.throwthemoon.actors.LevelDebugRenderer.java

License:Open Source License

@Override
public void drawDebug(ShapeRenderer shapes) {
    super.drawDebug(shapes);
    if (!getDebug() || level == null)
        return;/*from w  w  w . j ava2 s  .  co  m*/
    shapes.setColor(Color.GREEN);
    for (EnemySpawnWall wall : level.enemySpawnWallList) {
        shapes.line(wall.spawnWallX, 0, wall.spawnWallX, getStage().getHeight());
    }
}

From source file:com.agateau.pixelwheels.map.MapUtils.java

License:Open Source License

public static void renderObjectLayer(ShapeRenderer renderer, MapLayer layer) {
    final float U = Constants.UNIT_FOR_PIXEL;
    for (MapObject object : layer.getObjects()) {
        if (object instanceof PolygonMapObject) {
            float[] vertices = ((PolygonMapObject) object).getPolygon().getTransformedVertices();
            for (int idx = 2; idx < vertices.length; idx += 2) {
                renderer.line(vertices[idx - 2] * U, vertices[idx - 1] * U, vertices[idx] * U,
                        vertices[idx + 1] * U);
            }//from ww w.ja v  a 2  s  .  c o m
        } else if (object instanceof RectangleMapObject) {
            Rectangle rect = ((RectangleMapObject) object).getRectangle();
            renderer.rect(rect.x * U, rect.y * U, rect.width * U, rect.height * U);
        }
    }
}

From source file:com.agateau.pixelwheels.utils.DrawUtils.java

License:Open Source License

public static void drawCross(ShapeRenderer renderer, float x, float y, float radius) {
    renderer.line(x - radius, y, x + radius, y);
    renderer.line(x, y - radius, x, y + radius);
}

From source file:com.bladecoder.engine.model.Scene.java

License:Apache License

public void drawBBoxLines(ShapeRenderer renderer) {
    // renderer.begin(ShapeType.Rectangle);
    renderer.begin(ShapeType.Line);

    for (BaseActor a : actors.values()) {
        Polygon p = a.getBBox();//from  w  w w.j  a  v  a2s.  com

        if (p == null) {
            EngineLogger.error("ERROR DRAWING BBOX FOR: " + a.getId());
        }

        if (a instanceof ObstacleActor) {
            renderer.setColor(OBSTACLE_COLOR);
            renderer.polygon(p.getTransformedVertices());
        } else if (a instanceof AnchorActor) {
            renderer.setColor(Scene.ANCHOR_COLOR);
            renderer.line(p.getX() - Scene.ANCHOR_RADIUS, p.getY(), p.getX() + Scene.ANCHOR_RADIUS, p.getY());
            renderer.line(p.getX(), p.getY() - Scene.ANCHOR_RADIUS, p.getX(), p.getY() + Scene.ANCHOR_RADIUS);
        } else {
            renderer.setColor(ACTOR_BBOX_COLOR);
            renderer.polygon(p.getTransformedVertices());
        }

        // Rectangle r = a.getBBox().getBoundingRectangle();
        // renderer.rect(r.getX(), r.getY(), r.getWidth(), r.getHeight());
    }

    if (polygonalNavGraph != null) {
        renderer.setColor(WALKZONE_COLOR);
        renderer.polygon(polygonalNavGraph.getWalkZone().getTransformedVertices());

        // DRAW LINEs OF SIGHT
        renderer.setColor(Color.WHITE);
        ArrayList<NavNodePolygonal> nodes = polygonalNavGraph.getGraphNodes();
        for (NavNodePolygonal n : nodes) {
            for (NavNodePolygonal n2 : n.neighbors) {
                renderer.line(n.x, n.y, n2.x, n2.y);
            }
        }
    }

    renderer.end();
}

From source file:com.company.minery.utils.spine.SkeletonRendererDebug.java

License:Open Source License

public void draw(Skeleton skeleton) {
    float skeletonX = skeleton.getX();
    float skeletonY = skeleton.getY();

    Gdx.gl.glEnable(GL20.GL_BLEND);//from   w w w  . j av  a  2s  .  com
    int srcFunc = premultipliedAlpha ? GL20.GL_ONE : GL20.GL_SRC_ALPHA;
    Gdx.gl.glBlendFunc(srcFunc, GL20.GL_ONE_MINUS_SRC_ALPHA);

    ShapeRenderer shapes = this.shapes;

    Array<Bone> bones = skeleton.getBones();
    if (drawBones) {
        shapes.setColor(boneLineColor);
        shapes.begin(ShapeType.Filled);
        for (int i = 0, n = bones.size; i < n; i++) {
            Bone bone = bones.get(i);
            if (bone.parent == null)
                continue;
            float x = skeletonX + bone.data.length * bone.m00 + bone.worldX;
            float y = skeletonY + bone.data.length * bone.m10 + bone.worldY;
            shapes.rectLine(skeletonX + bone.worldX, skeletonY + bone.worldY, x, y, boneWidth * scale);
        }
        shapes.end();
        shapes.begin(ShapeType.Line);
        shapes.x(skeletonX, skeletonY, 4 * scale);
    } else
        shapes.begin(ShapeType.Line);

    if (drawRegionAttachments) {
        shapes.setColor(attachmentLineColor);
        Array<Slot> slots = skeleton.getSlots();
        for (int i = 0, n = slots.size; i < n; i++) {
            Slot slot = slots.get(i);
            Attachment attachment = slot.attachment;
            if (attachment instanceof RegionAttachment) {
                RegionAttachment regionAttachment = (RegionAttachment) attachment;
                regionAttachment.updateWorldVertices(slot, false);
                float[] vertices = regionAttachment.getWorldVertices();
                shapes.line(vertices[X1], vertices[Y1], vertices[X2], vertices[Y2]);
                shapes.line(vertices[X2], vertices[Y2], vertices[X3], vertices[Y3]);
                shapes.line(vertices[X3], vertices[Y3], vertices[X4], vertices[Y4]);
                shapes.line(vertices[X4], vertices[Y4], vertices[X1], vertices[Y1]);
            }
        }
    }

    if (drawMeshHull || drawMeshTriangles) {
        Array<Slot> slots = skeleton.getSlots();
        for (int i = 0, n = slots.size; i < n; i++) {
            Slot slot = slots.get(i);
            Attachment attachment = slot.attachment;
            float[] vertices = null;
            short[] triangles = null;
            int hullLength = 0;
            if (attachment instanceof MeshAttachment) {
                MeshAttachment mesh = (MeshAttachment) attachment;
                mesh.updateWorldVertices(slot, false);
                vertices = mesh.getWorldVertices();
                triangles = mesh.getTriangles();
                hullLength = mesh.getHullLength();
            } else if (attachment instanceof SkinnedMeshAttachment) {
                SkinnedMeshAttachment mesh = (SkinnedMeshAttachment) attachment;
                mesh.updateWorldVertices(slot, false);
                vertices = mesh.getWorldVertices();
                triangles = mesh.getTriangles();
                hullLength = mesh.getHullLength();
            }
            if (vertices == null || triangles == null)
                continue;
            if (drawMeshTriangles) {
                shapes.setColor(triangleLineColor);
                for (int ii = 0, nn = triangles.length; ii < nn; ii += 3) {
                    int v1 = triangles[ii] * 5, v2 = triangles[ii + 1] * 5, v3 = triangles[ii + 2] * 5;
                    shapes.triangle(vertices[v1], vertices[v1 + 1], //
                            vertices[v2], vertices[v2 + 1], //
                            vertices[v3], vertices[v3 + 1] //
                    );
                }
            }
            if (drawMeshHull && hullLength > 0) {
                shapes.setColor(attachmentLineColor);
                hullLength = hullLength / 2 * 5;
                float lastX = vertices[hullLength - 5], lastY = vertices[hullLength - 4];
                for (int ii = 0, nn = hullLength; ii < nn; ii += 5) {
                    float x = vertices[ii], y = vertices[ii + 1];
                    shapes.line(x, y, lastX, lastY);
                    lastX = x;
                    lastY = y;
                }
            }
        }
    }

    if (drawBoundingBoxes) {
        SkeletonBounds bounds = this.bounds;
        bounds.update(skeleton, true);
        shapes.setColor(aabbColor);
        shapes.rect(bounds.getMinX(), bounds.getMinY(), bounds.getWidth(), bounds.getHeight());
        shapes.setColor(boundingBoxColor);
        Array<FloatArray> polygons = bounds.getPolygons();
        for (int i = 0, n = polygons.size; i < n; i++) {
            FloatArray polygon = polygons.get(i);
            shapes.polygon(polygon.items, 0, polygon.size);
        }
    }

    shapes.end();
    shapes.begin(ShapeType.Filled);

    if (drawBones) {
        shapes.setColor(boneOriginColor);
        for (int i = 0, n = bones.size; i < n; i++) {
            Bone bone = bones.get(i);
            shapes.setColor(Color.GREEN);
            shapes.circle(skeletonX + bone.worldX, skeletonY + bone.worldY, 3 * scale, 8);
        }
    }

    shapes.end();
}

From source file:com.esotericsoftware.spine.SkeletonViewer.java

License:Open Source License

public void render() {
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

    float delta = Gdx.graphics.getDeltaTime();

    if (skeleton != null) {
        if (reloadTimer <= 0) {
            lastModifiedCheck -= delta;/*from  w  w  w.  j ava  2s.c  om*/
            if (lastModifiedCheck < 0) {
                lastModifiedCheck = checkModifiedInterval;
                long time = skeletonFile.lastModified();
                if (time != 0 && lastModified != time)
                    reloadTimer = reloadDelay;
            }
        } else {
            reloadTimer -= delta;
            if (reloadTimer <= 0)
                loadSkeleton(skeletonFile, true);
        }

        state.getData().setDefaultMix(ui.mixSlider.getValue());
        renderer.setPremultipliedAlpha(ui.premultipliedCheckbox.isChecked());

        delta = Math.min(delta, 0.032f) * ui.speedSlider.getValue();
        skeleton.update(delta);
        skeleton.setFlip(ui.flipXCheckbox.isChecked(), ui.flipYCheckbox.isChecked());
        if (!ui.pauseButton.isChecked()) {
            state.update(delta);
            state.apply(skeleton);
        }
        skeleton.setPosition(skeletonX, skeletonY);
        // skeleton.setPosition(0, 0);
        // skeleton.getRootBone().setX(skeletonX);
        // skeleton.getRootBone().setY(skeletonY);
        skeleton.updateWorldTransform();

        batch.begin();
        renderer.draw(batch, skeleton);
        batch.end();

        debugRenderer.setBones(ui.debugBonesCheckbox.isChecked());
        debugRenderer.setRegionAttachments(ui.debugRegionsCheckbox.isChecked());
        debugRenderer.setBoundingBoxes(ui.debugBoundingBoxesCheckbox.isChecked());
        debugRenderer.setMeshHull(ui.debugMeshHullCheckbox.isChecked());
        debugRenderer.setMeshTriangles(ui.debugMeshTrianglesCheckbox.isChecked());
        debugRenderer.draw(skeleton);
    }

    ui.stage.act();
    ui.stage.draw();

    // Draw indicator for timeline position.
    if (state != null) {
        ShapeRenderer shapes = debugRenderer.getShapeRenderer();
        TrackEntry entry = state.getCurrent(0);
        if (entry != null) {
            float percent = entry.getTime() / entry.getEndTime();
            if (entry.getLoop())
                percent %= 1;
            float x = ui.window.getRight() + (Gdx.graphics.getWidth() - ui.window.getRight()) * percent;
            shapes.setColor(Color.CYAN);
            shapes.begin(ShapeType.Line);
            shapes.line(x, 0, x, 20);
            shapes.end();
        }
    }
}

From source file:com.hindelid.ld.thirtyfour.Fish.java

License:Apache License

public void render(ShapeRenderer aShapeRenderer) {
    aShapeRenderer.circle(mPos.x, mPos.y, mRadus, 30); // Body
    aShapeRenderer.circle(mPos.x - 0.25f, mPos.y + 0.15f, 0.06f, 30); // Eye
    aShapeRenderer.line(mPos.x + mTailOffset.x, mPos.y + mTailOffset.y, mPos.x + 1f, mPos.y - 0.4f); // \
    aShapeRenderer.line(mPos.x + mTailOffset.x, mPos.y - mTailOffset.y, mPos.x + 1f, mPos.y + 0.4f); // /
    aShapeRenderer.line(mPos.x + 1f, mPos.y - 0.4f, mPos.x + 1f, mPos.y + 0.4f); // |
    aShapeRenderer.line(mPos.x - mLampOffset.x, mPos.y + mLampOffset.y, mPos.x - mLampOffset.x * 2f,
            mPos.y + mLampOffset.y * 2f);
    aShapeRenderer.line(mPos.x - mLampOffset.x * 3.3f, mPos.y + mLampOffset.y, mPos.x - mLampOffset.x * 2f,
            mPos.y + mLampOffset.y * 2f);
    aShapeRenderer.circle(mPos.x - mLampOffset.x * 3.3f, mPos.y + mLampOffset.y - 0.08f, 0.08f, 30);

    aShapeRenderer.curve(mPos.x - mTailOffset.x, mPos.y - mTailOffset.y, mPos.x - mTailOffset.x,
            mPos.y - mTailOffset.y * 1.6f, mPos.x, mPos.y - mTailOffset.y * 1.5f, mPos.x - mTailOffset.x / 2f,
            mPos.y - mTailOffset.y / 2f, 30);
    //        aShapeRenderer.rect(mBoundingBox.x, mBoundingBox.y, mBoundingBox.width, mBoundingBox.height);
}

From source file:com.hindelid.ld.thirtyfour.Octopus.java

License:Apache License

public void render(ShapeRenderer aShapeRenderer) {
    aShapeRenderer.curve(mPos.x, mPos.y, mPos.x + 0.5f, mPos.y + 1f, mPos.x + 0.5f, mPos.y + 1f, mPos.x + 1f,
            mPos.y, 30);/*  ww w .  ja  v a 2 s . c  om*/
    aShapeRenderer.line(mPos.x, mPos.y, mPos.x + 1f, mPos.y);
    aShapeRenderer.triangle( // Left eye
            mPos.x + 0.3f, mPos.y + 0.4f, mPos.x + 0.35f, mPos.y + 0.45f, mPos.x + 0.45f, mPos.y + 0.32f);
    aShapeRenderer.triangle( // Right eye
            mPos.x + 0.7f, mPos.y + 0.4f, mPos.x + 0.65f, mPos.y + 0.45f, mPos.x + 0.55f, mPos.y + 0.32f);
    aShapeRenderer.line(mPos.x + 0.1f, mPos.y, mPos.x - 0.1f, mPos.y - 0.6f);
    aShapeRenderer.line(mPos.x + 0.4f, mPos.y, mPos.x + 0.35f, mPos.y - 0.6f);
    aShapeRenderer.line(mPos.x + 0.6f, mPos.y, mPos.x + 0.65f, mPos.y - 0.6f);
    aShapeRenderer.line(mPos.x + 0.9f, mPos.y, mPos.x + 1.1f, mPos.y - 0.6f);
}

From source file:com.hindelid.ld.thirtyfour.TreeBranch.java

License:Apache License

public void render(ShapeRenderer aShapeRenderer) {
    if (mTheOneActive) {
        sGlobal.x = mStart.x;// + (mEnd.x - mStart.x) * (sGlobal.y - mStart.y) / (mEnd.y - mStart.y);
        if (sGlobal.y > mEnd.y) {
            sNext = true;/* www .j  ava2s. c om*/
            if (mFirstRenderer) { // To keep up if the fps is lower than number of BranchTress grow per second.
                split();
            }
        }
        mFirstRenderer = false;
    }
    if (mActive) {

        //            aShapeRenderer.setColor(Color.RED);
        if (mTheOneActive && sGlobal.y < mEnd.y) {
            aShapeRenderer.line(mStart.x, mStart.y, sGlobal.x, sGlobal.y
            /*mStart.x + (sGlobal.x - mStart.x) / (mEnd.x - mStart.x),
            mStart.y + (sGlobal.y - mStart.y) / (mEnd.y - mStart.y)*/);
        } else {
            aShapeRenderer.line(mStart, mEnd);
        }
        if (mEnd.y + 10f < sGlobal.y) {
            Main.mNextRoot = this;
        }
        aShapeRenderer.setColor(Color.BROWN);

    } else {
        aShapeRenderer.line(mStart, mEnd);
    }

    if (null != mLeftBranch) {
        mLeftBranch.render(aShapeRenderer);
    }
    if (null != mRightBranch) {
        mRightBranch.render(aShapeRenderer);
    }
    if (null != mMiddleBranch) {
        mMiddleBranch.render(aShapeRenderer);
    }

}

From source file:com.kotcrab.vis.editor.module.scene.entitymanipulator.tool.ScaleTool.java

License:Apache License

@Override
public void render(ShapeRenderer shapeRenderer) {
    super.render(shapeRenderer);

    if (totalSelectionBounds != null) {
        float centerX = totalSelectionBounds.x + totalSelectionBounds.width / 2;
        float centerY = totalSelectionBounds.y + totalSelectionBounds.height / 2;

        float centerRectSize = 0.1f * camera.getZoom() * 100f / scene.pixelsPerUnit;
        float lineLengthX = 1 * camera.getZoom() * 100f / scene.pixelsPerUnit;
        float lineLengthY = 1 * camera.getZoom() * 100f / scene.pixelsPerUnit;
        if (Gdx.input.isButtonPressed(Buttons.LEFT)) {
            if (mouseLooping.isOnVirtualScreen() == false) {
                if (mouseInsideRectX)
                    lineLengthX = camera.getInputX() - centerX;
                if (mouseInsideRectY)
                    lineLengthY = camera.getInputY() - centerY;
            } else {
                //if mouse is on virtual screen, method above won't work because line would be flipped
                //but also on virtual screen line end won't be visible anyways so we are just drawing very long line
                if (mouseInsideRectX)
                    lineLengthX = 100000;
                if (mouseInsideRectY)
                    lineLengthY = 100000;
            }/* w  w  w .  ja  v  a 2s .co  m*/
        }

        shapeRenderer.setColor(Color.GREEN);
        shapeRenderer.begin(ShapeType.Line);
        shapeRenderer.line(centerX, centerY, centerX + lineLengthX, centerY);
        shapeRenderer.end();

        shapeRenderer.setColor(mouseInsideRectX ? xRectOver : xRect);
        shapeRenderer.begin(ShapeType.Filled);
        rect(shapeRenderer, xScaleRect.set(centerX + lineLengthX - centerRectSize / 2,
                centerY - centerRectSize / 2, centerRectSize, centerRectSize));
        shapeRenderer.end();

        shapeRenderer.setColor(Color.RED);
        shapeRenderer.begin(ShapeType.Line);
        shapeRenderer.line(centerX, centerY, centerX, centerY + lineLengthY);
        shapeRenderer.end();

        shapeRenderer.setColor(mouseInsideRectY ? yRectOver : yRect);
        shapeRenderer.begin(ShapeType.Filled);
        rect(shapeRenderer, yScaleRect.set(centerX - centerRectSize / 2,
                centerY + lineLengthY - centerRectSize / 2, centerRectSize, centerRectSize));
        shapeRenderer.end();
    }
}