Absolutely feasible! You don’t need Sprite or SpriteBatch to get a standalone Texture from your atlas region—you just need to extract the pixel data of the region and create a new Texture from it. Here’s a step-by-step breakdown tailored for your 3D use case:

Step 1: Extract the Region’s Pixel Data into a Pixmap #

First, you’ll need to copy the portion of the original atlas texture corresponding to your "box" region into a Pixmap. This acts as an in-memory buffer for the pixel data:

val textureAtlas = TextureAtlas("atlas.atlas")
val boxRegion = textureAtlas.findRegion("box")

// Prepare the original texture's pixel data for access
val originalTextureData = boxRegion.texture.textureData
if (!originalTextureData.isPrepared) {
    originalTextureData.prepare()
}

// Create a Pixmap sized to match your region
val regionPixmap = Pixmap(boxRegion.regionWidth, boxRegion.regionHeight, Pixmap.Format.RGBA8888)
regionPixmap.setBlending(Pixmap.Blending.None) // Avoid color artifacts during copy

// Copy the region's pixels from the original texture to the new Pixmap
regionPixmap.drawPixmap(
    originalTextureData.consumePixmap(),
    0, 0, // Top-left corner of the new Pixmap
    boxRegion.regionX, boxRegion.regionY, // Top-left corner of the region in the atlas
    boxRegion.regionWidth, boxRegion.regionHeight // Size of the region
)

Step 2: Create the Standalone Texture #

Once you have the Pixmap with your region’s pixels, you can create a new Texture directly from it:

val boxTexture = Texture(regionPixmap)
// Clean up the Pixmap—we don't need it anymore after creating the Texture
regionPixmap.dispose()

Key Notes for 3D Scenarios #

• GPU Memory Consideration: Each new Texture will consume additional GPU memory. If you’re extracting many regions, this could add up—keep an eye on your app’s memory usage.
• Mipmapping: By default, the new texture won’t have mipmaps (which are useful for smooth 3D rendering at different distances). Enable them with:

  boxTexture.generateMipMap()
  boxTexture.setFilter(Texture.TextureFilter.MipMapLinearNearest, Texture.TextureFilter.Linear)
  

• Resource Management: Don’t forget to dispose() boxTexture when you’re done with it (e.g., in your screen’s dispose() method) to prevent memory leaks.

Alternative: Use UV Coordinates with the Original Atlas Texture (More Efficient) #

If you’re open to avoiding a new Texture entirely (which is more performance-friendly), you can use the original atlas texture in your 3D material and adjust the UV coordinates of your 3D model to only sample the "box" region. Calculate the normalized UVs like this:

val originalTextureWidth = boxRegion.texture.width.toFloat()
val originalTextureHeight = boxRegion.texture.height.toFloat()

// Normalized UV coordinates (0-1 range) for the box region
val uMin = boxRegion.regionX / originalTextureWidth
val vMin = boxRegion.regionY / originalTextureHeight
val uMax = (boxRegion.regionX + boxRegion.regionWidth) / originalTextureWidth
val vMax = (boxRegion.regionY + boxRegion.regionHeight) / originalTextureHeight

You can then pass these UV values to your 3D model’s material or shader to sample only the desired region of the atlas texture. This avoids the overhead of copying pixels and creating a new Texture.

内容的提问来源于stack exchange，提问作者lacas