Java 类com.badlogic.gdx.graphics.Pixmap 实例源码

public static void takeScreenshot() {
    byte[] pixels = ScreenUtils.getFrameBufferPixels(0, 0,
            Gdx.graphics.getBackBufferWidth(),
            Gdx.graphics.getBackBufferHeight(), true);

    Pixmap pixmap = new Pixmap(Gdx.graphics.getBackBufferWidth(),
            Gdx.graphics.getBackBufferHeight(), Pixmap.Format.RGBA8888);
    BufferUtils.copy(pixels, 0, pixmap.getPixels(), pixels.length);

    SimpleDateFormat dateFormat = new SimpleDateFormat(
            "yyyy-MM-dd HH-mm-ss");

    PixmapIO.writePNG(
            Gdx.files.external(dateFormat.format(new Date()) + ".png"),
            pixmap);
    pixmap.dispose();
}

/** A utility method to write the given array of pixmaps to the given output directory, with the specified file name. If the
 * pages array is of length 1, then the resulting file ref will look like: "fileName.png".
 *
 * If the pages array is greater than length 1, the resulting file refs will be appended with "_N", such as "fileName_0.png",
 * "fileName_1.png", "fileName_2.png" etc.
 *
 * The returned string array can then be passed to the <tt>writeFont</tt> method.
 *
 * Note: None of the pixmaps will be disposed.
 *
 * @param pages the pages of pixmap data to write
 * @param outputDir the output directory
 * @param fileName the file names for the output images
 * @return the array of string references to be used with <tt>writeFont</tt> */
public static String[] writePixmaps (Pixmap[] pages, FileHandle outputDir, String fileName) {
  if (pages == null || pages.length == 0) throw new IllegalArgumentException("no pixmaps supplied to BitmapFontWriter.write");

  String[] pageRefs = new String[pages.length];

  for (int i = 0; i < pages.length; i++) {
    String ref = pages.length == 1 ? (fileName + ".png") : (fileName + "_" + i + ".png");

    // the ref for this image
    pageRefs[i] = ref;

    // write the PNG in that directory
    PixmapIO.writePNG(outputDir.child(ref), pages[i]);
  }
  return pageRefs;
}

private void createToolTip()
{
    Skin skin = new Skin();
    Pixmap pixmap = new Pixmap(1, 1, Pixmap.Format.RGBA8888);
    pixmap.setColor(Color.WHITE);
    pixmap.fill();
    skin.add("white", new Texture(pixmap));
    skin.add("default", new BitmapFont());

    TextButton.TextButtonStyle textButtonStyle = new TextButton.TextButtonStyle();
    textButtonStyle.up = skin.newDrawable("white", new Color(0, 0, 0, 1));
    textButtonStyle.font = skin.getFont("default");
    skin.add("default", textButtonStyle);

    labelToolTip = new TextButton("TEST", skin);
    labelToolTip.setX(5);
    labelToolTip.setY(5);
    labelToolTip.setWidth(125);
    labelToolTip.setVisible(false);
    labelToolTip.getLabel().setWrap(true);
    labelToolTip.setHeight(labelToolTip.getLabel().getHeight());
    group.addActor(labelToolTip);
}

private void createResetButton()
{
    Skin skin = new Skin();
    Pixmap pixmap = new Pixmap(1, 1, Pixmap.Format.RGBA8888);
    pixmap.setColor(Color.WHITE);
    pixmap.fill();
    skin.add("white", new Texture(pixmap));
    skin.add("default", new BitmapFont());

    TextButton.TextButtonStyle textButtonStyle = new TextButton.TextButtonStyle();
    textButtonStyle.up = skin.newDrawable("white", new Color(0, 0, 0, 1));
    textButtonStyle.font = skin.getFont("default");
    skin.add("default", textButtonStyle);

    btnReset = new TextButton("RESET", skin);
    btnReset.setX(5);
    btnReset.setY(Gdx.graphics.getHeight() - 25);
    btnReset.setWidth(60);
    btnReset.setVisible(true);
    group.addActor(btnReset);
}

private void createUndoButton()
{
    Skin skin = new Skin();
    Pixmap pixmap = new Pixmap(1, 1, Pixmap.Format.RGBA8888);
    pixmap.setColor(Color.WHITE);
    pixmap.fill();
    skin.add("white", new Texture(pixmap));
    skin.add("default", new BitmapFont());

    TextButton.TextButtonStyle textButtonStyle = new TextButton.TextButtonStyle();
    textButtonStyle.up = skin.newDrawable("white", new Color(0, 0, 0, 1));
    textButtonStyle.font = skin.getFont("default");
    skin.add("default", textButtonStyle);

    btnUndo = new TextButton("UNDO", skin);
    btnUndo.setX(70);
    btnUndo.setY(Gdx.graphics.getHeight() - 25);
    btnUndo.setWidth(60);
    btnUndo.setVisible(true);
    group.addActor(btnUndo);
}

public void setColor(int color) {
    Pixmap pix = new Pixmap(1, 1, Pixmap.Format.RGBA8888);
    pix.setColor(color);
    pix.fill();
    Texture tex = new Texture(pix);
    TextureRegion region = new TextureRegion(tex);

    Point p1 = (Point) parent.getPoints().toArray()[0];
    Point p2 = (Point) parent.getPoints().toArray()[1];
    Point p3 = (Point) parent.getPoints().toArray()[2];
    Point p4 = (Point) parent.getPoints().toArray()[3];
    Point p5 = (Point) parent.getPoints().toArray()[4];
    Point p6 = (Point) parent.getPoints().toArray()[5];

    float[] vertices = new float[]{(
            float) p1.getCoordinateX(), (float)p1.getCoordinateY(),
            (float)p2.getCoordinateX(), (float)p2.getCoordinateY(),
            (float)p3.getCoordinateX(), (float)p3.getCoordinateY(),
            (float) p4.getCoordinateX(), (float)p4.getCoordinateY(),
            (float)p5.getCoordinateX(), (float)p5.getCoordinateY(),
            (float)p6.getCoordinateX(), (float)p6.getCoordinateY()};
    EarClippingTriangulator triangulator = new EarClippingTriangulator();
    ShortArray triangleIndices = triangulator.computeTriangles(vertices);
    PolygonRegion polygonRegion = new PolygonRegion(region, vertices, triangleIndices.toArray());
    sprite = new PolygonSprite(polygonRegion);
}

public static void takeScreenshot() {
  Pixmap pixmap = ScreenUtils.getFrameBufferPixmap(0, 0, Gdx.graphics.getBackBufferWidth(), Gdx.graphics.getBackBufferHeight());
  FileHandle dir = Compatibility.get().getBaseFolder().child("screenshots");
  dir.mkdirs();
  FileHandle f = dir.child(System.currentTimeMillis() + ".png");
  try {
    PixmapIO.PNG writer = new PixmapIO.PNG((int) (pixmap.getWidth() * pixmap.getHeight() * 1.5f));
    try {
      writer.setFlipY(true);
      writer.write(f, pixmap);
    } finally {
      writer.dispose();
    }
  } catch (IOException ex) {
    throw new CubesException("Error writing PNG: " + f, ex);
  } finally {
    pixmap.dispose();
  }
  Log.info("Took screenshot '" + f.file().getAbsolutePath() + "'");
}

/**
 * Initializes the pattern table textures and pixmap.
 */
public void initialize() {
    //Allocate a pixmap big enough to accommodate both pattern tables.
    patternTablePixmap = new Pixmap(128, 256, Pixmap.Format.RGBA8888);
    //Set blending to none so we can rewrite the pixmap and draw it to the
    //pattern table texture when graphics are regenerated.
    patternTablePixmap.setBlending(Pixmap.Blending.None);

    //Allocate a pixmap the size of one tile for live CHR-RAM updates.
    patternPixmap = new Pixmap(8, 8, Pixmap.Format.RGBA8888);
    patternPixmap.setBlending(Pixmap.Blending.None);

    patternTableTexture = new Texture(patternTablePixmap, false);
    TextureRegion[][] textureRegions = TextureRegion.split(patternTableTexture, 8, 8);
    patternTableSprites = new Sprite[32][16];
    for(int row = 0; row < 32; row++) {
        for(int column = 0; column < 16; column++) {
            TextureRegion textureRegion = textureRegions[row][column];
            patternTableSprites[row][column] = new Sprite(textureRegion);
        }
    }
    initializeMonochromePalette();
}

public void saveAndReload(Map map, Pixmap out){
    if(map.pixmap != null && out != map.pixmap && map.texture != null){
        map.texture.dispose();
        map.texture = new Texture(out);
    }else if (out == map.pixmap){
        map.texture.draw(out, 0, 0);
    }

    map.pixmap = out;
    if(map.texture == null) map.texture = new Texture(map.pixmap);

    if(map.id == -1){
        if(mapNames.containsKey(map.name)){
            map.id = mapNames.get(map.name).id;
        }else{
            map.id = ++lastID;
        }
    }

    if(!Settings.has("hiscore" + map.name)){
        Settings.defaults("hiscore" + map.name, 0);
    }

    saveCustomMap(map);
    Vars.ui.levels.reload();
}

private boolean loadMapFile(FileHandle file){
    try{
        Array<Map> arr = json.fromJson(ArrayContainer.class, file).maps;
        if(arr != null){ //can be an empty map file
            for(Map map : arr){
                map.pixmap = new Pixmap(file.sibling(map.name + ".png"));
                map.texture = new Texture(map.pixmap);
                maps.put(map.id, map);
                mapNames.put(map.name, map);
                lastID = Math.max(lastID, map.id);
            }
        }
        return true;
    }catch(Exception e){
        if(!Vars.android) e.printStackTrace();
        Gdx.app.error("Mindustry-Maps", "Failed loading map file: " + file);
        return false;
    }
}

private void stencil(Planet planet, Texture texture, PlanetCell.CellType[] replaceTypes, int degrees, int x1, int y1) {
    final TextureData textureData = texture.getTextureData();
    textureData.prepare();

    final Pixmap pixmap = textureData.consumePixmap();
    for (int y = 0; y < texture.getHeight(); y++) {
        for (int x = 0; x < texture.getWidth(); x++) {

            tv.set(x, y).rotate(degrees).add(x1, y1);

            int color = pixmap.getPixel(x, texture.getHeight() - y);
            final PlanetCell.CellType type = getSourceCellType(planet, color);
            if (type != null) {
                replaceCell(planet, Math.round(tv.x), Math.round(tv.y), replaceTypes, type, color);
            }

        }
    }
    pixmap.dispose();
}

public void draw(Coordinates<Integer> coords, Pixmap map) {
    int terrainID = world.get(coords.y).get(coords.x);

    // tileID runs 0 through 8, conveniently in the
    // same order as our split tiles texture...
    int ty = (int) terrainID / 3;
    int tx = terrainID % 3;

    TextureRegion tileRegion = tileRegions[ty][tx];

    map.drawPixmap(tilesPixmap,
                   coords.x * tileSize,
                   coords.y * tileSize,
                   tileRegion.getRegionX(),
                   tileRegion.getRegionY(),
                   tileRegion.getRegionWidth(),
                   tileRegion.getRegionHeight());
}

private TileTouchCheck(Pixmap pixelMap, TextureRegion region) {
    this.width = region.getRegionWidth();
    this.height = region.getRegionHeight();
    map = new int[width * height];
    int i = -1;
    // pixmap coordinates have the origin in the top left corner; shift it so it goes from the bottom left instead
    for (int x = 0; x < width; x++) {
        for (int y = height-1; y >= 0; y--) {
            Color color = new Color(pixelMap.getPixel(region.getRegionX() + x, region.getRegionY() + y));

            i++;
            if(color.a == 0) continue; // set to zero, tile doesn't matter

            if(color.equals(Color.WHITE)) // the tile must be different from the center tile
                map[i] = WHITE;
            else if(color.equals(Color.BLACK)) // the tile must be equal to the center tile
                map[i] = BLACK;
        }
    }
}

public PlayerAnimation() {
    nullRegion = new TextureRegion(new Texture(new Pixmap(1, 1, Pixmap.Format.RGBA8888)));
    for (int i = 0; i < regions.length; i++) {
        Pixmap pixmap = new Pixmap(64, 64, Pixmap.Format.RGBA8888);
        pixmap.setColor(0, 0, 1, 1);
        pixmap.fillCircle(32, 32, 10);
        pixmap.setColor(1, 1, 1, 1);
        pixmap.fillCircle(32, 32, 5);
        pixmap.setColor(1, 1, 1, 0.5f);
        pixmap.drawCircle(32, 32, (int) (i * 3f) + 7);
        pixmap.setColor(1, 1, 1, 1f);
        pixmap.drawCircle(32, 32, (int) (i * 3f) + 8);
        pixmap.setColor(1, 1, 1, 0.5f);
        pixmap.drawCircle(32, 32, (int) (i * 3f) + 9);
        regions[i] = new TextureRegion(new Texture(pixmap));
        pixmap.dispose();
    }
    setRegion(regions[0]);
}

public VRCamera(int width, int height, int viewportWidth, int viewportHeight) {
    leftCamera = new PerspectiveCamera(90, viewportWidth, viewportHeight);
    rightCamera = new PerspectiveCamera(90, viewportWidth, viewportHeight);
    leftBuffer = new FrameBuffer(Pixmap.Format.RGBA8888, width, height, true);
    rightBuffer = new FrameBuffer(Pixmap.Format.RGBA8888, width, height, true);
    leftTexture = new TextureRegion();
    rightTexture = new TextureRegion();
    batch = new SpriteBatch();
    this.width = width;
    this.height = height;
    this.viewportWidth = viewportWidth;
    this.viewportHeight = viewportHeight;
    tmpVector3 = new Vector3();
    position = new Vector3(250, 20, 250);
    positionLeft = new Vector3(249.5f, 20, 250);
    positionRight = new Vector3(250.5f, 20, 250);
    direction = new Vector3();
    up = new Vector3(0, 1, 0);
    eyeDistance = 0.5f;
}

private static void setupPixmap(Pixmap p, int i, Color c) {
    p.setColor(c);

    setupPixMapA(i, p);

    if ((i & AmbientOcclusion.E) == AmbientOcclusion.E) {
        p.fillRectangle(AmbientOcclusion.INDIVIDUAL_SIZE * 2, AmbientOcclusion.INDIVIDUAL_SIZE,
                AmbientOcclusion.INDIVIDUAL_SIZE, AmbientOcclusion.INDIVIDUAL_SIZE);
    }

    if ((i & AmbientOcclusion.F) == AmbientOcclusion.F) {
        p.fillRectangle(0, AmbientOcclusion.INDIVIDUAL_SIZE * 2, AmbientOcclusion.INDIVIDUAL_SIZE,
                AmbientOcclusion.INDIVIDUAL_SIZE);
    }
    if ((i & AmbientOcclusion.G) == AmbientOcclusion.G) {
        p.fillRectangle(AmbientOcclusion.INDIVIDUAL_SIZE, AmbientOcclusion.INDIVIDUAL_SIZE * 2,
                AmbientOcclusion.INDIVIDUAL_SIZE, AmbientOcclusion.INDIVIDUAL_SIZE);
    }
    if ((i & AmbientOcclusion.H) == AmbientOcclusion.H) {
        p.fillRectangle(AmbientOcclusion.INDIVIDUAL_SIZE * 2, AmbientOcclusion.INDIVIDUAL_SIZE * 2,
                AmbientOcclusion.INDIVIDUAL_SIZE, AmbientOcclusion.INDIVIDUAL_SIZE);
    }
}

/** A utility method to write the given array of pixmaps to the given output directory, with the specified file name. If the
 * pages array is of length 1, then the resulting file ref will look like: "fileName.png".
 *
 * If the pages array is greater than length 1, the resulting file refs will be appended with "_N", such as "fileName_0.png",
 * "fileName_1.png", "fileName_2.png" etc.
 *
 * The returned string array can then be passed to the <tt>writeFont</tt> method.
 *
 * Note: None of the pixmaps will be disposed.
 *
 * @param pages the pages of pixmap data to write
 * @param outputDir the output directory
 * @param fileName the file names for the output images
 * @return the array of string references to be used with <tt>writeFont</tt> */
public static String[] writePixmaps (Pixmap[] pages, FileHandle outputDir, String fileName) {
  if (pages == null || pages.length == 0) throw new IllegalArgumentException("no pixmaps supplied to BitmapFontWriter.write");

  String[] pageRefs = new String[pages.length];

  for (int i = 0; i < pages.length; i++) {
    String ref = pages.length == 1 ? (fileName + ".png") : (fileName + "_" + i + ".png");

    // the ref for this image
    pageRefs[i] = ref;

    // write the PNG in that directory
    PixmapIO.writePNG(outputDir.child(ref), pages[i]);
  }
  return pageRefs;
}

public static void takeScreenshot() {
    Pixmap pixmap = ScreenUtils.getFrameBufferPixmap(0, 0, Gdx.graphics.getBackBufferWidth(),
            Gdx.graphics.getBackBufferHeight());
    FileHandle dir = Compatibility.get().getBaseFolder().child("screenshots");
    dir.mkdirs();
    FileHandle f = dir.child(System.currentTimeMillis() + ".png");
    try {
        PixmapIO.PNG writer = new PixmapIO.PNG((int) (pixmap.getWidth() * pixmap.getHeight() * 1.5f));
        try {
            writer.setFlipY(true);
            writer.write(f, pixmap);
        } finally {
            writer.dispose();
        }
    } catch (IOException ex) {
        throw new CubesException("Error writing PNG: " + f, ex);
    } finally {
        pixmap.dispose();
    }
    Log.info("Took screenshot '" + f.file().getAbsolutePath() + "'");
}

public void updateVisual(){
    Skin skin = new Skin();
    Pixmap pixmap = new Pixmap(1,(int)(Gdx.graphics.getHeight()*0.0175), Pixmap.Format.RGBA8888);
    switch (infoProfile.getDateUserGame().getFaction()){
        case 1:{
            pixmap.setColor(1, 0f, 0f, 1);
            break;
        }
        case 2:{
            pixmap.setColor(0f, 0.831f, 0.969f,1f);
            break;
        }
        case 3:{
            pixmap.setColor(0.129f, 0.996f, 0.29f,1);
            break;
        }
    }
    pixmap.fill();
    skin.add("blue", new Texture(pixmap));
    ProgressBar.ProgressBarStyle style = new ProgressBar.ProgressBarStyle(bar.getStyle().background,skin.newDrawable("blue",Color.WHITE));
    style.knobBefore = style.knob;
    bar.setStyle(style);
}

/** A utility method to write the given array of pixmaps to the given output directory, with the specified file name. If the
 * pages array is of length 1, then the resulting file ref will look like: "fileName.png".
 *
 * If the pages array is greater than length 1, the resulting file refs will be appended with "_N", such as "fileName_0.png",
 * "fileName_1.png", "fileName_2.png" etc.
 *
 * The returned string array can then be passed to the <tt>writeFont</tt> method.
 *
 * Note: None of the pixmaps will be disposed.
 *
 * @param pages the pages of pixmap data to write
 * @param outputDir the output directory
 * @param fileName the file names for the output images
 * @return the array of string references to be used with <tt>writeFont</tt> */
public static String[] writePixmaps (Pixmap[] pages, FileHandle outputDir, String fileName) {
    if (pages==null || pages.length==0)
        throw new IllegalArgumentException("no pixmaps supplied to BitmapFontWriter.write");

    String[] pageRefs = new String[pages.length];

    for (int i=0; i<pages.length; i++) {
        String ref = pages.length==1 ? (fileName+".png") : (fileName+"_"+i+".png");

        //the ref for this image
        pageRefs[i] = ref;

        //write the PNG in that directory
        PixmapIO.writePNG(outputDir.child(ref), pages[i]);
    }
    return pageRefs;
}

public static SmartTexture createSolid( int color ) {
    String key = "1x1:" + color;

    if (all.containsKey( key )) {

        return all.get( key );

    } else {

        final Pixmap pixmap = new Pixmap(1, 1, Pixmap.Format.RGBA8888);
        // In the rest of the code ARGB is used
        pixmap.setColor( (color << 8) | (color >>> 24) );
        pixmap.fill();
        GdxTexture bmp = new GdxTexture( pixmap );

        SmartTexture tx = new SmartTexture( bmp );
        all.put(key, tx);

        return tx;
    }
}

public Pixmap generateScreenshot(ParticleSystem particleSystem, Player player) {
    final float cam_width = camera.getCameraWidth();
    final float cam_height = camera.getCameraHeight();
    final int current_x = camera.getCameraX();
    final int current_y = camera.getCameraY();
    final Pixmap screen_shot = new Pixmap((int) cam_width, (int) cam_height, Pixmap.Format.RGB888);

    for (int i = current_x; i < current_x + cam_width; i++) {
        for (int j = current_y; j < current_y + cam_height; j++) {
            Particle current_particle = particleSystem.getParticle(i, j);

            if (current_particle != null) {
                screen_shot.setColor(current_particle.getProperties().getColor());
                screen_shot.drawPixel(i - current_x, ((int) cam_height - 1) - (j - current_y));
            }
        }
    }

    return screen_shot;
}

private Texture createHighlightingGraphic(TextureRegion textureRegion)
{
    TextureData textureData = textureRegion.getTexture().getTextureData();
    textureData.prepare();
    Pixmap sourcePixmap = textureData.consumePixmap();
    Pixmap destinationPixmap = new Pixmap(textureRegion.getRegionWidth(), textureRegion.getRegionHeight(), Format.RGBA8888);
    Color color = new Color();

    for (int x = 0; x < textureRegion.getRegionWidth(); x++)
    {
        for (int y = 0; y < textureRegion.getRegionHeight(); y++)
        {
            int colorInt = sourcePixmap.getPixel(textureRegion.getRegionX() + x, textureRegion.getRegionY() + y);
            Color.rgba8888ToColor(color, colorInt);
            destinationPixmap.setColor(1.0f, 1f, 1.0f, 1);
            if (color.a > 0.004f)
                destinationPixmap.drawPixel(x, y);
        }
    }
    Texture result = new Texture(destinationPixmap);
    textureData.disposePixmap();
    destinationPixmap.dispose();
    return result;
}

/**
 * Sets the cursor image.
 * 
 * @param image
 *            The image.
 */
public void setCursorImage(Pixmap image) {
    if (image == null) {
        throw new IllegalArgumentException("Cursor image cannot be null.");
    }

    if (!cursorCacheMap.containsKey(image)) {
        Cursor newCursor = Gdx.graphics.newCursor(image, 0, 0);
        this.cursorCacheMap.put(image, newCursor);

        Gdx.graphics.setCursor(newCursor);
    } else {
        Gdx.graphics.setCursor(cursorCacheMap.get(image));
    }
}

private boolean verifySize(Pixmap pix){
    boolean w = false, h = false;
    for(int i : MapEditor.validMapSizes){
        if(pix.getWidth() == i)
            w = true;
        if(pix.getHeight() == i)
            h = true;
    }

    return w && h;
}

private boolean verifyMap(){
    int psc = ColorMapper.getColor(SpecialBlocks.playerSpawn);
    int esc = ColorMapper.getColor(SpecialBlocks.enemySpawn);

    int playerSpawns = 0;
    int enemySpawns = 0;
    Pixmap pix = editor.pixmap();

    for(int x = 0; x < pix.getWidth(); x ++){
        for(int y = 0; y < pix.getHeight(); y ++){
            int i = pix.getPixel(x, y);
            if(i == psc) playerSpawns ++;
            if(i == esc) enemySpawns ++;
        }
    }

    if(playerSpawns == 0){
        Vars.ui.showError("$text.editor.noplayerspawn");
        return false;
    }else if(playerSpawns > 1){
        Vars.ui.showError("$text.editor.manyplayerspawns");
        return false;
    }

    if(enemySpawns > MapEditor.maxSpawnpoints){
        Vars.ui.showError(Bundles.format("text.editor.manyenemyspawns", MapEditor.maxSpawnpoints));
        return false;
    }

    return true;
}

public void draw(int dx, int dy){
    if(dx < 0 || dy < 0 || dx >= pixmap.getWidth() || dy >= pixmap.getHeight()){
        return;
    }

    Gdx.gl.glBindTexture(GL20.GL_TEXTURE_2D, texture.getTextureObjectHandle());

    int dstWidth = brushSize*2-1;
    int dstHeight = brushSize*2-1;
    int width = pixmap.getWidth(), height = pixmap.getHeight();

    int x = dx - dstWidth/2;
    int y = dy - dstHeight/2;

    if (x + dstWidth > width){
        x = width - dstWidth;
    }else if (x < 0){
        x = 0;
    }

    if (y + dstHeight > height){
        dstHeight = height - y;
    }else if (y < 0){
        dstHeight += y;
        y = 0;
    }

    pixmap.fillCircle(dx, dy, brushSize-1);

    Pixmap dst = brush(brushSize);
    dst.drawPixmap(pixmap, x, y, dstWidth, dstHeight, 0, 0, dstWidth, dstHeight);

    Gdx.gl.glTexSubImage2D(GL20.GL_TEXTURE_2D, 0, x, y, dstWidth, dstHeight,
            dst.getGLFormat(), dst.getGLType(), dst.getPixels());
}

private Pixmap brush(int size){
    for(int i = 0; i < brushSizes.length; i ++){
        if(brushSizes[i] == size){
            return brushPixmaps[i];
        }
    }
    return null;
}

public PixelBuffer() {
    super(Pixmap.Format.RGBA8888, Scene.BUFFER_WIDTH, Scene.BUFFER_HEIGHT, false);
    getColorBufferTexture().setFilter(Texture.TextureFilter.Nearest, Texture.TextureFilter.Nearest);

    pixelBufferRegion = new TextureRegion(getColorBufferTexture(), 0, 0, Scene.BUFFER_WIDTH, Scene.BUFFER_HEIGHT);
    pixelBufferRegion.flip(false, true);
}

public Sprite createMoonSprite(int size) {
        Pixmap pixmap = new Pixmap(size, size, Pixmap.Format.RGBA8888);
//        pixmap.setColor(color);
        pixmap.setColor(Color.WHITE);
        pixmap.fillCircle(pixmap.getWidth()/2, pixmap.getHeight()/2, size / 2 - 1);
        Sprite sprite = new Sprite(new Texture(pixmap));
        pixmap.dispose();
        return sprite;
    }

private void createBasicSkin() {
    // Create a font
    BitmapFont font = new BitmapFont();
    skin = new Skin();
    skin.add("default", font);

    // Create a texture
    Pixmap pixmap = new Pixmap(Gdx.graphics.getWidth() / 4, Gdx.graphics.getHeight() / 10, Pixmap.Format.RGB888);
    pixmap.setColor(Color.WHITE);
    pixmap.fill();
    skin.add("background", new Texture(pixmap));

    // Create a button style
    TextButton.TextButtonStyle textButtonStyle = new TextButton.TextButtonStyle();
    textButtonStyle.up = skin.newDrawable("background", Color.GRAY);
    textButtonStyle.down = skin.newDrawable("background", Color.DARK_GRAY);
    textButtonStyle.checked = skin.newDrawable("background", Color.DARK_GRAY);
    textButtonStyle.over = skin.newDrawable("background", Color.LIGHT_GRAY);
    textButtonStyle.font = skin.getFont("default");
    skin.add("default", textButtonStyle);

    // Create a window style
    Window.WindowStyle windowStyle = new Window.WindowStyle();
    windowStyle.background = skin.newDrawable("background", Color.DARK_GRAY);
    // Dim background
    windowStyle.stageBackground = skin.newDrawable("background", Color.valueOf("#00000099"));
    windowStyle.titleFont = skin.getFont("default");
    windowStyle.titleFontColor = Color.WHITE;
    skin.add("default", windowStyle);
}

public static int pick( int index, int x, int y ) {
    GdxTexture bmp = TextureCache.get( Assets.ITEMS ).bitmap;
    int rows = bmp.getWidth() / SIZE;
    int row = index / rows;
    int col = index % rows;
    // FIXME: I'm assuming this is super slow?
    final TextureData td = bmp.getTextureData();
    if (!td.isPrepared()) {
        td.prepare();
    }
    final Pixmap pixmap = td.consumePixmap();
    int pixel = pixmap.getPixel(col * SIZE + x, row * SIZE + y);
    pixmap.dispose();
    return pixel;
}

/**
 * Re-color a given region
 * @param color New Color for the Region
 * @param region Region to re-color
 */
private void setRegionColor(Color color, AssetMap.Region region) {
    Pixmap pix = new Pixmap(1, 1, Pixmap.Format.RGBA8888);
    pix.setColor(color);
    pix.fill();

    Texture regionTexture = new Texture(pix);
    PolygonRegion polygonRegion = regionMap.get(region);
    polygonRegion.getRegion().setTexture(regionTexture);
}

public static void putPixelsBack(Pixmap pixmap, ByteBuffer pixels) {
    if (pixmap.getWidth() == 0 || pixmap.getHeight() == 0) return;
    if (imageData == null) {
        imageData = pixmap.getContext().createImageData(pixmap.getHeight(), pixmap.getWidth());
    }
    putPixelsBack(pixels.array(), pixmap.getWidth(), pixmap.getHeight(), pixmap.getContext(), imageData);
}

public static Texture resizeTexture(String internalPath, int width, int height) {
    Pixmap pixmap = new Pixmap(width, height, Pixmap.Format.RGBA8888);
    Pixmap origPixmap = new Pixmap(Gdx.files.internal(internalPath));
    pixmap.drawPixmap(origPixmap, 0, 0, origPixmap.getWidth(), origPixmap.getHeight(),
            0, 0, width, height);
    return new Texture(pixmap);
}

/**
 * Takes a screenshot of the current game state and saves it in the assets directory
 */
public void takeScreenshot() {
    byte[] pixels = ScreenUtils.getFrameBufferPixels(0, 0, Gdx.graphics.getBackBufferWidth(), Gdx.graphics.getBackBufferHeight(), true);
    Pixmap pixmap = new Pixmap(Gdx.graphics.getBackBufferWidth(), Gdx.graphics.getBackBufferHeight(), Pixmap.Format.RGBA8888);
    BufferUtils.copy(pixels, 0, pixmap.getPixels(), pixels.length);
    PixmapIO.writePNG(Gdx.files.local("screenshots/screenshot.png"), pixmap);
    pixmap.dispose();
}

@Override
public void setCursorTexture(Pixmap cursorImage) {
    this.cursor = null;

    if (this.newCursorImage != cursorImage) {
        this.newCursorImage = cursorImage;
        changed = true;
    }
}

protected void splitBy(GdxTexture bitmap, int height, int color, String chars, String fntFile, int scale)
{
    autoUppercase = false;

    ArrayList<FntFileChar> realChars = processFntFile(fntFile, scale);

    int width = bitmap.getWidth();
    int length = realChars.size();

    TextureData td = bitmap.getTextureData();
    if (!td.isPrepared())
    {
        td.prepare();
    }
    final Pixmap pixmap = td.consumePixmap();

    for (int i = 0; i < length; i++)
    {
        FntFileChar ch = realChars.get(i);
        if (ch.c == ' ')
        {
            add(ch.c, new RectF(1 - (float) ch.height / 2 / width, 1 - (float) ch.height / height, 1, 1));
            // add('\u007F', new RectF(1 - (float)ch.height / 2 / width, 1 - (float)ch.height / height, 1, 1));
            // in case no such in font
        }
        else
        {
            add(ch.c, new RectF((float) ch.x / width, (float) ch.y / height, (float) (ch.x + ch.width) / width, (float) (ch.y + ch.height) / height));
        }
    }
    pixmap.dispose();

    lineHeight = baseLine = height(frames.get(realChars.get(0).c));
}

public static Texture loadTexture(Crypto crypto, FileHandle file, Pixmap.Format format, boolean useMipMaps) {
    try {
        byte[] bytes = file.readBytes();
        if (crypto != null) {
            bytes = crypto.decrypt(bytes, true);
        }
        Pixmap pixmap = new Pixmap(new Gdx2DPixmap(bytes, 0, bytes.length, 0));
        return new Texture(pixmap, format, useMipMaps);
    } catch (Exception e) {
        throw new GdxRuntimeException("Couldn't load file: " + file, e);
    }
}

protected static void generate(FileHandle file, float strength) {
    Pixmap blocks = new Pixmap(INDIVIDUAL_SIZE * 3, INDIVIDUAL_SIZE * 3, AOTextureGenerator.FORMAT);
    Pixmap gaussian = new Pixmap(INDIVIDUAL_SIZE, INDIVIDUAL_SIZE, AOTextureGenerator.FORMAT);

    Pixmap output = new Pixmap(TEXTURE_SIZE, TEXTURE_SIZE, AOTextureGenerator.FORMAT);

    double[][] gwm = AOTextureGenerator.gaussianWeightMatrix(SIGMA);
    int gaussianRadius = (gwm.length - 1) / 2;

    Color blockColor = new Color(strength, strength, strength, 1f);

    for (int i = 0; i < TOTAL; i++) {
        String n = name(i);
        System.out.print(n + " ");

        AOTextureGenerator.clearPixmap(blocks);
        AOTextureGenerator.clearPixmap(gaussian);

        AOTextureGenerator.setupPixmap(blocks, i, blockColor);

        AOTextureGenerator.gaussianPixmap(blocks, gaussian, gwm, gaussianRadius);

        // PixmapIO.writePNG(folder.child(n + "_blocks_" + sigma + ".png"),
        // blocks);
        // PixmapIO.writePNG(folder.child(n + "_gaussian_" + sigma +
        // ".png"), gaussian);

        output.drawPixmap(gaussian, (i % SQRT_TOTAL) * INDIVIDUAL_SIZE, (i / SQRT_TOTAL) * INDIVIDUAL_SIZE, 0, 0,
                INDIVIDUAL_SIZE, INDIVIDUAL_SIZE);

        if (i % SQRT_TOTAL == SQRT_TOTAL - 1)
            System.out.println();
    }

    PixmapIO.writePNG(file, output);
    output.dispose();
    blocks.dispose();
    gaussian.dispose();
}