List of usage examples for com.badlogic.gdx.maps.tiled TiledMapTileLayer getTileWidth
public float getTileWidth()
From source file:br.com.animvs.koalory.entities.engine.graphics.tiles.TileRenderer.java
License:Apache License
@Override public void renderTileLayer(TiledMapTileLayer layer) { final float color = Color.toFloatBits(1, 1, 1, layer.getOpacity()); final int layerWidth = layer.getWidth(); final int layerHeight = layer.getHeight(); final float layerTileWidth = layer.getTileWidth() * unitScale; final float layerTileHeight = layer.getTileHeight() * unitScale; final int col1 = Math.max(0, (int) (cacheBounds.x / layerTileWidth)); final int col2 = Math.min(layerWidth, (int) ((cacheBounds.x + cacheBounds.width + layerTileWidth) / layerTileWidth)); final int row1 = Math.max(0, (int) (cacheBounds.y / layerTileHeight)); final int row2 = Math.min(layerHeight, (int) ((cacheBounds.y + cacheBounds.height + layerTileHeight) / layerTileHeight)); canCacheMoreN = row2 < layerHeight; canCacheMoreE = col2 < layerWidth; canCacheMoreW = col1 > 0;/*w ww . ja v a2 s. c o m*/ canCacheMoreS = row1 > 0; float[] vertices = this.vertices; for (int row = row2; row >= row1; row--) { for (int col = col1; col < col2; col++) { final TiledMapTileLayer.Cell cell = layer.getCell(col, row); if (cell == null) continue; final TiledMapTile tile = cell.getTile(); if (tile == null) continue; count++; final boolean flipX = cell.getFlipHorizontally(); final boolean flipY = cell.getFlipVertically(); final int rotations = cell.getRotation(); final TextureRegion region = tile.getTextureRegion(); final Texture texture = region.getTexture(); final float x1 = col * layerTileWidth + tile.getOffsetX() * unitScale; final float y1 = row * layerTileHeight + tile.getOffsetY() * unitScale; final float x2 = x1 + region.getRegionWidth() * unitScale; final float y2 = y1 + region.getRegionHeight() * unitScale; final float adjustX = 0.5f / texture.getWidth(); final float adjustY = 0.5f / texture.getHeight(); final float u1 = region.getU() + adjustX; final float v1 = region.getV2() - adjustY; final float u2 = region.getU2() - adjustX; final float v2 = region.getV() + adjustY; vertices[X1] = x1; vertices[Y1] = y1; vertices[C1] = color; vertices[U1] = u1; vertices[V1] = v1; vertices[X2] = x1; vertices[Y2] = y2; vertices[C2] = color; vertices[U2] = u1; vertices[V2] = v2; vertices[X3] = x2; vertices[Y3] = y2; vertices[C3] = color; vertices[U3] = u2; vertices[V3] = v2; vertices[X4] = x2; vertices[Y4] = y1; vertices[C4] = color; vertices[U4] = u2; vertices[V4] = v1; if (flipX) { float temp = vertices[U1]; vertices[U1] = vertices[U3]; vertices[U3] = temp; temp = vertices[U2]; vertices[U2] = vertices[U4]; vertices[U4] = temp; } if (flipY) { float temp = vertices[V1]; vertices[V1] = vertices[V3]; vertices[V3] = temp; temp = vertices[V2]; vertices[V2] = vertices[V4]; vertices[V4] = temp; } if (rotations != 0) { switch (rotations) { case Cell.ROTATE_90: { float tempV = vertices[V1]; vertices[V1] = vertices[V2]; vertices[V2] = vertices[V3]; vertices[V3] = vertices[V4]; vertices[V4] = tempV; float tempU = vertices[U1]; vertices[U1] = vertices[U2]; vertices[U2] = vertices[U3]; vertices[U3] = vertices[U4]; vertices[U4] = tempU; break; } case Cell.ROTATE_180: { float tempU = vertices[U1]; vertices[U1] = vertices[U3]; vertices[U3] = tempU; tempU = vertices[U2]; vertices[U2] = vertices[U4]; vertices[U4] = tempU; float tempV = vertices[V1]; vertices[V1] = vertices[V3]; vertices[V3] = tempV; tempV = vertices[V2]; vertices[V2] = vertices[V4]; vertices[V4] = tempV; break; } case Cell.ROTATE_270: { float tempV = vertices[V1]; vertices[V1] = vertices[V4]; vertices[V4] = vertices[V3]; vertices[V3] = vertices[V2]; vertices[V2] = tempV; float tempU = vertices[U1]; vertices[U1] = vertices[U4]; vertices[U4] = vertices[U3]; vertices[U3] = vertices[U2]; vertices[U2] = tempU; break; } } } spriteCache.add(texture, vertices, 0, 20); } } }
From source file:com.agateau.pixelwheels.tools.LapPositionTableGenerator.java
License:Apache License
public static void generateTable(FileHandle tmxFile, FileHandle tableFile) { TiledMap map = new TmxMapLoader().load(tmxFile.path()); LapPositionTable table = LapPositionTableIO.load(map); TiledMapTileLayer layer = (TiledMapTileLayer) map.getLayers().get(0); int width = layer.getWidth() * ((int) layer.getTileWidth()); int height = layer.getHeight() * ((int) layer.getTileHeight()); Pixmap pixmap = LapPositionTableIO.createPixmap(table, width, height); PixmapIO.writePNG(tableFile, pixmap); }
From source file:com.agateau.pixelwheels.tools.MapScreenshotGenerator.java
License:Apache License
private static Pixmap generateScreenshot(FileHandle tmxFile) { TiledMap map = new TmxMapLoader().load(tmxFile.path()); TiledMapTileLayer layer = (TiledMapTileLayer) map.getLayers().get(0); int mapWidth = (int) (layer.getWidth() * layer.getTileWidth()); int mapHeight = (int) (layer.getHeight() * layer.getTileHeight()); FrameBuffer fbo = new FrameBuffer(Pixmap.Format.RGB888, mapWidth, mapHeight, false /* hasDepth */); OrthogonalTiledMapRenderer renderer = new OrthogonalTiledMapRenderer(map); OrthographicCamera camera = new OrthographicCamera(); camera.setToOrtho(true /* yDown */, mapWidth, mapHeight); renderer.setView(camera);/*from w w w .j ava 2 s . co m*/ fbo.begin(); renderer.render(); return ScreenUtils.getFrameBufferPixmap(0, 0, mapWidth, mapHeight); }
From source file:com.barconr.games.marblegame.Physics2D.java
License:Apache License
public void createFixtures(TiledMap tiledmap) { int layerHeight = 0, layerWidth = 0; float tileWidth = 0, tileHeight = 0; ballsListener = new BallContactListener(); // Load the Tiled map layer and store some relevant variables TiledMapTileLayer tilelayer = (TiledMapTileLayer) (tiledmap.getLayers().get(0)); layerHeight = tilelayer.getHeight(); layerWidth = tilelayer.getWidth();/* w ww . ja va2 s. c om*/ maze = new Maze(layerWidth, layerHeight); tileHeight = tilelayer.getTileHeight(); tileWidth = tilelayer.getTileWidth(); System.out.println("Layer height (tiles) = " + layerHeight + " Layer width (tiles) = " + layerWidth + " Tile height = " + tileHeight + "tile width = " + tileWidth); System.out.println("Tile count = " + tilelayer.getObjects().getCount()); System.out.println("layer height pixels = " + (layerHeight * tileHeight) + "LAYER WIDTH PIXELS : " + (layerWidth * tileWidth)); //Create the box2d world world = new World(new Vector2(0, -9), true); world.setContactListener(ballsListener); // Loop through the grid reference for (int y_pos = 0; y_pos < layerHeight; y_pos++) { for (int x_pos = 0; x_pos < layerWidth; x_pos++) { boolean impassibleBlock = tilelayer.getCell(x_pos, layerHeight - y_pos - 1).getTile() .getProperties().containsKey("block"); // If the tile square contains the reference "start" // Store this as the start position if (tilelayer.getCell(x_pos, layerHeight - y_pos - 1).getTile().getProperties() .containsKey("start")) { if (startPosition == null) { System.out.println("x:" + x_pos * tileWidth + " y:" + y_pos * tileHeight); startPosition = new Vector2(x_pos * tileWidth * Assets.METERS_PER_PIXEL, (50 - y_pos) * tileHeight * Assets.METERS_PER_PIXEL); } } //Create a fixture for the end position if (tilelayer.getCell(x_pos, layerHeight - y_pos - 1).getTile().getProperties() .containsKey("end")) { //Draw box for fixture that is impassible PolygonShape squareShape = new PolygonShape(); BodyDef squareBodyDef = new BodyDef(); squareBodyDef.type = BodyType.StaticBody; //Static body which won't move //Box position squareBodyDef.position.set(new Vector2((x_pos * Assets.METERS_PER_PIXEL * tileWidth), (layerHeight - y_pos - 1) * Assets.METERS_PER_PIXEL * tileHeight)); //Correction for fact Box2Ds squares are half width/height from center point squareBodyDef.position.add(tileWidth / 2 * Assets.METERS_PER_PIXEL, tileHeight / 2 * Assets.METERS_PER_PIXEL); Body squareBody = world.createBody(squareBodyDef); squareShape.setAsBox(tileWidth / 2 * Assets.METERS_PER_PIXEL, tileHeight / 2 * Assets.METERS_PER_PIXEL); FixtureDef fixDefSquare = new FixtureDef(); fixDefSquare.shape = squareShape; fixDefSquare.isSensor = true; fixDefSquare.density = 0.1f; fixDefSquare.restitution = 0.3f; Fixture endFix = squareBody.createFixture(fixDefSquare); endFix.setSensor(true); endFix.setUserData("exit"); } if (impassibleBlock) { //Draw box for fixture that blocks maze.setMazeUnit(new MazeUnit("block"), x_pos, y_pos); //System.out.print("@"); // Draw ascii map in stdout } else { maze.setMazeUnit(new MazeUnit("passage"), x_pos, y_pos); } } //System.out.println(); } // The players ball playerBallBodyDef = new BodyDef(); playerBallBodyDef.type = BodyType.DynamicBody; if (startPosition == null) { playerBallBodyDef.position.set(3f, 3f); } else { playerBallBodyDef.position.set(startPosition.x, startPosition.y); } playerBallBodyDef.allowSleep = false; ballCircleBody = world.createBody(playerBallBodyDef); dynamicCircle = new CircleShape(); dynamicCircle.setRadius(8 / Assets.PIXELS_PER_METER); FixtureDef ballFixtureDef = new FixtureDef(); ballFixtureDef.shape = dynamicCircle; ballFixtureDef.density = 0.1f; ballFixtureDef.friction = 1f; //ballFixtureDef. ballFixtureDef.restitution = 0.5f; //ballCircleBody.setUserData("ball"); Fixture fx = ballCircleBody.createFixture(ballFixtureDef); fx.setUserData("ball"); maze.removeExtraBoxes(); /* PolygonShape squareShape = new PolygonShape(); */ for (int i = 0; i < maze.width; i++) { for (int j = 0; j < maze.height; j++) { if (maze.mazeUnits[j][i].getType().equals("block")) { BodyDef squareBodyDef = new BodyDef(); PolygonShape squareShape = new PolygonShape(); squareBodyDef.type = BodyType.StaticBody; //Static body which won't move //Box position squareBodyDef.position.set(new Vector2((j * Assets.METERS_PER_PIXEL * tileWidth), (layerHeight - i - 1) * Assets.METERS_PER_PIXEL * tileHeight)); //Correction for fact Box2Ds squares are half width/height from center point squareBodyDef.position.add(tileWidth / 2 * Assets.METERS_PER_PIXEL, tileHeight / 2 * Assets.METERS_PER_PIXEL); Body squareBody = world.createBody(squareBodyDef); //Size of box squareShape.setAsBox(tileWidth / 2 * Assets.METERS_PER_PIXEL, tileHeight / 2 * Assets.METERS_PER_PIXEL); FixtureDef fixDefSquare = new FixtureDef(); fixDefSquare.shape = squareShape; fixDefSquare.density = 0.1f; fixDefSquare.restitution = 0.3f; squareBody.createFixture(fixDefSquare); } } } }
From source file:com.khoa.demo1.OrthogonalTiledMapRenderer2.java
License:Apache License
@Override public void renderTileLayer(TiledMapTileLayer layer) { final Color batchColor = spriteBatch.getColor(); final float color = Color.toFloatBits(batchColor.r, batchColor.g, batchColor.b, batchColor.a * layer.getOpacity()); final int layerWidth = layer.getWidth(); final int layerHeight = layer.getHeight(); final float layerTileWidth = layer.getTileWidth() * unitScale; final float layerTileHeight = layer.getTileHeight() * unitScale; final int col1 = Math.max(0, (int) (viewBounds.x / layerTileWidth)); final int col2 = Math.min(layerWidth, (int) ((viewBounds.x + viewBounds.width + layerTileWidth) / layerTileWidth)); final int row1 = Math.max(0, (int) (viewBounds.y / layerTileHeight)); final int row2 = Math.min(layerHeight, (int) ((viewBounds.y + viewBounds.height + layerTileHeight) / layerTileHeight)); float y = row1 * layerTileHeight; float xStart = col1 * layerTileWidth + displacement; final float[] vertices = this.vertices; for (int row = row1; row < row2; row++) { float x = xStart; for (int col = col1; col < col2; col++) { final Cell cell = layer.getCell(col, row); if (cell == null) { x += layerTileWidth;/*from w w w .j a v a 2 s. co m*/ continue; } final TiledMapTile tile = cell.getTile(); if (tile != null) { final boolean flipX = cell.getFlipHorizontally(); final boolean flipY = cell.getFlipVertically(); final int rotations = cell.getRotation(); TextureRegion region = tile.getTextureRegion(); float x1 = x; float y1 = y; float x2 = x1 + region.getRegionWidth() * unitScale; float y2 = y1 + region.getRegionHeight() * unitScale; float u1 = region.getU(); float v1 = region.getV2(); float u2 = region.getU2(); float v2 = region.getV(); vertices[X1] = x1; vertices[Y1] = y1; vertices[C1] = color; vertices[U1] = u1; vertices[V1] = v1; vertices[X2] = x1; vertices[Y2] = y2; vertices[C2] = color; vertices[U2] = u1; vertices[V2] = v2; vertices[X3] = x2; vertices[Y3] = y2; vertices[C3] = color; vertices[U3] = u2; vertices[V3] = v2; vertices[X4] = x2; vertices[Y4] = y1; vertices[C4] = color; vertices[U4] = u2; vertices[V4] = v1; if (flipX) { float temp = vertices[U1]; vertices[U1] = vertices[U3]; vertices[U3] = temp; temp = vertices[U2]; vertices[U2] = vertices[U4]; vertices[U4] = temp; } if (flipY) { float temp = vertices[V1]; vertices[V1] = vertices[V3]; vertices[V3] = temp; temp = vertices[V2]; vertices[V2] = vertices[V4]; vertices[V4] = temp; } if (rotations != 0) { switch (rotations) { case Cell.ROTATE_90: { float tempV = vertices[V1]; vertices[V1] = vertices[V2]; vertices[V2] = vertices[V3]; vertices[V3] = vertices[V4]; vertices[V4] = tempV; float tempU = vertices[U1]; vertices[U1] = vertices[U2]; vertices[U2] = vertices[U3]; vertices[U3] = vertices[U4]; vertices[U4] = tempU; break; } case Cell.ROTATE_180: { float tempU = vertices[U1]; vertices[U1] = vertices[U3]; vertices[U3] = tempU; tempU = vertices[U2]; vertices[U2] = vertices[U4]; vertices[U4] = tempU; float tempV = vertices[V1]; vertices[V1] = vertices[V3]; vertices[V3] = tempV; tempV = vertices[V2]; vertices[V2] = vertices[V4]; vertices[V4] = tempV; break; } case Cell.ROTATE_270: { float tempV = vertices[V1]; vertices[V1] = vertices[V4]; vertices[V4] = vertices[V3]; vertices[V3] = vertices[V2]; vertices[V2] = tempV; float tempU = vertices[U1]; vertices[U1] = vertices[U4]; vertices[U4] = vertices[U3]; vertices[U3] = vertices[U2]; vertices[U2] = tempU; break; } } } spriteBatch.draw(region.getTexture(), vertices, 0, 20); x += layerTileWidth; } } y += layerTileHeight; } }
From source file:com.khoa.demo1.OrthogonalTiledMapRenderer2.java
License:Apache License
public void renderTileLayer(TiledMapTileLayer layer, int xDisplacement) { final Color batchColor = spriteBatch.getColor(); final float color = Color.toFloatBits(batchColor.r, batchColor.g, batchColor.b, batchColor.a * layer.getOpacity()); final int layerWidth = layer.getWidth(); final int layerHeight = layer.getHeight(); final float layerTileWidth = layer.getTileWidth() * unitScale; final float layerTileHeight = layer.getTileHeight() * unitScale; final int col1 = Math.max(xDisplacement, (int) (viewBounds.x / layerTileWidth)); final int col2 = Math.min(layerWidth + xDisplacement, (int) ((viewBounds.x + viewBounds.width + layerTileWidth) / layerTileWidth)); final int row1 = Math.max(0, (int) (viewBounds.y / layerTileHeight)); final int row2 = Math.min(layerHeight, (int) ((viewBounds.y + viewBounds.height + layerTileHeight) / layerTileHeight)); float y = row1 * layerTileHeight; float xStart = col1 * layerTileWidth + displacement; // System.out.println(col1); // System.out.println(col2); // System.out.println(xStart); // System.out.println(xDisplacement); final float[] vertices = this.vertices; for (int row = row1; row < row2; row++) { float x = xStart; for (int col = col1; col < col2; col++) { final Cell cell = layer.getCell(col, row); if (cell == null) { x += layerTileWidth;//from ww w . j a v a 2 s .c o m continue; } final TiledMapTile tile = cell.getTile(); if (tile != null) { final boolean flipX = cell.getFlipHorizontally(); final boolean flipY = cell.getFlipVertically(); final int rotations = cell.getRotation(); TextureRegion region = tile.getTextureRegion(); float x1 = x; float y1 = y; float x2 = x1 + region.getRegionWidth() * unitScale; float y2 = y1 + region.getRegionHeight() * unitScale; float u1 = region.getU(); float v1 = region.getV2(); float u2 = region.getU2(); float v2 = region.getV(); vertices[X1] = x1; vertices[Y1] = y1; vertices[C1] = color; vertices[U1] = u1; vertices[V1] = v1; vertices[X2] = x1; vertices[Y2] = y2; vertices[C2] = color; vertices[U2] = u1; vertices[V2] = v2; vertices[X3] = x2; vertices[Y3] = y2; vertices[C3] = color; vertices[U3] = u2; vertices[V3] = v2; vertices[X4] = x2; vertices[Y4] = y1; vertices[C4] = color; vertices[U4] = u2; vertices[V4] = v1; if (flipX) { float temp = vertices[U1]; vertices[U1] = vertices[U3]; vertices[U3] = temp; temp = vertices[U2]; vertices[U2] = vertices[U4]; vertices[U4] = temp; } if (flipY) { float temp = vertices[V1]; vertices[V1] = vertices[V3]; vertices[V3] = temp; temp = vertices[V2]; vertices[V2] = vertices[V4]; vertices[V4] = temp; } if (rotations != 0) { switch (rotations) { case Cell.ROTATE_90: { float tempV = vertices[V1]; vertices[V1] = vertices[V2]; vertices[V2] = vertices[V3]; vertices[V3] = vertices[V4]; vertices[V4] = tempV; float tempU = vertices[U1]; vertices[U1] = vertices[U2]; vertices[U2] = vertices[U3]; vertices[U3] = vertices[U4]; vertices[U4] = tempU; break; } case Cell.ROTATE_180: { float tempU = vertices[U1]; vertices[U1] = vertices[U3]; vertices[U3] = tempU; tempU = vertices[U2]; vertices[U2] = vertices[U4]; vertices[U4] = tempU; float tempV = vertices[V1]; vertices[V1] = vertices[V3]; vertices[V3] = tempV; tempV = vertices[V2]; vertices[V2] = vertices[V4]; vertices[V4] = tempV; break; } case Cell.ROTATE_270: { float tempV = vertices[V1]; vertices[V1] = vertices[V4]; vertices[V4] = vertices[V3]; vertices[V3] = vertices[V2]; vertices[V2] = tempV; float tempU = vertices[U1]; vertices[U1] = vertices[U4]; vertices[U4] = vertices[U3]; vertices[U3] = vertices[U2]; vertices[U2] = tempU; break; } } } spriteBatch.draw(region.getTexture(), vertices, 0, 20); x += layerTileWidth; } } y += layerTileHeight; } }
From source file:com.letsrace.game.map.OrthogonalTiledMapRenderer.java
License:Apache License
@Override public void renderTileLayer(TiledMapTileLayer layer) { final Color batchColor = spriteBatch.getColor(); final float color = Color.toFloatBits(batchColor.r, batchColor.g, batchColor.b, batchColor.a * layer.getOpacity()); final int layerWidth = layer.getWidth(); final int layerHeight = layer.getHeight(); final float layerTileWidth = layer.getTileWidth() * unitScale; final float layerTileHeight = layer.getTileHeight() * unitScale; final int col1 = Math.max(0, (int) (viewBounds.x / layerTileWidth)); final int col2 = Math.min(layerWidth, (int) ((viewBounds.x + viewBounds.width + layerTileWidth) / layerTileWidth)); final int row1 = Math.max(0, (int) (viewBounds.y / layerTileHeight)); final int row2 = Math.min(layerHeight, (int) ((viewBounds.y + viewBounds.height + layerTileHeight) / layerTileHeight)); float y = row2 * layerTileHeight; float xStart = col1 * layerTileWidth; final float[] vertices = this.vertices; for (int row = row2; row >= row1; row--) { float x = xStart; for (int col = col1; col < col2; col++) { final TiledMapTileLayer.Cell cell = layer.getCell(col, row); if (cell == null) { x += layerTileWidth;/*from w ww .j ava 2s.co m*/ continue; } final TiledMapTile tile = cell.getTile(); if (tile != null) { final boolean flipX = cell.getFlipHorizontally(); final boolean flipY = cell.getFlipVertically(); final int rotations = cell.getRotation(); TextureRegion region = tile.getTextureRegion(); float x1 = x + tile.getOffsetX() * unitScale; float y1 = y + tile.getOffsetY() * unitScale; float x2 = x1 + region.getRegionWidth() * unitScale; float y2 = y1 + region.getRegionHeight() * unitScale; float u1 = region.getU(); float v1 = region.getV2(); float u2 = region.getU2(); float v2 = region.getV(); vertices[X1] = x1; vertices[Y1] = y1; vertices[C1] = color; vertices[U1] = u1; vertices[V1] = v1; vertices[X2] = x1; vertices[Y2] = y2; vertices[C2] = color; vertices[U2] = u1; vertices[V2] = v2; vertices[X3] = x2; vertices[Y3] = y2; vertices[C3] = color; vertices[U3] = u2; vertices[V3] = v2; vertices[X4] = x2; vertices[Y4] = y1; vertices[C4] = color; vertices[U4] = u2; vertices[V4] = v1; if (flipX) { float temp = vertices[U1]; vertices[U1] = vertices[U3]; vertices[U3] = temp; temp = vertices[U2]; vertices[U2] = vertices[U4]; vertices[U4] = temp; } if (flipY) { float temp = vertices[V1]; vertices[V1] = vertices[V3]; vertices[V3] = temp; temp = vertices[V2]; vertices[V2] = vertices[V4]; vertices[V4] = temp; } if (rotations != 0) { switch (rotations) { case Cell.ROTATE_90: { float tempV = vertices[V1]; vertices[V1] = vertices[V2]; vertices[V2] = vertices[V3]; vertices[V3] = vertices[V4]; vertices[V4] = tempV; float tempU = vertices[U1]; vertices[U1] = vertices[U2]; vertices[U2] = vertices[U3]; vertices[U3] = vertices[U4]; vertices[U4] = tempU; break; } case Cell.ROTATE_180: { float tempU = vertices[U1]; vertices[U1] = vertices[U3]; vertices[U3] = tempU; tempU = vertices[U2]; vertices[U2] = vertices[U4]; vertices[U4] = tempU; float tempV = vertices[V1]; vertices[V1] = vertices[V3]; vertices[V3] = tempV; tempV = vertices[V2]; vertices[V2] = vertices[V4]; vertices[V4] = tempV; break; } case Cell.ROTATE_270: { float tempV = vertices[V1]; vertices[V1] = vertices[V4]; vertices[V4] = vertices[V3]; vertices[V3] = vertices[V2]; vertices[V2] = tempV; float tempU = vertices[U1]; vertices[U1] = vertices[U4]; vertices[U4] = vertices[U3]; vertices[U3] = vertices[U2]; vertices[U2] = tempU; break; } } } spriteBatch.draw(region.getTexture(), vertices, 0, 20); } x += layerTileWidth; } y -= layerTileHeight; } }
From source file:com.mygdx.game.MyOrthogonalTiledMapRenderer.java
License:Apache License
@Override public void renderTileLayer(TiledMapTileLayer layer) { final Color batchColor = spriteBatch.getColor(); final float color = Color.toFloatBits(batchColor.r, batchColor.g, batchColor.b, batchColor.a * layer.getOpacity()); final int layerWidth = layer.getWidth(); final int layerHeight = layer.getHeight(); final float layerTileWidth = layer.getTileWidth() * unitScale; final float layerTileHeight = layer.getTileHeight() * unitScale; final int col1 = Math.max(0, (int) (viewBounds.x / layerTileWidth)); final int col2 = Math.min(layerWidth, (int) ((viewBounds.x + viewBounds.width + layerTileWidth) / layerTileWidth)); final int row1 = Math.max(0, (int) (viewBounds.y / layerTileHeight)); final int row2 = Math.min(layerHeight, (int) ((viewBounds.y + viewBounds.height + layerTileHeight) / layerTileHeight)); float y = row2 * layerTileHeight; float xStart = col1 * layerTileWidth; final float[] vertices = this.vertices; for (int row = row2; row >= row1; row--) { float x = xStart; for (int col = col1; col < col2; col++) { final TiledMapTileLayer.Cell cell = layer.getCell(col, row); if (cell == null) { x += layerTileWidth;/* w w w. j a v a 2 s . c o m*/ continue; } final TiledMapTile tile = cell.getTile(); if (tile != null) { final boolean flipX = cell.getFlipHorizontally(); final boolean flipY = cell.getFlipVertically(); final int rotations = cell.getRotation(); TextureRegion region = tile.getTextureRegion(); fixBleeding(region); float x1 = x + tile.getOffsetX() * unitScale; float y1 = y + tile.getOffsetY() * unitScale; float x2 = x1 + region.getRegionWidth() * unitScale; float y2 = y1 + region.getRegionHeight() * unitScale; float u1 = region.getU(); float v1 = region.getV2(); float u2 = region.getU2(); float v2 = region.getV(); vertices[X1] = x1; vertices[Y1] = y1; vertices[C1] = color; vertices[U1] = u1; vertices[V1] = v1; vertices[X2] = x1; vertices[Y2] = y2; vertices[C2] = color; vertices[U2] = u1; vertices[V2] = v2; vertices[X3] = x2; vertices[Y3] = y2; vertices[C3] = color; vertices[U3] = u2; vertices[V3] = v2; vertices[X4] = x2; vertices[Y4] = y1; vertices[C4] = color; vertices[U4] = u2; vertices[V4] = v1; if (flipX) { float temp = vertices[U1]; vertices[U1] = vertices[U3]; vertices[U3] = temp; temp = vertices[U2]; vertices[U2] = vertices[U4]; vertices[U4] = temp; } if (flipY) { float temp = vertices[V1]; vertices[V1] = vertices[V3]; vertices[V3] = temp; temp = vertices[V2]; vertices[V2] = vertices[V4]; vertices[V4] = temp; } if (rotations != 0) { switch (rotations) { case Cell.ROTATE_90: { float tempV = vertices[V1]; vertices[V1] = vertices[V2]; vertices[V2] = vertices[V3]; vertices[V3] = vertices[V4]; vertices[V4] = tempV; float tempU = vertices[U1]; vertices[U1] = vertices[U2]; vertices[U2] = vertices[U3]; vertices[U3] = vertices[U4]; vertices[U4] = tempU; break; } case Cell.ROTATE_180: { float tempU = vertices[U1]; vertices[U1] = vertices[U3]; vertices[U3] = tempU; tempU = vertices[U2]; vertices[U2] = vertices[U4]; vertices[U4] = tempU; float tempV = vertices[V1]; vertices[V1] = vertices[V3]; vertices[V3] = tempV; tempV = vertices[V2]; vertices[V2] = vertices[V4]; vertices[V4] = tempV; break; } case Cell.ROTATE_270: { float tempV = vertices[V1]; vertices[V1] = vertices[V4]; vertices[V4] = vertices[V3]; vertices[V3] = vertices[V2]; vertices[V2] = tempV; float tempU = vertices[U1]; vertices[U1] = vertices[U4]; vertices[U4] = vertices[U3]; vertices[U3] = vertices[U2]; vertices[U2] = tempU; break; } } } spriteBatch.draw(region.getTexture(), vertices, 0, 20); } x += layerTileWidth; } y -= layerTileHeight; } }
From source file:com.stercore.code.net.dermetfan.utils.libgdx.maps.MapUtils.java
License:Apache License
/** @see #readableHierarchy(com.badlogic.gdx.maps.Map, int) */ public static String readableHierarchy(MapLayer layer, int indent) { String hierarchy = ""; for (int i = 0; i < indent; i++) hierarchy += '\t'; hierarchy += ClassReflection.getSimpleName(layer.getClass()); if (layer instanceof TiledMapTileLayer) { TiledMapTileLayer tileLayer = (TiledMapTileLayer) layer; hierarchy += " (size: " + tileLayer.getWidth() + 'x' + tileLayer.getHeight() + ", tile size: " + tileLayer.getTileWidth() + 'x' + tileLayer.getTileHeight() + ')'; } else/*from ww w . java2s .co m*/ hierarchy += ' ' + layer.getName(); hierarchy += '\n'; hierarchy += readableHierarchy(layer.getProperties(), indent + 1); hierarchy += readableHierarchy(layer.getObjects(), indent + 1); return hierarchy; }
From source file:com.stercore.code.net.dermetfan.utils.libgdx.maps.MapUtils.java
License:Apache License
/** sets the given Vector2 to the max width and height of all {@link TiledMapTileLayer tile layers} of the given map * @param map the map to measure/*from w w w. ja v a 2 s.c o m*/ * @param output the Vector2 to set to the map size * @return the given Vector2 representing the map size */ public static Vector2 size(TiledMap map, Vector2 output) { Array<TiledMapTileLayer> layers = map.getLayers().getByType(TiledMapTileLayer.class); float maxWidth = 0, maxTileWidth = 0, maxHeight = 0, maxTileHeight = 0; for (TiledMapTileLayer layer : layers) { int layerWidth = layer.getWidth(), layerHeight = layer.getHeight(); float layerTileWidth = layer.getTileWidth(), layerTileHeight = layer.getTileHeight(); if (layerWidth > maxWidth) maxWidth = layerWidth; if (layerTileWidth > maxTileWidth) maxTileWidth = layerTileWidth; if (layerHeight > maxHeight) maxHeight = layerHeight; if (layerTileHeight > maxTileHeight) maxTileHeight = layerTileHeight; } return output.set(maxWidth * maxTileWidth, maxHeight * maxTileHeight); }