import com.esotericsoftware.spine.SkeletonRenderer; //导入依赖的package包/类
public SkeletonActorPool (SkeletonRenderer renderer, SkeletonData skeletonData, AnimationStateData stateData,
	int initialCapacity, int max) {
	super(initialCapacity, max);

	this.renderer = renderer;
	this.skeletonData = skeletonData;
	this.stateData = stateData;

	obtained = new Array(false, initialCapacity);

	skeletonPool = new Pool<Skeleton>(initialCapacity, max) {
		protected Skeleton newObject () {
			return new Skeleton(SkeletonActorPool.this.skeletonData);
		}

		protected void reset (Skeleton skeleton) {
			skeleton.setColor(Color.WHITE);
			skeleton.setFlip(false, false);
			skeleton.setSkin((Skin)null);
			skeleton.setSkin(SkeletonActorPool.this.skeletonData.getDefaultSkin());
			skeleton.setToSetupPose();
		}
	};

	statePool = new Pool<AnimationState>(initialCapacity, max) {
		protected AnimationState newObject () {
			return new AnimationState(SkeletonActorPool.this.stateData);
		}

		protected void reset (AnimationState state) {
			state.clearTracks();
			state.clearListeners();
		}
	};
}
 

import com.esotericsoftware.spine.SkeletonRenderer; //导入依赖的package包/类
public RenderingSystem() {
	super();
	
	this.sortedEntities = new Array<Entity>(100);
	this.batch = new SpriteBatch();
	this.camera = Env.game.getCamera();
	this.viewport = Env.game.getViewport();
	this.uiCamera = Env.game.getUICamera();
	this.uiViewport = Env.game.getUIViewport();
	this.sorter = new DepthSorter();
	this.shapeRenderer = new ShapeRenderer();
	this.box2DRenderer = new Box2DDebugRenderer(Env.drawBodies,
												Env.drawJoints,
												Env.drawABBs,
												Env.drawInactiveBodies,
												Env.drawVelocities,
												Env.drawContacts);
	
	this.particleFrameBuffer = new FrameBuffer(Pixmap.Format.RGBA8888, Gdx.graphics.getWidth(), Gdx.graphics.getHeight(), false);
	this.particleRegion = new TextureRegion(particleFrameBuffer.getColorBufferTexture());
	this.particleRegion.flip(false, true);
	
	this.skeletonRenderer = new SkeletonRenderer();
	
	if (Env.debug) {
		debugFont = Env.game.getAssets().get("data/ui/default.fnt", BitmapFont.class);
	}
}
 

import com.esotericsoftware.spine.SkeletonRenderer; //导入依赖的package包/类
@Override
public void retrieveAssets() {
	renderer = new SkeletonRenderer();
	renderer.setPremultipliedAlpha(false);
	bounds = new SkeletonBounds();

	for (String key : sourceCache.keySet()) {
		if (sourceCache.get(key).refCounter > 0)
			retrieveSource(key, ((SkeletonCacheEntry) sourceCache.get(key)).atlas);
	}

	if (currentAnimation != null) {
		SkeletonCacheEntry entry = (SkeletonCacheEntry) sourceCache.get(currentAnimation.source);
		currentSource = entry;

		// Stop events to avoid event trigger
		boolean prevEnableEvents = eventsEnabled;

		eventsEnabled = false;
		setCurrentAnimation();
		eventsEnabled = prevEnableEvents;

	} else if (initAnimation != null) {
		startAnimation(initAnimation, Tween.Type.SPRITE_DEFINED, 1, null);
	}

	setSkin(skin);
	computeBbox();
}
 

import com.esotericsoftware.spine.SkeletonRenderer; //导入依赖的package包/类
@Override
protected void initialize () {
	batch = renderBatchingSystem.getBatch();
	if (batch instanceof PolygonSpriteBatch) {
		skeletonRenderer = new SkeletonMeshRenderer();
	} else {
		skeletonRenderer = new SkeletonRenderer();
	}
}
 

import com.esotericsoftware.spine.SkeletonRenderer; //导入依赖的package包/类
public RenderSystem(SpriteBatch batch){
    super(Families.RENDERABLE);
    this.batch = batch;
    renderer = new SkeletonRenderer<>();
    renderer.setPremultipliedAlpha(true);
}
 

import com.esotericsoftware.spine.SkeletonRenderer; //导入依赖的package包/类
public SkeletonActor (SkeletonRenderer renderer, Skeleton skeleton, AnimationState state) {
	this.renderer = renderer;
	this.skeleton = skeleton;
	this.state = state;
}
 

import com.esotericsoftware.spine.SkeletonRenderer; //导入依赖的package包/类
public SkeletonRenderer getRenderer () {
	return renderer;
}
 

import com.esotericsoftware.spine.SkeletonRenderer; //导入依赖的package包/类
public void setRenderer (SkeletonRenderer renderer) {
	this.renderer = renderer;
}
 

import com.esotericsoftware.spine.SkeletonRenderer; //导入依赖的package包/类
public RenderingSystem(Viewport viewport,
					   Rectangle cameraFocusRect,
					   Vector2 cameraTarget,
					   Stage stage,
					   World world,
					   RayHandler rayHandler) {
	super(Family.all(RootComponent.class, NodeComponent.class).get());
	
	logger.info("initialize");
	
	this.viewport = viewport;
	this.cameraFocusRect = cameraFocusRect;
	this.cameraTarget = cameraTarget;
	this.stage = stage;
	this.world = world;
	this.rayHandler = rayHandler;
	
	//batch = new SpriteBatch();
	batch = new PolygonSpriteBatch();
	
	shapeRenderer = new ShapeRenderer();
	
	boolean drawBodies = true;
	boolean drawJoints = true;
	boolean drawABBs = true;
	boolean drawInactiveBodies = true;
	boolean drawVelocities = true;
	boolean drawContacts = true;
	box2DRenderer = new Box2DDebugRenderer(
		drawBodies,
		drawJoints,
		drawABBs,
		drawInactiveBodies,
		drawVelocities,
		drawContacts
	);
	
	spineRenderer = new SkeletonRenderer();
	spineDebugRenderer = new SkeletonRendererDebug();
	
	renderable = Family.all(
		NodeComponent.class,
		TransformComponent.class,
		SizeComponent.class
	).one(
		TextureComponent.class,
		ParticleComponent.class,
		SpineComponent.class
	).get();

}