Пример #1
0
  private int addBlock(int[][] layer, int layerNum, int blockRow, int blockCol, boolean blended) {
    int tile;
    AtlasRegion region;
    cache.beginCache();

    int firstCol = blockCol * tilesPerBlockX;
    int firstRow = blockRow * tilesPerBlockY;
    int lastCol = firstCol + tilesPerBlockX;
    int lastRow = firstRow + tilesPerBlockY;

    int row, col;
    float x, y;

    for (row = firstRow; row < lastRow && row < layer.length; row++) {
      for (col = firstCol; col < lastCol && col < layer[row].length; col++) {
        tile = layer[row][col];
        if (tile != 0) {
          if (blended == blendedTiles.contains(tile)) {
            region = atlas.getRegion(tile);
            if (region != null) {
              y = (layer.length - row) * tileHeight - (region.packedHeight + region.offsetY);
              x = col * tileWidth + region.offsetX;
              cache.add(region, x, y);
            }
          }
        }
      }
    }

    return cache.endCache();
  }
Пример #2
0
  /**
   * Renders specific layers between the given Tiled world coordinates.
   *
   * @param x The x coordinate to start drawing (in pixels)
   * @param y the y coordinate to start drawing (in pixels)
   * @param width the width of the tiles to draw (in pixels)
   * @param height the width of the tiles to draw (in pixels)
   * @param layers The list of layers to draw, 0 being the lowest layer. You will get an
   *     IndexOutOfBoundsException if a layer number is too high.
   */
  public void render(float x, float y, int width, int height, int[] layers) {
    lastRow = (int) ((mapHeightPixels - (y - height + overdrawY)) / (tilesPerBlockY * tileHeight));
    initialRow = (int) ((mapHeightPixels - (y - overdrawY)) / (tilesPerBlockY * tileHeight));
    initialRow = (initialRow > 0) ? initialRow : 0; // Clamp initial Row > 0

    initialCol = (int) ((x - overdrawX) / (tilesPerBlockX * tileWidth));
    initialCol = (initialCol > 0) ? initialCol : 0; // Clamp initial Col > 0
    lastCol = (int) ((x + width + overdrawX) / (tilesPerBlockX * tileWidth));

    Gdx.gl.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);

    cache.begin();
    for (currentLayer = 0; currentLayer < layers.length; currentLayer++) {
      for (currentRow = initialRow;
          currentRow <= lastRow && currentRow < getLayerHeightInBlocks(currentLayer);
          currentRow++) {
        for (currentCol = initialCol;
            currentCol <= lastCol && currentCol < getLayerWidthInBlocks(currentLayer, currentRow);
            currentCol++) {
          Gdx.gl.glDisable(GL10.GL_BLEND);
          cache.draw(normalCacheId[layers[currentLayer]][currentRow][currentCol]);
          Gdx.gl.glEnable(GL10.GL_BLEND);
          cache.draw(blendedCacheId[layers[currentLayer]][currentRow][currentCol]);
        }
      }
    }
    cache.end();
    Gdx.gl.glDisable(GL10.GL_BLEND);
  }
Пример #3
0
  /**
   * Carga los layers desde el arrayList
   *
   * @param maplayers un conjunto de layers que se dibujaran en el mismo orden que esten en el
   *     ArrayList
   */
  public void Cargar(ArrayList<TiledLayer> maplayers) {

    texture = new Texture(Gdx.files.internal("gfx/Tiles/ambiente.png"));

    for (int i = 0; i < LAYERS; i++) {
      caches[i] = new SpriteCache();
      cache = caches[i];
      cache.beginCache();
      for (int y = 0; y < HEIGHT; y++) {
        for (int x = 0; x < WIDTH; x++) {
          int textureX = maplayers.get(i).tiles[y][x] % 16;
          int textureY = maplayers.get(i).tiles[y][x] / 16;
          if (textureX != 0 || textureY != 0) {
            int tileX = x * TILE_SIZE;
            int tileY = ((HEIGHT - y) * TILE_SIZE);

            cache.add(
                texture,
                tileX,
                tileY,
                textureX * (TILE_SIZE),
                textureY * (TILE_SIZE),
                TILE_SIZE,
                TILE_SIZE);
          }
        }
      }

      layers[i] = cache.endCache();
    }
  }
Пример #4
0
  private void initBackground() {
    backCache = new SpriteCache();
    backCache.beginCache();

    TextureRegion backRegion = Globals.atlas.findRegion("back");

    float w = backRegion.getRegionWidth() * 2;
    float h = backRegion.getRegionWidth() * 2;

    for (int y = 0; y < Globals.PSCR_H; y += h)
      for (int x = 0; x < Globals.PSCR_W; x += w) backCache.add(backRegion, x, y, w, h);

    backCacheId = backCache.endCache();
  }
Пример #5
0
  private void renderScene() {
    Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);

    backCache.begin();
    backCache.draw(backCacheId);
    backCache.end();

    Matrix4 mviewmx = scroller.cam.view;

    world.render(mviewmx);
    renderPlayer(mviewmx);

    renderTextOverlay();
  }
  /**
   * Renders specific layers between the given bounding box in map units.
   *
   * @param x The x coordinate to start drawing
   * @param y the y coordinate to start drawing
   * @param width the width of the tiles to draw
   * @param height the width of the tiles to draw
   * @param layers The list of layers to draw, 0 being the lowest layer. You will get an
   *     IndexOutOfBoundsException if a layer number is too high.
   */
  public void render(float x, float y, float width, float height, int[] layers) {
    lastRow = (int) ((mapHeightUnits - (y - height + overdrawY)) / (unitsPerBlockY));
    initialRow = (int) ((mapHeightUnits - (y - overdrawY)) / (unitsPerBlockY));
    initialRow = (initialRow > 0) ? initialRow : 0; // Clamp initial Row > 0

    lastCol = (int) ((x + width + overdrawX) / (unitsPerBlockX));
    initialCol = (int) ((x - overdrawX) / (unitsPerBlockX));
    initialCol = (initialCol > 0) ? initialCol : 0; // Clamp initial Col > 0

    Gdx.gl.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);

    cache.begin();
    if (isSimpleTileAtlas) {
      // Without this special case the top left corner doesn't work properly on mutilayered maps
      Gdx.gl.glEnable(GL10.GL_BLEND);
      for (currentLayer = 0; currentLayer < layers.length; currentLayer++) {
        for (currentRow = initialRow;
            currentRow <= lastRow && currentRow < getLayerHeightInBlocks(currentLayer);
            currentRow++) {
          for (currentCol = initialCol;
              currentCol <= lastCol && currentCol < getLayerWidthInBlocks(currentLayer, currentRow);
              currentCol++) {
            cache.draw(blendedCacheId[layers[currentLayer]][currentRow][currentCol]);
          }
        }
      }
    } else {
      for (currentLayer = 0; currentLayer < layers.length; currentLayer++) {
        for (currentRow = initialRow;
            currentRow <= lastRow && currentRow < getLayerHeightInBlocks(currentLayer);
            currentRow++) {
          for (currentCol = initialCol;
              currentCol <= lastCol && currentCol < getLayerWidthInBlocks(currentLayer, currentRow);
              currentCol++) {
            Gdx.gl.glDisable(GL10.GL_BLEND);
            cache.draw(normalCacheId[layers[currentLayer]][currentRow][currentCol]);
            Gdx.gl.glEnable(GL10.GL_BLEND);
            cache.draw(blendedCacheId[layers[currentLayer]][currentRow][currentCol]);
          }
        }
      }
    }
    cache.end();
    Gdx.gl.glDisable(GL10.GL_BLEND);
  }
Пример #7
0
  /** Dibuja en pantalla, lo que se cargo previamente en el metodo cargar, de esta clase. */
  public void Render() {
    GL10 gl = Gdx.gl10;
    gl.glClear(GL10.GL_COLOR_BUFFER_BIT);

    gl.glEnable(GL10.GL_BLEND);
    gl.glBlendFunc(GL10.GL_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA);
    for (int i = 0; i < LAYERS; i++) {
      SpriteCache cache = caches[i];
      cache.setProjectionMatrix(cam.combined);
      cache.begin();
      for (int j = 0; j < TILES_PER_LAYER; j += BLOCK_TILES) {
        cache.draw(layers[i], j, BLOCK_TILES);
      }
      cache.end();
    }

    if (System.nanoTime() - startTime >= 1000000000) {
      // Gdx.app.log("TileTest", "fps: " + Gdx.graphics.getFramesPerSecond());
      startTime = System.nanoTime();
    }
  }
Пример #8
0
  /**
   * Constructs a map from a TMX file
   *
   * @param fileHandle A {@link FileHandle} to a .tmx file
   * @param loadTilesets True if the tileset images should be loaded
   * @throws IOException Thrown if the map file could not be parsed
   */
  public TiledMap(FileHandle fileHandle, boolean loadTilesets) throws IOException {
    this();
    this.loadTilesets = loadTilesets;
    this.fileHandle = fileHandle;

    TiledParser parser = new TiledParser();
    parser.addListener(this);
    parser.parse(fileHandle);

    if (loadTilesets) {
      layerCache = new SpriteCache(getWidth() * getHeight() * tileLayers.size(), true);
      for (int layer = 0; layer < tileLayers.size(); layer++) {
        layerCache.beginCache();
        for (int y = 0; y < getHeight(); y++) {
          for (int x = 0; x < getWidth(); x++) {
            int tileId = tileLayers.get(layer).getTileId(x, y);

            if (tileId > 0) {
              int tileRenderX = x * getTileWidth();
              int tileRenderY = y * getTileHeight();

              for (int i = 0; i < tilesets.size(); i++) {
                Tileset tileset = tilesets.get(i);
                if (tileset.contains(tileId)) {
                  layerCache.add(tileset.getTile(tileId).getTileImage(), tileRenderX, tileRenderY);
                  break;
                }
              }
            }
          }
        }
        int layerCacheId = layerCache.endCache();
        layerCacheIds.put(tileLayers.get(layer), layerCacheId);
      }
    }
  }
Пример #9
0
 /** Releases all resources held by this TiledMapRenderer. */
 public void dispose() {
   cache.dispose();
 }
Пример #10
0
 public Matrix4 getTransformMatrix() {
   return cache.getTransformMatrix();
 }
Пример #11
0
 public Matrix4 getProjectionMatrix() {
   return cache.getProjectionMatrix();
 }
Пример #12
0
 /** Releases all resources held by this TiledMapRenderer. */
 @Override
 public void dispose() {
   cache.dispose();
 }
Пример #13
0
  private int addBlock(int[][] layer, int blockRow, int blockCol, boolean blended) {
    cache.beginCache();

    int firstCol = blockCol * tilesPerBlockX;
    int firstRow = blockRow * tilesPerBlockY;
    int lastCol = firstCol + tilesPerBlockX;
    int lastRow = firstRow + tilesPerBlockY;

    float offsetX = ((tileWidth - unitsPerTileX) / 2);
    float offsetY = ((tileHeight - unitsPerTileY) / 2);

    for (int row = firstRow; row < lastRow && row < layer.length; row++) {
      for (int col = firstCol; col < lastCol && col < layer[row].length; col++) {
        int tile = layer[row][col];

        boolean flipX = ((tile & FLAG_FLIP_X) != 0);
        boolean flipY = ((tile & FLAG_FLIP_Y) != 0);
        boolean rotate = ((tile & FLAG_ROTATE) != 0);

        tile = tile & ~MASK_CLEAR;

        if (tile != 0) {
          if (blended == blendedTiles.contains(tile)) {
            TextureRegion reg = atlas.getRegion(tile);
            if (reg != null) {

              float x = col * unitsPerTileX - offsetX;
              float y = (layer.length - row - 1) * unitsPerTileY - offsetY;
              float width = reg.getRegionWidth();
              float height = reg.getRegionHeight();
              float originX = width * 0.5f;
              float originY = height * 0.5f;
              float scaleX = unitsPerTileX / tileWidth;
              float scaleY = unitsPerTileY / tileHeight;
              float rotation = 0;
              int sourceX = reg.getRegionX();
              int sourceY = reg.getRegionY();
              int sourceWidth = reg.getRegionWidth();
              int sourceHeight = reg.getRegionHeight();

              if (rotate) {
                if (flipX && flipY) {
                  rotation = -90;
                  sourceX += sourceWidth;
                  sourceWidth = -sourceWidth;
                } else if (flipX && !flipY) {
                  rotation = -90;
                } else if (flipY && !flipX) {
                  rotation = +90;
                } else if (!flipY && !flipX) {
                  rotation = -90;
                  sourceY += sourceHeight;
                  sourceHeight = -sourceHeight;
                }
              } else {
                if (flipX) {
                  sourceX += sourceWidth;
                  sourceWidth = -sourceWidth;
                }
                if (flipY) {
                  sourceY += sourceHeight;
                  sourceHeight = -sourceHeight;
                }
              }

              cache.add(
                  reg.getTexture(),
                  x,
                  y,
                  originX,
                  originY,
                  width,
                  height,
                  scaleX,
                  scaleY,
                  rotation,
                  sourceX,
                  sourceY,
                  sourceWidth,
                  sourceHeight,
                  false,
                  false);
            }
          }
        }
      }
    }

    return cache.endCache();
  }