gdx-studio

package scene2d;

import com.badlogic.gdx.Gdx;

import com.badlogic.gdx.graphics.OrthographicCamera;

import com.badlogic.gdx.math.Interpolation;

import com.badlogic.gdx.math.Vector3;

import com.badlogic.gdx.scenes.scene2d.Actor;

import com.badlogic.gdx.utils.Array;

import com.badlogic.gdx.math.Rectangle;

public class Camera extends OrthographicCamera {

	private static Camera instance;

	private static float duration;

	private static float time;

	private static Interpolation interpolation;

	private static boolean moveCompleted;

	private static float lastPercent;

	private static float percentDelta;

	private static float panSpeedX, panSpeedY;

	private static final Array<Actor> hudActors = new Array<Actor>();

	private static Actor followedActor = null;

	private static float followSpeed = 1f;

	/*

	 *  This is to set the offsets of camera position when following the actor

	 *  When the camera follows the actor its (x,y) position is set to actor's (x,y) position

	 *  based on followSpeed. The offsets are used to position the camera in such a way that the actor

	 *  doesn't need to be at the center of the camera always

	 */

	public static Rectangle followOffset = new Rectangle(10,70,10,60);

	private static boolean followContinous = false;

	public static boolean usePan = false;

    public static boolean useDrag = false;

	/*

	 * Sets the speed at which the camera pans. By default it moves 1px for a duration a 1f

	 * so its speed is 1px/f. So reduce the duration to increase its speed.

	 * ex: setPanSpeed(0.5) will change its speed to 2px/f

	 * Here: f can/maybe also indicate seconds 

	 */

	public static float panSpeed = 5f;

	public static Rectangle panSize;

	/*

	 *  This sets the boundary of the camera till what position can it move or pan in the

	 *  directions left, right, top, down. This is to prevent is from panning overboard the game area.

	 *  Usually the bounds of the camera is like a rectangle. This must be calculated carefully

	 *  as the camera's position is based on its center.

	*/

	public static Rectangle bounds = new Rectangle(0,0,999,999);

	Camera(){

		setToOrtho(false, Scene.targetWidth, Scene.targetHeight);

		position.set(Scene.targetWidth/2, Scene.targetHeight/2, 0);

		instance = this;

		panSize = new Rectangle(10, 10, Scene.targetWidth-10, Scene.targetHeight - 10);

	}

	/*

	 * Moves the camera to x,y over a time duration

	 */

	public void moveTo(float x, float y, float duration) {

		moveBy(x-position.x, y-position.y, duration);

	}

	/*

	 * Moves the camera by amountX, amountY over a time duration

	 */

	public static void moveBy (float amountX, float amountY, float duration) {

		moveBy(amountX, amountY, duration, null);

	}

	/*

	 * Moves the camera by amountX, amountY over a time duration and interpolation interp

	 */

	public static void moveBy (float amountX, float amountY, float dur, Interpolation interp) {

		duration = dur;

		interpolation = interp;

		panSpeedX = amountX;

		panSpeedY = amountY;

		lastPercent = 0;

		time = 0;

		moveCompleted = false;

	}

	private static Rectangle cullRect = new Rectangle();

	private void moveByAction(float delta){

		time += delta;

		moveCompleted = time >= duration;

		float percent;

		if (moveCompleted)

			percent = 1;

		else {

			percent = time / duration;

			if (interpolation != null) percent = interpolation.apply(percent);

		}

		percentDelta = percent - lastPercent;

		if(Scene.cullingEnabled){

			cullRect.set(getXLeft(), getYBot(), Scene.targetWidth, Scene.targetHeight);

			Scene.getCurrentScene().setCullingArea(cullRect);

		}

		translate(panSpeedX * percentDelta, panSpeedY * percentDelta, 0);

		for(Actor actor: hudActors) 

			actor.setPosition(actor.getX()+panSpeedX * percentDelta, actor.getY()+panSpeedY * percentDelta);

		lastPercent = percent;

		if (moveCompleted) interpolation = null;

	}

	public void resetCamera(){

		position.set(Scene.targetWidth/2, Scene.targetHeight/2, 0);

	}

	/*

	 * This makes the camera follow the actor once and only once. Once the camera reaches its

	 * target, it stops following the actor.

	 */

	public static void followActor(Actor actor){

		followedActor = actor;

		followContinous = false;

	}

	/*

	 * This makes the camera follow the actor continuously, even after the camera reaches its

	 * target, it keeps following the if the actor changes its position.

	 */

	public static void followActorContinuously(Actor actor){

		followedActor = actor;

		followContinous = true;

	}

	/*

	 * Sets the speed at which the camera follows the actor. By default it moves 1px for a duration of 1f

	 * so its speed is 1px/f. So reduce the duration to increase its speed.

	 * ex: setPanSpeed(0.5) will change its speed to 2px/f

	 * Here: f can/maybe also indicate seconds

	 */

	public static void setFollowSpeed(float duration){

		followSpeed = duration;

	}

	private void follow(){

		//if(camera.position.x == followedActor.getX()+followLeftOffset &&

		//	camera.position.y == followedActor.getY()+followTopOffset)

		//return;

		//moveTo(followedActor.getX()+followLeftOffset, followedActor.getY()+followTopOffset, 100f);

		if(position.x < followedActor.getX() - followOffset.x) moveBy(1f, 0, followSpeed);

		else if(position.x > followedActor.getX() + followOffset.width) moveBy(-1f, 0, followSpeed);

		else if(position.y < followedActor.getY() - followOffset.y) moveBy(0, 1f, followSpeed);

		else if(position.y > followedActor.getY() - followOffset.height) moveBy(0, -1f, followSpeed);

		else {

			if(!followContinous)

				followedActor = null;

		}

	}

	@Override

	public void update(){

		super.update();

		Scene.mouse.x = Gdx.input.getX();

		Scene.mouse.y = Gdx.graphics.getHeight() - Gdx.input.getY();

		if(!moveCompleted)

			moveByAction(Scene.stateTime);//FIXME

		if(usePan) 

			panCameraWithMouse();

		if(followedActor != null)

			follow();

	}

	private void panCameraWithMouse(){

		 if(Scene.mouse.x > panSize.width && getXLeft() < bounds.width) moveBy(1f, 0, panSpeed);

		 else if(Scene.mouse.x < panSize.x  && getXLeft() > bounds.x)  moveBy(-1f, 0, panSpeed);

		 else if(Scene.mouse.y < panSize.y && getYBot() > bounds.y) moveBy(0, -1f, panSpeed);

		 else if(Scene.mouse.y > panSize.height && getYBot() < bounds.height) moveBy(0, 1f, panSpeed);

	}

	private final static Vector3 curr = new Vector3();

	private final static Vector3 last = new Vector3(-1, -1, -1);

	private final static Vector3 deltaDrag = new Vector3();

	private static float deltaCamX = 0;

	private static float deltaCamY = 0;

	public static void dragCam(int x, int y){

		instance.unproject(curr.set(x, y, 0));

    	if (!(last.x == -1 && last.y == -1 && last.z == -1)) {

    		instance.unproject(deltaDrag.set(last.x, last.y, 0));

    		deltaDrag.sub(curr);

    		deltaCamX = deltaDrag.x + instance.position.x;

    		deltaCamY = deltaDrag.y + instance.position.y;

    		if(deltaCamX > bounds.x && deltaCamX < bounds.x+bounds.width)

    			moveBy(deltaDrag.x, 0f, 0f);

    		if(deltaCamY > bounds.y && deltaCamY < bounds.y+bounds.height)

    			moveBy(0f, deltaDrag.y, 0f);		

    	}

    	last.set(x, y, 0);

    }

	public static void resetDrag(){

		last.set(-1, -1, -1);

	}

	public static void reset(){

		usePan = false;

		followActor(null);

		clearAllHud();

		instance.position.set(Scene.targetWidth/2, Scene.targetHeight/2, 0);

	}

	/* If you want to make any elements/actors to move along with the camera 

	 * like HUD's add them using this method */

	public static void addHud(Actor actor){

		if(actor != null){

			Scene.getCurrentScene().addActor(actor);

			hudActors.add(actor);

		}

	}

	/* If you want to make any elements/actors to move along with the camera 

	 * like HUD's add them using this method */

	public static void addHud(String actorName){

		if(actorName != null && !actorName.isEmpty()){

			Actor actor = Scene.getCurrentScene().findActor(actorName);

			Scene.getCurrentScene().addActor(actor);

			hudActors.add(actor);

		}

	}

	/* If you want to any elements/actors which was a Hud the use this */

	public static void removeHud(Actor actor){

		Scene.getCurrentScene().removeActor(actor);

		hudActors.removeValue(actor, true);

	}

	/* If you want to any elements/actors which was a Hud the use this */

	public static void removeHud(String actorName){

		if(actorName != null && !actorName.isEmpty()){

			Actor actor = Scene.getCurrentScene().findActor(actorName);

			Scene.getCurrentScene().removeActor(actor);

			hudActors.removeValue(actor, true);

		}

	}

	/*

	 * Clears all hud's registered with the camera

	 */

	public static void clearAllHud(){

		hudActors.clear();

	}

	/*

	 * Returns the x position of the camera

	 */

	public static float getX(){

		return instance.position.x;

	}

	/*

	 * Returns the y position of the camera

	 */

	public static float getY(){

		return instance.position.y;

	}

	public static float getXLeft(){

		return instance.position.x - Scene.targetWidth/2;

	}

	public static float getYBot(){

		return instance.position.y - Scene.targetHeight/2;

	}

	public static float getWidth(){

		return instance.viewportWidth;

	}

	public static float getHeight(){

		return instance.viewportHeight;

	}

}