java - Libgdx cambia el color de la Textura en tiempo de ejecución

colors textures

Question

en un juego, hecho con Libgdx tengo un TextureAtlas , en el cual TextureAtlas todas las TextureRegion para mis Animation del Player . El Player tiene una camiseta azul por defecto (por ejemplo).
Ahora me gustaría poder tener más de un Player , y cada Player debería tener otro color de camiseta.
Así que, básicamente, quiero reemplazar el azul con rojo para el segundo Player , con verde para el 3er Player y así sucesivamente.
Estoy seguro de que puedo hacer esto con PixMap , pero ¿no perdería la ventaja de las TextureAtlas ?
¿Hay otra posibilidad de hacer esto? ¿O necesito tener cada "versión de color" como una TextureRegion en TextureAtlas ?
Otra pequeña pregunta:
Con Gimp (y tal vez algunos otros programas) puede usar índices de color para archivos ".gif".
Esto reduce el tamaño de todas las Texture , guardando un índice para cada color en el archivo y luego usando este índice para describir los píxeles. Por lo tanto, para cada píxel rojo tendría un "1" en lugar de "# FF0000" y en algún lugar del archivo tiene un "1 = # FF0000".
Si luego empaqueta los archivos ".gif" con los índices de color dentro de un TextureAtlas , ¿se pierde el índice y restaura los colores RGB predeterminados o dará problemas?

¡Muchas gracias!

Answer 1

Una forma de hacer esto es simplemente establecer un número máximo de jugadores, y hacer camisetas para todos, y empacarlos con atlas de texturas y agregarlos en una matriz TextureRegion.

Ahora solo tendrías que cambiar entre índices.

Otra forma de hacerlo es con batch.setColor

void    setColor(Color tint)
void    setColor(float color) 
void    setColor(float r, float g, float b, float a) 

Y simplemente configure el color del lote de sprites para cada camiseta que dibuje, y después de dibujarlas todas, vuelva a poner el color del spritebatch en blanco.

También puede hacer esto con la clase Sprite con la función setColor.

Si sus camisetas no tienen un tamaño muy grande, y su número máximo de jugadores es pequeño, recomendaría el primer método.

Answer 2

Enfrenté el mismo problema para generar armas con colores aleatorios usando la misma textura.

Entonces escribí esto.
Básicamente, hago un mapa de píxeles de la textura que desea editar.

Luego, itera sobre todos los píxeles, mientras que al iterar verifico ciertos colores que son parte de una parte específica de la textura. (Sugiero usar diferentes tonos de gris ya que el RGB es el mismo)

Luego, cuando está en un píxel donde se necesita cambiar el color, tomo un color para esos grupos de píxeles usando un método de selección de color que es básicamente aleatorio, que obtiene un color de una matriz de colores prefabricada,
y luego cambia ese píxel específico al nuevo color.

/**
 * Requires a asset''s textureName, and requires gray scale colors of the
 * parts
 * 
 * @param texturename
 * @param colorBlade
 * @param colorEdge
 * @param colorAffinity
 * @param colorGrip
 * @return
 */
private static Texture genTexture(String texturename, int colorBlade,
        int colorEdge, int colorAffinity, int colorGrip, int colorExtra) {
    Texture tex = Game.res.getTexture(texturename);

    TextureData textureData = tex.getTextureData();
    textureData.prepare();

    Color tintBlade = chooseColor(mainColors);
    Color tintEdge = new Color(tintBlade.r + 0.1f, tintBlade.g + 0.1f,
            tintBlade.b + 0.1f, 1);

    Color tintAffinity = chooseColor(affinityColors);
    Color tintGrip;
    Color tintExtra = chooseColor(extraColors);

    boolean colorsAreSet = false;

    do {
        tintGrip = chooseColor(mainColors);

        if (tintAffinity != tintBlade && tintAffinity != tintGrip
                && tintGrip != tintBlade) {
            colorsAreSet = true;
        }
    } while (!colorsAreSet);

    Pixmap pixmap = tex.getTextureData().consumePixmap();

    for (int y = 0; y < pixmap.getHeight(); y++) {
        for (int x = 0; x < pixmap.getWidth(); x++) {

            Color color = new Color();
            Color.rgba8888ToColor(color, pixmap.getPixel(x, y));
            int colorInt[] = getColorFromHex(color);

            if (colorInt[0] == colorBlade && colorInt[1] == colorBlade
                    && colorInt[2] == colorBlade) {
                pixmap.setColor(tintBlade);
                pixmap.fillRectangle(x, y, 1, 1);
            } else if (colorInt[0] == colorEdge && colorInt[1] == colorEdge
                    && colorInt[2] == colorEdge) {
                pixmap.setColor(tintEdge);
                pixmap.fillRectangle(x, y, 1, 1);
            } else if (colorInt[0] == colorAffinity
                    && colorInt[1] == colorAffinity
                    && colorInt[2] == colorAffinity) {
                pixmap.setColor(tintAffinity);
                pixmap.fillRectangle(x, y, 1, 1);
            } else if (colorInt[0] == colorGrip && colorInt[1] == colorGrip
                    && colorInt[2] == colorGrip) {
                pixmap.setColor(tintGrip);
                pixmap.fillRectangle(x, y, 1, 1);
            }
            else if (colorInt[0] == colorExtra && colorInt[1] == colorExtra
                && colorInt[2] == colorExtra) {
            pixmap.setColor(tintExtra);
            pixmap.fillRectangle(x, y, 1, 1);
            }
        }
    }

    tex = new Texture(pixmap);
    textureData.disposePixmap();
    pixmap.dispose();

    return tex;
}

Espero que esto ayude.
No copie y pegue, intente reconstruir esto para adaptarlo a sus necesidades o no aprenderá nada.