Textura de texturepacker en LibGDX

Tratando de obtener mi cabeza alrededor de la envoltura de textura en (el impresionante) marco LibGDX y necesito ayuda.

Me gustaría unir una textura (de acuerdo a Malla, Color y Textura ) que se extrae de un TextureAtlas embalado con el TexturePacker. La textura se une a una malla rectangular.

Quiero que la textura (instancia de textura) se extraiga básicamente de un archivo empaquetado.

¿Es posible utilizar los métodos createdprite o findregion y de alguna manera omitir el paso filehandle?

Además: ¿Algo especial debe tener en cuenta al combinar el método anterior con el AssetManager?

Gracias por separarme!

    2 Solutions collect form web for “Textura de texturepacker en LibGDX”

    Crear la región de textura

    Primero, crea un objeto TextureAtlas apuntando al archivo de texto que describe su atlas (la herramienta que crea el atlas creará dos archivos: una imagen y un archivo de texto que describa su contenido):

     TextureAtlas myTextures = new TextureAtlas("images/packed.txt"); 

    A continuación, puede buscar una TextureRegion en ese atlas (es decir, una sub-textura específica del atlas). La región debe tener el nombre de base del archivo original que se utilizó (hay más detalles y opciones si sigue algunas de las convenciones de nomenclatura especiales para crear matrices de elementos de textura, pero déjelo por ahora):

     TextureRegion region = myTextures.findRegion(fname); 

    Configurar una malla con textura

    Para dibujar esta región de textura en una malla, necesitará inicializar la Mesh con soporte para las coordenadas de textura:

     Mesh myMesh = new Mesh(..., new VertexAttribute(Usage.TextureCoordinates, 2, "y")); 

    El new VertexAttribute(Usage.TextureCoordinates, 2, ...) le dice a libGDX que esta malla tendrá dos coordenadas de textura por vértice (tradicionalmente, las dos coordenadas de textura son llamadas u ). Puede tener un montón de atributos diferentes por vértice, pero voy a asumir que el único otro atributo es un uso de 3 valores. Usage.Position para las coordenadas espaciales x, y, z.

    Ahora, en la matriz de flotadores que define tu malla (la matriz que pasas a setVertices ) debes establecer las coordenadas espaciales x, y y z más u, y v las coordenadas de textura para cada vértice:

     final int floatsPerVertex = 5; // 3 spatial + 2 texture float[] meshData = new float[numVerticies * floatsPerVertex]; for (int i = 0; i < numVerticies; i++) { meshData[(i * floatsPerVertex) + 0] = ... ; // x coordinate of i'th vertex meshData[(i * floatsPerVertex) + 1] = ... ; // y coordinate of i'th vertex meshData[(i * floatsPerVertex) + 2] = ... ; // z coordinate of i'th vertex meshData[(i * floatsPerVertex) + 3] = ... ; // u texture coordinate of i'th vertex meshData[(i * floatsPerVertex) + 4] = ... ; // v texture coordinate of i'th vertex } myMesh.setVertices(meshData); 

    Puede calcular el u y v correctos para un TextureRegion específico utilizando los getU , getV , getU2 y getV2 . Tenga en cuenta que las coordenadas de textura tienen el origen (u1, v1) en la parte superior izquierda y los puntos del eje y "abajo" (la pantalla y las coordenadas espaciales en OpenGL suelen tener el origen en la parte inferior izquierda y los puntos del eje y " arriba"). Es un poco complicado, pero muy flexible en que se puede voltear o estirar o distorsionar la textura, ya que los mapas en su malla.

    Dado que la textura es grande (digamos 512×512) y la región específica es un pequeño subconjunto de eso (digamos 20×20 a 128×128), en realidad terminará dando sus coordenadas de textura de malla que utilizan sólo el subconjunto de 20×20 de toda la imagen 512×512.

    Render la malla texturizada

    Por último, cuando se renderiza es necesario vincular la imagen y habilitar la texturización antes de renderizarla:

     region.getTexture().bind(); Gdx.graphics.getGL10().glEnable(GL10.GL_TEXTURE_2D); myMesh.render(); Gdx.graphics.getGL10().glDisable(GL10.GL_TEXTURE_2D); 

    Tenga en cuenta que esto es mucho menos eficiente de lo que debería ser. Parte del beneficio de un atlas de textura es que debe contener un montón de regiones que se pueden renderizar juntos, por lo que sólo es necesario para enlazar una textura, y luego hacer un montón de diferentes texturas mallas de esa textura unidos.

    SpriteBatch soporta sprites definidos con un TextureRegion y AssetManager soporta cargar y encontrar un TextureAtlas como un elemento de primera clase.

    Tengo que trabajar con la explicación anterior.

    No puedo creer que tan pocas personas están corriendo haciendo esta pregunta, ya que parece algo que otros querrían hacer.

    De la solución aceptada he creado una función que también hace las matemáticas para la nueva posición UV.

    Probado, y funciona para mí, pero por favor revise como no soy un desarrollador de Java.

     public Mesh RebuildMeshUVtoTextureRegion(Mesh ObjectMesh, TextureRegion UVMapPos) { int numFloats = ObjectMesh.getNumVertices() * ObjectMesh.getVertexSize() / 4; float[] vertices = new float[numFloats]; ObjectMesh.getVertices(vertices); int numIndices = ObjectMesh.getNumIndices(); short SourceIndices[] = new short[numIndices]; ObjectMesh.getIndices(SourceIndices); final int floatsPerVertex = 5; int TimesToLoop = ((vertices.length) /floatsPerVertex); float previousU; float previousV; float FullMapHeight = UVMapPos.getTexture().getHeight(); float FullMapWidth = UVMapPos.getTexture().getWidth(); float NewMapWidth = UVMapPos.getRegionWidth(); float NewMapHeight = UVMapPos.getRegionHeight(); float FullMapUPercent; float FullMapVPercent; for (int i = 0; i < TimesToLoop; i++) { previousU = (vertices[(i * floatsPerVertex) + 3]); previousV = (vertices[(i * floatsPerVertex) + 4]); FullMapUPercent = previousU / FullMapWidth; FullMapVPercent = previousV / FullMapHeight; vertices[(i * floatsPerVertex) + 3] = (NewMapWidth * FullMapUPercent) + UVMapPos.getU(); //New U vertices[(i * floatsPerVertex) + 4] = (NewMapHeight * FullMapVPercent) + UVMapPos.getV();//New V } ObjectMesh.setVertices(vertices); ObjectMesh.setIndices(SourceIndices); return ObjectMesh; } 
    FlipAndroid es un fan de Google para Android, Todo sobre Android Phones, Android Wear, Android Dev y Aplicaciones para Android Aplicaciones.