Java 使用缩放进行引擎背景缩放

我有一个游戏场景，其中我使用了ZoomCamera、一个背景和一些“病毒”。 问题是，当我放大或缩小背景时，也会缩放，我不希望这样，请帮助

公共类GameSecene扩展BaseSecene实现IScrollDetectorListener、IPinchZoomDetectorListener、IOnSceneTouchListener{
私有静态最终字符串标记_ENTITY=“ENTITY”；
私有静态最终字符串标记\u实体\u属性\u X=“X”；
私有静态最终字符串标记\u实体\u属性\u Y=“Y”；
私有静态最终字符串标记\u实体\u属性\u TYPE=“TYPE”；
私有ZoomCamera mZoomCamera=GameActivity.mZoomCamera；
私有静态最终对象标记\实体\属性\类型\值\单元格=“单元格”；
//私有静态最终对象标记\实体\属性\类型\值\平台1=“平台1”；
//私有静态最终对象标记\实体\属性\类型\值\平台2=“平台2”；
//私有静态最终对象标记\实体\属性\类型\值\平台3=“平台3”；
//私有静态最终对象标记\实体\属性\类型\值\硬币=“硬币”；
专用表面滚动检测器；
私有PinchZoomDetector mPinchZoomDetector；
私有浮动mPinchZoomStartedCameraZoomFactor；
@凌驾
公共场景（）{
this.mScrollDetector=新表面滚动检测器（this）；
this.mPinchZoomDetector=新PinchZoomDetector（this）；
this.setOnSceneTouchListener（this）；
此.setTouchAreaBindingOnActionDownEnabled（true）；
这个.setonareatouchtraversalfrontoback（）；
createBackground（）；
createHUD（）；
创建物理（）；
负荷水平（1）；
}
@凌驾
public void onBackKeyPressed（）{
SceneManager.getInstance（）.loadMenuScene（引擎）；
}
私有void createBackground（）
{Sprite bg=新的Sprite（400240，resourcesManager.menu_background_region，vbom）；
阿塔奇尔德（bg）；
/*attachChild（新精灵（400240，resourcesManager.menu\u background\u region，vbom）
{
@凌驾
受保护的空白预绘制（GLState pGLState、摄像头pCamera）
{
超级预拉伸（pGLState，pCamera）；
pGLState.enableDither（）；
}
});*/
}
@凌驾
公共SceneType getSceneType（）{
//TODO自动生成的方法存根
返回null；
}
@凌驾
公共无效处置（）
{
摄像头。setHUD（空）；
摄像机。设置中心（400240）；
mZoomCamera.setZoomFactor（1.0f）；
//负责处理场景的TODO代码
//移除所有游戏场景对象。
}
私人抬头显示器；
私人文本；
私有void createHUD（）
{
gameHUD=新HUD（）；
//创建分数文本
scoreText=新文本（20220，resourcesManager.font，“分数：0123456789”，新文本选项（horizontallign.LEFT），vbom）；
scoreText.setAnchorCenter（0,0）；
scoreText.setText（“分数：0”）；
gameHUD.attachChild（scoreText）；
摄像机。setHUD（gameHUD）；
}
私人智力得分=0；
私有void addToScore（int i）
{
分数+=i；
scoreText.setText（“分数：+Score”）；
}
私人物理世界物理世界；
私人物理学（）
{
physicsWorld=新固定步骤physicsWorld（60，新向量2（0，-17），false）；
registerUpdateHandler（physicsWorld）；
}
私有void加载级别（int-levelID）
{
最终SimpleLevel Loader levelLoader=新SimpleLevel Loader（vbom）；
final FixtureDef FIXTURE_DEF=PhysicsFactory.createFixtureDef（0,0.01f,0.5f）；
levelLoader.registerEntityLoader（新EntityLoader（LevelConstants.TAG_级别）
{
public Entity onLoadEntity（最终字符串pEntityName、最终Entity pParent、最终属性pAttributes、最终SimpleLevel EntityLoaderData PSImpleLevel EntityLoaderData）引发IOException
{
getIntAttributeOrThrow（pAttributes，LevelConstants.TAG\u LEVEL\u ATTRIBUTE\u WIDTH）；
getIntAttributeOrThrow（pAttributes，LevelConstants.TAG\u LEVEL\u ATTRIBUTE\u HEIGHT）；
//待办事项稍后，我们将指定摄影机边界并创建不可见墙
//在关卡的开头和结尾。
返回游戏场景。这个；
}
});
levelLoader.registerEntityLoader（新实体加载器（标记实体）
{
public Entity onLoadEntity（最终字符串pEntityName、最终Entity pParent、最终属性pAttributes、最终SimpleLevel EntityLoaderData PSImpleLevel EntityLoaderData）引发IOException
{
final int x=SAXUtils.getIntAttributeOrThrow（pAttributes，TAG_ENTITY_ATTRIBUTE_x）；
final int y=SAXUtils.getIntAttributeOrThrow（pAttributes，TAG\u ENTITY\u ATTRIBUTE\u y）；
最终字符串类型=SAXUtils.getAttributeOrThrow（pAttributes，标记\实体\属性\类型）；
最终的精灵对象；
/*if（type.equals（标记\实体\属性\类型\值\平台1））
{
levelObject=新精灵（x，y，resourcesManager.platform1_区域，vbom）；
createBoxBody（physicsWorld、levelObject、BodyType.StaticBody、FIXTURE_DEF）.setUserData（“平台1”）；
} 
else if（type.equals（标记\实体\属性\类型\值\平台2））
{
levelObject=新精灵（x，y，resourcesManager.platform2_区域，vbom）；
最终主体=PhysicsFactory.createBoxBody（physicsWorld、levelObject、BodyType.StaticBody、FIXTURE_DEF）；
正文.setUserData（“平台2”）；
注册物理连接器（新的物理连接器（levelObject，body，true，false））；
}
else if（type.equals（标记\实体\属性\类型\值\平台3））
{
levelObject=新精灵（x，y，resourcesManager.platform3_区域，vbom）；
最终主体=PhysicsFactory.createBoxBody（physicsWorld、levelObject、BodyType.StaticBody、FIXTURE_DEF）；
body.setUserData（“平台3”）；
注册物理连接器（新的物理连接器（levelObject，body，true，false））；
}
else*/if（type.equals）（标记\实体\属性\类型\值\单元格
public class GameScene extends BaseScene implements IScrollDetectorListener, IPinchZoomDetectorListener, IOnSceneTouchListener  {
private static final String TAG_ENTITY = "entity";
private static final String TAG_ENTITY_ATTRIBUTE_X = "x";
private static final String TAG_ENTITY_ATTRIBUTE_Y = "y";
private static final String TAG_ENTITY_ATTRIBUTE_TYPE = "type";
private ZoomCamera mZoomCamera = GameActivity.mZoomCamera;
private static final Object TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_CELL = "cell";
//private static final Object TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_PLATFORM1 = "platform1";
//private static final Object TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_PLATFORM2 = "platform2";
//private static final Object TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_PLATFORM3 = "platform3";
//private static final Object TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_COIN = "coin";
private SurfaceScrollDetector mScrollDetector;
private PinchZoomDetector mPinchZoomDetector;
private float mPinchZoomStartedCameraZoomFactor;
@Override
public void createScene() {
    this.mScrollDetector = new SurfaceScrollDetector(this);
    this.mPinchZoomDetector = new PinchZoomDetector(this);
    this.setOnSceneTouchListener(this);
    this.setTouchAreaBindingOnActionDownEnabled(true);
    this.setOnAreaTouchTraversalFrontToBack();
    createBackground();
    createHUD();
    createPhysics();
    loadLevel(1);
}

@Override
public void onBackKeyPressed() {
    SceneManager.getInstance().loadMenuScene(engine);

}
private void createBackground()
{   Sprite bg=new Sprite(400, 240, resourcesManager.menu_background_region, vbom);
    attachChild(bg);
    /*attachChild(new Sprite(400, 240, resourcesManager.menu_background_region, vbom)
    {
        @Override
        protected void preDraw(GLState pGLState, Camera pCamera) 
        {
            super.preDraw(pGLState, pCamera);
            pGLState.enableDither();
        }
    });*/
}

@Override
public SceneType getSceneType() {
    // TODO Auto-generated method stub
    return null;
}

@Override
public void disposeScene()
{
    camera.setHUD(null);
    camera.setCenter(400, 240);
    mZoomCamera.setZoomFactor(1.0f);
    // TODO code responsible for disposing scene
    // removing all game scene objects.
}
private HUD gameHUD;

private Text scoreText;

private void createHUD()
{
    gameHUD = new HUD();

    // CREATE SCORE TEXT
    scoreText = new Text(20, 420, resourcesManager.font, "Score: 0123456789", new TextOptions(HorizontalAlign.LEFT), vbom);
    scoreText.setAnchorCenter(0, 0);    
    scoreText.setText("Score: 0");
    gameHUD.attachChild(scoreText);

    camera.setHUD(gameHUD);
}
private int score = 0;

private void addToScore(int i)
{
    score += i;
    scoreText.setText("Score: " + score);
}

private PhysicsWorld physicsWorld;

private void createPhysics()
{
    physicsWorld = new FixedStepPhysicsWorld(60, new Vector2(0, -17), false); 
    registerUpdateHandler(physicsWorld);
}

private void loadLevel(int levelID)
{
    final SimpleLevelLoader levelLoader = new SimpleLevelLoader(vbom);

    final FixtureDef FIXTURE_DEF = PhysicsFactory.createFixtureDef(0, 0.01f, 0.5f);

    levelLoader.registerEntityLoader(new EntityLoader<SimpleLevelEntityLoaderData>(LevelConstants.TAG_LEVEL)
    {
        public IEntity onLoadEntity(final String pEntityName, final IEntity pParent, final Attributes pAttributes, final SimpleLevelEntityLoaderData pSimpleLevelEntityLoaderData) throws IOException 
        {
            SAXUtils.getIntAttributeOrThrow(pAttributes, LevelConstants.TAG_LEVEL_ATTRIBUTE_WIDTH);
            SAXUtils.getIntAttributeOrThrow(pAttributes, LevelConstants.TAG_LEVEL_ATTRIBUTE_HEIGHT);

            // TODO later we will specify camera BOUNDS and create invisible walls
            // on the beginning and on the end of the level.

            return GameScene.this;
        }
    });

    levelLoader.registerEntityLoader(new EntityLoader<SimpleLevelEntityLoaderData>(TAG_ENTITY)
    {
        public IEntity onLoadEntity(final String pEntityName, final IEntity pParent, final Attributes pAttributes, final SimpleLevelEntityLoaderData pSimpleLevelEntityLoaderData) throws IOException
        {
            final int x = SAXUtils.getIntAttributeOrThrow(pAttributes, TAG_ENTITY_ATTRIBUTE_X);
            final int y = SAXUtils.getIntAttributeOrThrow(pAttributes, TAG_ENTITY_ATTRIBUTE_Y);
            final String type = SAXUtils.getAttributeOrThrow(pAttributes, TAG_ENTITY_ATTRIBUTE_TYPE);

            final Sprite levelObject;

           /* if (type.equals(TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_PLATFORM1))
            {
                levelObject = new Sprite(x, y, resourcesManager.platform1_region, vbom);
                PhysicsFactory.createBoxBody(physicsWorld, levelObject, BodyType.StaticBody, FIXTURE_DEF).setUserData("platform1");
            } 
            else if (type.equals(TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_PLATFORM2))
            {
                levelObject = new Sprite(x, y, resourcesManager.platform2_region, vbom);
                final Body body = PhysicsFactory.createBoxBody(physicsWorld, levelObject, BodyType.StaticBody, FIXTURE_DEF);
                body.setUserData("platform2");
                physicsWorld.registerPhysicsConnector(new PhysicsConnector(levelObject, body, true, false));
            }
            else if (type.equals(TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_PLATFORM3))
            {
                levelObject = new Sprite(x, y, resourcesManager.platform3_region, vbom);
                final Body body = PhysicsFactory.createBoxBody(physicsWorld, levelObject, BodyType.StaticBody, FIXTURE_DEF);
                body.setUserData("platform3");
                physicsWorld.registerPhysicsConnector(new PhysicsConnector(levelObject, body, true, false));
            }
            else*/ if (type.equals(TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_CELL))
            {
                levelObject = new Sprite(x, y, resourcesManager.cell_region, vbom);
                final Body body = PhysicsFactory.createBoxBody(physicsWorld, levelObject, BodyType.StaticBody, FIXTURE_DEF);
                body.setUserData("cell");
                physicsWorld.registerPhysicsConnector(new PhysicsConnector(levelObject, body, true, false));
            }
            /*else if (type.equals(TAG_ENTITY_ATTRIBUTE_TYPE_VALUE_COIN))
            {
                levelObject = new Sprite(x, y, resourcesManager.coin_region, vbom)
                {
                    @Override
                    protected void onManagedUpdate(float pSecondsElapsed) 
                    {
                        super.onManagedUpdate(pSecondsElapsed);

                        /** 
                         * TODO
                         * we will later check if player collide with this (coin)
                         * and if it does, we will increase score and hide coin
                         * it will be completed in next articles (after creating player code)

                    }
                };
                levelObject.registerEntityModifier(new LoopEntityModifier(new ScaleModifier(1, 1, 1.3f)));
            } */           
            else
            {
                throw new IllegalArgumentException();
            }

            levelObject.setCullingEnabled(true);

            return levelObject;
        }
    });

    levelLoader.loadLevelFromAsset(activity.getAssets(), "level/" + levelID + ".lvl");
}

@Override
public boolean onSceneTouchEvent(Scene pScene, TouchEvent pSceneTouchEvent) {
    this.mPinchZoomDetector.onTouchEvent(pSceneTouchEvent);

    if(this.mPinchZoomDetector.isZooming()) {
        this.mScrollDetector.setEnabled(false);
    } else {
        if(pSceneTouchEvent.isActionDown()) {
            this.mScrollDetector.setEnabled(true);
        }
        this.mScrollDetector.onTouchEvent(pSceneTouchEvent);
    }

    return true;
}

@Override
public void onPinchZoomStarted(PinchZoomDetector pPinchZoomDetector,
        TouchEvent pSceneTouchEvent) {
    this.mPinchZoomStartedCameraZoomFactor = this.mZoomCamera.getZoomFactor();

}

@Override
public void onPinchZoom(PinchZoomDetector pPinchZoomDetector,
        TouchEvent pTouchEvent, float pZoomFactor) {
    this.mZoomCamera.setZoomFactor(this.mPinchZoomStartedCameraZoomFactor * pZoomFactor);

}

@Override
public void onPinchZoomFinished(PinchZoomDetector pPinchZoomDetector,
        TouchEvent pTouchEvent, float pZoomFactor) {
    this.mZoomCamera.setZoomFactor(this.mPinchZoomStartedCameraZoomFactor * pZoomFactor);

}

@Override
public void onScrollStarted(ScrollDetector pScollDetector, int pPointerID,
        float pDistanceX, float pDistanceY) {
    final float zoomFactor = mZoomCamera.getZoomFactor();
    mZoomCamera.offsetCenter(-pDistanceX / zoomFactor, pDistanceY / zoomFactor);

}

@Override
public void onScroll(ScrollDetector pScollDetector, int pPointerID,
        float pDistanceX, float pDistanceY) {
    final float zoomFactor = mZoomCamera.getZoomFactor();
    mZoomCamera.offsetCenter(-pDistanceX / zoomFactor, pDistanceY / zoomFactor);

}

@Override
public void onScrollFinished(ScrollDetector pScollDetector, int pPointerID,
        float pDistanceX, float pDistanceY) {
    final float zoomFactor = mZoomCamera.getZoomFactor();
    mZoomCamera.offsetCenter(-pDistanceX / zoomFactor, pDistanceY / zoomFactor);

}

setBackground(new SpriteBackground(bg));