Good idea. I took the texture atlas that i used for spine animation and it is drawn correctly. Notice after the loop I draw the atlas.

Here is the FBO rendered image that i saved on disk. On the left is the image is textureatlas drawn by batch.draw(tex.getTextures().first(), 350, 500); , right is drawn by skeletonRenderer.draw(batch, skeleton);

Still I cannot understand why is this happening. Seems there is some scaling.

Изображение удалено из-за отсутствия поддержки HTTPS. | Показать

      

YieldingFrameBuffer fbo = new YieldingFrameBuffer(Pixmap.Format.RGBA8888, FBOwidthConst, FBOheightConst, false);

  fbo.begin();
  skeletonRenderer.setPremultipliedAlpha(true);
  batch.getProjectionMatrix().setToOrtho2D(0, 0, fbo.getWidth(), fbo.getHeight());

  batch.begin();

  Gdx.gl.glEnable(GL20.GL_BLEND);
  batch.setBlendFunction(GL20.GL_ONE, GL20.GL_ONE_MINUS_SRC_ALPHA);
  Gdx.gl20.glViewport(0, 0, fbo.getWidth(), fbo.getHeight());
  Gdx.gl20.glClearColor(0f, 0f, 0f, 0f);
  Gdx.gl20.glClear(GL20.GL_COLOR_BUFFER_BIT);
  Gdx.gl20.glEnable(GL20.GL_TEXTURE_2D);

  skeletonRenderer = new SkeletonRenderer<Batch>();
  skeletonRenderer.setPremultipliedAlpha(true);

  int fitInRow = fbo.getWidth() / widthConst;

  int currIdx = 0;
  for (int j = 0; j < charactersNeeded.length; j++)
  {
     IntMap<TextureSkeletonHolder> map = _dictOfTextureAtlas.get(charactersNeeded[j]);

     IntArray arr = map.keys().toArray();
     arr.sort();

     for (int idx : arr.items)
     {
        TextureSkeletonHolder holder = map.get(idx);
        //holder.TextureAtlas.getTextures().first().setFilter(TextureFilter.Nearest, (TextureFilter.Nearest));
        Skeleton skeleton = new Skeleton(holder.SkeletonData);
        AnimationStateData animationState = new AnimationStateData(holder.SkeletonData);
        AnimationState animstat = new AnimationState(animationState);
        int currentIndex = currIdx++;

        int multipyBy = currentIndex / fitInRow;

        int y = multipyBy * heightConst;

        y = (heightConst) + y;

        int x = currentIndex * widthConst - (multipyBy * fitInRow * widthConst);

        skeleton.setPosition(x, y);
        skeleton.setFlipY(true);

        animstat.apply(skeleton);
        skeleton.updateWorldTransform();

        skeleton.setToSetupPose();

        skeletonRenderer.draw(batch, skeleton);

        skeleton.setFlipY(false);

     }

  }

 IntMap<TextureSkeletonHolder> map2 = _dictOfTextureAtlas.get(charactersNeeded[2]);

  TextureAtlas tex = map2.get(1).TextureAtlas;

  batch.draw(tex.getTextures().first(), 350, 500); 

  batch.end();

I don't think is gone. I suppose that this 2 renderings (plain textureatlas, spinerednerer) should be same, but in fact they are not.

If I don't put filtering, texture is blurry (my second post)
If I put nearest,nearest, the texture is stretched (first post). <- This one looks more similar to original.

What I do is:
1) Render the FBO (spine and atlas texture)
2) Save the rendered into a PNG locally

There I see that the atlas texture is not equal like the texture rendered from SpineRenderer. So I think the problem somewhere during the FBO rendering.

When I render the SpineRenderer on screen buffer, everything seems fine (like the atlas texture).

I really have difficulties understanding why is this happening.

One more thing, when exporting in texture packer, I set 0.333, and then i scale in game like this:

               SkeletonJson json = new SkeletonJson(atlas);
json.setScale(sizing);

Just to check, if the sizing is same value, this should not change the size of textures, right?

Maybe you didn't understand me.

1) I render both texture of spine and the spine animation in same FBO.
2) For debug purposes i export the FBO into png
3) PNG is same as its rendered on screen

Problem:
The rendered spine animation is blurry if compared with the texture rendered.
If i set nearest, nearest in the texture, spine animation rendered is stretched.

If i set the alpha to 1, the background is black, but the problem is still there. The image rendered with spine rendered is blurry.

OK, I have created a small project containing the example to show the behavior. Since I'm using private assets, is it possible to send it on email?

To replicate the problem I'm having:
With the code you provided me, I put the FBO in constructor, and during rendering (after rendering the FBO) zoomed the camera.

import com.badlogic.gdx.ApplicationAdapter;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Input;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.graphics.Pixmap; 
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.graphics.g2d.TextureAtlas;
import com.badlogic.gdx.graphics.g2d.TextureRegion;
import com.badlogic.gdx.graphics.glutils.FrameBuffer;
import com.esotericsoftware.spine.*;

public class SpineFBOTest extends ApplicationAdapter
{
   OrthographicCamera camera;
   SpriteBatch batch;
   SkeletonRenderer renderer;

   TextureAtlas atlas;
   Skeleton skeleton;

   FrameBuffer fbo;
   TextureRegion fboRegion;
   boolean useFbo = false;

   @Override
   public void create()
   {
      camera = new OrthographicCamera();
      batch = new SpriteBatch();
      renderer = new SkeletonRenderer();
      renderer.setPremultipliedAlpha(true);

  atlas = new TextureAtlas(Gdx.files.internal("annimation/Farmer1/Farmer1.atlas"));
         
  SkeletonJson json = new SkeletonJson(atlas);
  json.setScale(0.33f);
  SkeletonData skeletonData = json.readSkeletonData(Gdx.files.internal("annimation/Farmer1/Farmer12.json"));

  skeleton = new Skeleton(skeletonData);
  skeleton.setPosition(250, 20);

  fbo = new FrameBuffer(Pixmap.Format.RGBA8888, 512, 512, false);
  fboRegion = new TextureRegion(fbo.getColorBufferTexture());  
  fboRegion.flip(false, true);

  skeleton.updateWorldTransform();
  fbo.begin();
  Gdx.gl.glClearColor(0, 0, 0, 0);
  Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
  camera.setToOrtho(false, fbo.getWidth(), fbo.getHeight());
  camera.update();
  batch.getProjectionMatrix().set(camera.combined);
  batch.begin();
  renderer.draw(batch, skeleton);
  batch.end();
  fbo.end();

   }

   @Override
   public void render()
   {
      Gdx.gl.glClearColor(1, 1, 1, 1);
      Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

  camera.zoom = 0.5f; 

  skeleton.updateWorldTransform();

  if (!useFbo)
  {
     camera.setToOrtho(false);
     camera.update();
     batch.getProjectionMatrix().set(camera.combined);
     batch.begin();
     renderer.draw(batch, skeleton);
     batch.end();
  } else
  {
     // Render skeleton to FBO
     // Render FBO color buffer texture to screen      
     camera.setToOrtho(false);
     camera.update();
     batch.getProjectionMatrix().set(camera.combined);
     batch.begin();
     batch.draw(fboRegion, 0, 0);
     batch.end();
  }

  if (Gdx.input.isKeyJustPressed(Input.Keys.SPACE))
  {
     useFbo = !useFbo;
     Gdx.app.log("SpineFBOTest", "Using FBO: " + useFbo);
  }

   }

   @Override
   public void resize(int width, int height)
   {
      camera.setToOrtho(false);
   }
}