gdx-studio
git clone https://git.pyrossh.dev/gdx-studio
An IDE for creating Games using libgdx and Java supported on all platforms Android, iOS, Desktop
src/scene2d/Scene.java
package scene2d;
import scene3d.Actor3d;
import scene3d.Group3d;
import scene3d.Stage3d;
import com.badlogic.gdx.ApplicationListener;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.InputMultiplexer;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.PerspectiveCamera;
import com.badlogic.gdx.graphics.g2d.Batch;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer.ShapeType;
import com.badlogic.gdx.math.Intersector;
import com.badlogic.gdx.math.MathUtils;
import com.badlogic.gdx.math.Rectangle;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.scenes.scene2d.Actor;
import com.badlogic.gdx.scenes.scene2d.Group;
import com.badlogic.gdx.scenes.scene2d.InputEvent;
import com.badlogic.gdx.scenes.scene2d.Touchable;
import com.badlogic.gdx.scenes.scene2d.actions.Actions;
import com.badlogic.gdx.scenes.scene2d.ui.Dialog;
import com.badlogic.gdx.scenes.scene2d.ui.Image;
import com.badlogic.gdx.scenes.scene2d.ui.Label;
import com.badlogic.gdx.scenes.scene2d.ui.Table;
import com.badlogic.gdx.scenes.scene2d.utils.ClickListener;
import com.badlogic.gdx.scenes.scene2d.utils.TextureRegionDrawable;
import com.badlogic.gdx.utils.ArrayMap;
import com.badlogic.gdx.utils.Json;
import com.badlogic.gdx.utils.JsonReader;
import com.badlogic.gdx.utils.JsonValue;
import com.badlogic.gdx.utils.Scaling;
import com.badlogic.gdx.utils.StringBuilder;
import com.badlogic.gdx.utils.Timer;
import com.badlogic.gdx.utils.Timer.Task;
abstract public class Scene extends Group {
/* The array map containing all the scenes data of the game*/
public static final ArrayMap<String, String> scenesMap = new ArrayMap<String, String>();
private String sceneName = "";
public String sceneBackground = "None";
public String sceneMusic = "None";
public String sceneTransition = "None";
public float sceneDuration = 0;
public InterpolationType sceneInterpolationType = InterpolationType.Linear;
public static Color bgColor = new Color(1f,1f,1f,1f);
public static JsonValue configJson = null;
public static final JsonReader jsonReader = new JsonReader();
public static final Json json = new Json();
public static float splashDuration = 0f;
public static boolean pauseState = false;
/*Important:
* The Target Width and Target Height refer to the nominal width and height of the game for the
* graphics which are created for this width and height, this allows for the Stage to scale this
* graphics for all screen width and height. Therefore your game will work on all screen sizes
* but maybe blurred or look awkward on some devices.
* ex:
* My Game targetWidth = 800 targetHeight = 480
* Then my game works perfectly for SCREEN_WIDTH = 800 SCREEN_HEIGHT = 480
* and on others screen sizes it is just zoomed/scaled but works fine thats all
*/
public static float targetWidth = 800;
public static float targetHeight = 480;
public static boolean debug = false;
public final static Vector2 mouse = new Vector2();
private static Scene currentScene = null;
private static int sceneIndex = 0;
public static ClassLoader cl = null;
public static com.badlogic.gdx.scenes.scene2d.Stage stage2d;
public static Stage3d stage3d;
private static Label fpsLabel;
private static InputMultiplexer inputMux;
public static int mousePointer = 0;
public static int mouseButton = 0;
public static boolean cullingEnabled = false;
public static boolean isDirty = false;
public static String basePackage = "source.";
public Scene(){
setTouchable(Touchable.childrenOnly);
Camera.reset();
stage2d.clear();
stage3d.clear();
stage2d.addListener(touchInput);
setSize(targetWidth, targetHeight);
setBounds(0,0, targetWidth, targetHeight);
setColor(1f, 1f, 1f, 1f);
setVisible(true);
stage2d.getRoot().setPosition(0, 0);
stage2d.getRoot().setVisible(true);
stage3d.getRoot().setPosition(0, 0, 0);
stage3d.getRoot().setVisible(true);
sceneName = this.getClass().getName();
setName(sceneName);
Scene.log("Current Scene: "+sceneName);
currentScene = this;
load(sceneName);
cullingEnabled = true;
}
@Override
public void act(float delta){
super.act(delta);
if (fpsLabel != null)
fpsLabel.setText("Fps: " + Gdx.graphics.getFramesPerSecond());
}
public abstract void onClick(Actor actor);
public abstract void onTouchDown(Actor actor);
public abstract void onTouchUp();
public abstract void onDragged();
public abstract void onGesture(GestureType gestureType);
public abstract void onKeyTyped(char key);
public abstract void onKeyUp(int keycode);
public abstract void onKeyDown(int keycode);
/*
* This will pause any music and stop any sound being played
* and will fire the Pause event
*/
public abstract void onPause();
/*
* This will resume any music currently being played
* and will fire the Resume event
*/
public abstract void onResume();
public abstract void onDispose();
public void load(String sceneName){
log("Load "+sceneName);
if(!sceneName.contains(basePackage) && !sceneName.contains("gdxstudio"))
sceneName = basePackage+sceneName;
String[] lines = scenesMap.get(sceneName).split("\n");
for(String line: lines){
if(line.trim().isEmpty())
continue;
json.fromJson(null, line);
//log(line);
}
if(!sceneBackground.equals("None"))
setBackground(sceneBackground);
if(!sceneMusic.equals("None"))
Asset.musicPlay(sceneMusic);
if(!sceneTransition.equals("None"))
Effect.createEffect(Scene.getRoot(), EffectType.valueOf(sceneTransition), 1f,
sceneDuration, sceneInterpolationType);
}
protected void save(){
save(sceneName);
}
public void save(String sceneName){
if(!isDirty)
return;
if(sceneName == null || sceneName.isEmpty())
return;
Scene.log("Save "+sceneName);
if(!sceneName.contains(basePackage) && !sceneName.contains("gdxstudio"))
sceneName = basePackage+sceneName;
StringBuilder sb = new StringBuilder();
for(Actor actor: getChildren()){
sb.append(json.toJson(actor));
sb.append("\n");
}
sb.append(json.toJson(getRoot().findActor(this.sceneName)));//??Warning
scenesMap.put(sceneName, sb.toString());
Gdx.files.local(Asset.basePath+"scene").writeString(json.toJson(scenesMap, ArrayMap.class,
String.class), false);
sb = null;
isDirty = false;
}
/**
* Set the current scene to be displayed
* @param className The scene's Class Name
**/
public static void setScene(String className){
if(!className.contains(basePackage) && !className.contains("gdxstudio"))
className = basePackage+className;
if(!scenesMap.containsKey(className)){
log(className+": Scene Does not Exist");
return;
}
/*
* Every time the scene Changes disable panning/following/listening as it can cause the
* camera to move around aimlessly, thus abrupting the scene and clear
* all the listeners/huds that were registered in the previous scene
*/
sceneIndex = Scene.scenesMap.keys().toArray().indexOf(className, false);
if(currentScene != null)
currentScene.onDispose();
try {
if(cl != null)
cl.loadClass(className).newInstance();
else
Class.forName(className).newInstance();
} catch (InstantiationException e) {
log("Scene cannot be created , Check if scene class constructor is empty");
e.printStackTrace();
} catch (IllegalAccessException e) {
log("Scene cannot be created , Check if scene class can be found");
e.printStackTrace();
} catch (ClassNotFoundException e) {
log("Scene cannot be created , Check if scene class can be found");
e.printStackTrace();
}
//if (fpsLabel != null && configJson.getBoolean("showFPS")){
// fpsLabel.setPosition(targetWidth - 80, targetHeight - 20);
// Camera.addHud(fpsLabel);
//}
}
/**
* Set the current scene to be displayed with an amount of delay
* @param className The registered scene's name
**/
public static void setSceneWithDelay(final String className, float delay){
Timer.schedule(new Task(){
@Override
public void run() {
setScene(className);
}
}, delay);
}
/**
* Returns the current scene being Displayed on stage
**/
public static Scene getCurrentScene(){
return currentScene;
}
/**
* Changes to the next scene in the scnesList
**/
public static void nextScene(){
if(sceneIndex <= scenesMap.size)
sceneIndex++;
setScene(scenesMap.getKeyAt(sceneIndex));
}
/**
* Changes to the previous scene in the scnesList
**/
public static void prevScene(){
if(sceneIndex >= 0)
sceneIndex--;
setScene(scenesMap.getKeyAt(sceneIndex));
}
/**
* Changes to the next scene in the scnesList
**/
public static void nextSceneWithDelay(float delay){
if(sceneIndex <= scenesMap.size)
sceneIndex++;
setSceneWithDelay(Scene.scenesMap.getKeyAt(sceneIndex), delay);
}
/**
* Changes to the previous scene in the scnesList
**/
public static void prevSceneWithDelay(float delay){
if(sceneIndex >= 0)
sceneIndex--;
setSceneWithDelay(scenesMap.getKeyAt(sceneIndex), delay);
}
private static Image imgbg = null;
public void setBackground(String texName) {
if(imgbg != null)
removeBackground();
if(Asset.tex(texName) != null){
imgbg = new Image(new TextureRegionDrawable(Asset.tex(texName)), Scaling.stretch);
imgbg.setFillParent(true);
stage2d.addActor(imgbg);
imgbg.toBack();
}
}
public void removeBackground() {
getRoot().removeActor(imgbg);
}
public static Group getRoot(){
return stage2d.getRoot();
}
public void addActor(Actor actor, float x, float y){
if(actor != null){
actor.setPosition(x, y);
addActor(actor);
}
}
public void addActorWithDelay(final Actor actor, float delay){
Timer.schedule(new Task(){
@Override
public void run() {
addActor(actor);
}
}, delay);
}
public boolean removeActor(String actorName){
return removeActor(findActor(actorName));
}
public void removeActorWithDelay(Actor actor, float delay){
addAction(Actions.sequence(Actions.delay(delay), Actions.removeActor(actor)));
}
public Actor hit(float x, float y){
return hit(x, y, true);
}
/* Dragging Camera Related */
static boolean gestureStarted = false;
static Actor validActor = null;
private final ClickListener touchInput = new ClickListener(){
@Override
public void clicked(InputEvent event, float x, float y){
super.clicked(event, x, y);
mouse.set(x, y);
validActor = hit(x,y);
if(validActor != null && validActor.getName() != null)
Scene.getCurrentScene().onClick(validActor);
}
@Override
public boolean touchDown(InputEvent event, float x, float y, int pointer, int button){
mouse.set(x, y);
mousePointer = pointer;
mouseButton = button;
touchInitialX = x;
touchInitialY = y;
gestureStarted = true;
validActor = hit(x,y);
if(validActor != null && validActor.getName() != null)
Scene.getCurrentScene().onTouchDown(validActor);
return super.touchDown(event, x, y, pointer, button);
}
@Override
public void touchDragged(InputEvent event, float x, float y, int pointer){
super.touchDragged(event, x, y, pointer);
mouse.set(x, y);
mousePointer = pointer;
Scene.getCurrentScene().onDragged();
if(gestureStarted == true){
touchCurrentX = x;
touchCurrentY = y;
if(getGestureDirection() != GestureType.None){
gestureStarted = false;
Scene.getCurrentScene().onGesture(getGestureDirection());
}
}
if(Camera.useDrag)
Camera.dragCam((int)x, (int)-y);
}
@Override
public void touchUp(InputEvent event, float x, float y, int pointer, int button){
super.touchUp(event, x, y, pointer, button);
mouse.set(x, y);
mousePointer = pointer;
mouseButton = button;
// reset Gesture
difX = 0.0f;
difY = 0.0f;
touchInitialX = 0.0f;
touchInitialY = 0.0f;
touchCurrentX = 0.0f;
touchCurrentY = 0.0f;
touchDifX = 0.0f;
touchDifY = 0.0f;
prevDifX = 0.0f;
prevDifY = 0.0f;
// reset Gesture
Scene.getCurrentScene().onTouchUp();
Camera.resetDrag();
gestureStarted = false;
}
@Override
public boolean keyTyped(InputEvent event, char key) {
Scene.getCurrentScene().onKeyTyped(key);
return super.keyUp(event, key);
}
@Override
public boolean keyUp(InputEvent event, int keycode) {
Scene.getCurrentScene().onKeyUp(keycode);
return super.keyUp(event, keycode);
}
@Override
public boolean keyDown(InputEvent event, int keycode) {
Scene.getCurrentScene().onKeyDown(keycode);
return super.keyDown(event, keycode);
}
};
/*
* Gesture related
*/
public static float touchDragIntervalRange = 200f; // 200px drag for a gesture event
public static float touchInitialX = 0.0f, touchInitialY = 0.0f;
public static float touchCurrentX = 0.0f, touchCurrentY = 0.0f;
public static float difX;
public static float difY;
public static float prevDifX;
public static float prevDifY;
public static float touchDifX;
public static float touchDifY;
public boolean isTouchDragInterval() {
difX = java.lang.Math.abs(touchInitialX - touchCurrentX);
difY = java.lang.Math.abs(touchInitialY - touchCurrentY);
if (difX > touchDragIntervalRange || difY > touchDragIntervalRange)
return true;
else
return false;
}
public static GestureType getGestureDirection() {
prevDifX = difX;
prevDifY = difY;
difX = java.lang.Math.abs(touchInitialX - touchCurrentX);
difY = java.lang.Math.abs(touchInitialY - touchCurrentY);
/**
* Get minimal changes on drag
* <p> checkMomentumChanges
* EXAMPLE<br>
* User drags finger to left, suddenly dragging to right without removing
* his finger from the screen
* */
if (prevDifX > difX || prevDifY > difY) {
touchInitialX = touchCurrentX;
touchInitialY = touchCurrentY;
//
difX = 0.0f;
difY = 0.0f;
prevDifX = 0.0f;
prevDifY = 0.0f;
/**
* Set touch differences, optional, if you need amount of change from
* initial touch to drag, USE THIS: on touchDrag, pan or similar mthods
* */
touchDifX = java.lang.Math.abs(touchInitialX - touchCurrentX);
touchDifY = java.lang.Math.abs(touchInitialY - touchCurrentY);
}
if (touchInitialY < touchCurrentY && difY > difX) {
return GestureType.Up;
} else if (touchInitialY > touchCurrentY && difY > difX) {
return GestureType.Down;
} else if (touchInitialX < touchCurrentX && difY < difX) {
return GestureType.Right;
} else if (touchInitialX > touchCurrentX && difY < difX) {
return GestureType.Left;
} else {
return GestureType.None;
}
}
/*
* Dialog Methods
*/
public void showToast(String message, float duration){
Table table = new Table(Asset.skin);
table.add(" "+message+" ");
table.setBackground(Asset.skin.getDrawable("dialogDim"));
table.pack();
table.setPosition(Scene.targetWidth/2 - table.getWidth(), Scene.targetHeight/2 - table.getHeight());
addActor(table);
table.addAction(Actions.sequence(Actions.delay(duration), Actions.removeActor(table)));
}
public void showMessageDialog(String title, String message){
Dialog dialog = new Dialog(title, Asset.skin);
dialog.getContentTable().add(message);
dialog.button("OK", "OK");
dialog.pack();
dialog.show(getStage());
}
public boolean showConfirmDialog(String title, String message){
Dialog dialog = new Dialog(title, Asset.skin);
dialog.button("Yes", "Yes");
dialog.button("No", "No");
dialog.pack();
dialog.show(getStage());
//if(dialog.result().equals("Yes")) FIXME update Gdx
// return true;
return false;
}
public void outline(Actor actor){
selectionBox.setPosition(actor.getX(), actor.getY());
selectionBox.setSize(actor.getWidth(), actor.getHeight());
stage2d.addActor(selectionBox);
}
/***********************************************************************************************************
* 3d Related Functions *
************************************************************************************************************/
public static void addActor3d(Actor3d actor3d){
stage3d.addActor3d(actor3d);
}
public static void removeActor3d(Actor3d actor3d){
stage3d.getRoot().removeActor3d(actor3d);
}
public static void removeActor3d(String actor3dName){
getRoot3d().removeActor3d(stage3d.getRoot().findActor(actor3dName));
}
public static Group3d getRoot3d(){
return stage3d.getRoot();
}
public static void getChildren3d(){
stage3d.getActors3d();
}
public static void resetCamera3d(){
stage3d.getCamera().position.set(10f, 10f, 10f);
stage3d.getCamera().lookAt(0,0,0);
stage3d.getCamera().near = 0.1f;
stage3d.getCamera().far = 300f;
}
public static PerspectiveCamera getCamera3d(){
return stage3d.getCamera();
}
public static void log(String log) {
if(Scene.configJson.getBoolean("loggingEnabled"))
Gdx.app.log("Stage ", log);
}
/***********************************************************************************************************
* Utilities Related Functions *
************************************************************************************************************/
/*
* The the angle in degrees of the inclination of a line
* @param cx, cy The center point x, y
* @param tx, ty The target point x, y
*/
public static float getAngle(float cx, float cy, float tx, float ty) {
float angle = (float) Math.toDegrees(MathUtils.atan2(tx - cx, ty - cy));
//if(angle < 0){
// angle += 360;
//}
return angle;
}
private static Vector2 distVector = new Vector2();
public static final float getDistance(Actor a, Actor b){
distVector.set(a.getX(), a.getY());
return distVector.dst(b.getX(), b.getY());
}
public static final float getDistance(float x1, float y1, float x2, float y2){
distVector.set(x1, y1);
return distVector.dst(x2, y2);
}
/*
* Capitalizes the First Letter of a String
*/
public static String capitalize(String text){
if(text != null && text != "")
return (text.substring(0, 1)).toUpperCase() + text.substring(1);
else
return "";
}
/*
* UnCapitalizes the First Letter of a String
*/
public static String uncapitalize(String text){
return text.substring(0, 1).toLowerCase()+text.substring(1);
}
public static Rectangle getBounds(Actor actor) {
float posX = actor.getX();
float posY = actor.getY();
float width = actor.getWidth();
float height = actor.getHeight();
return new Rectangle(posX, posY, width, height);
}
public static boolean collides(Actor actor, float x, float y) {
Rectangle rectA1 = getBounds(actor);
Rectangle rectA2 = new Rectangle(x, y, 5, 5);
// Check if rectangles collides
if (Intersector.overlaps(rectA1, rectA2)) {
return true;
} else {
return false;
}
}
public static boolean collides(Actor actor1, Actor actor2) {
Rectangle rectA1 = getBounds(actor1);
Rectangle rectA2 = getBounds(actor2);
// Check if rectangles collides
if (Intersector.overlaps(rectA1, rectA2)) {
return true;
} else {
return false;
}
}
/**
* Get screen time from start in format of HH:MM:SS. It is calculated from
* "secondsTime" parameter.
* */
public static String toScreenTime(float secondstime) {
int seconds = (int)(secondstime % 60);
int minutes = (int)((secondstime / 60) % 60);
int hours = (int)((secondstime / 3600) % 24);
return new String(addZero(hours) + ":" + addZero(minutes) + ":" + addZero(seconds));
}
private static String addZero(int value){
String str = "";
if(value < 10)
str = "0" + value;
else
str = "" + value;
return str;
}
/*
* TEA Encryption and Decryption
*/
public static String encryptKey = "Default";
private static final int encryptDelta = 0x9E3779B9;
private static final int MX(int sum, int y, int z, int p, int e, int[] k) {
return (z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
}
public static final byte[] encrypt(String data) {
return encrypt(data.getBytes(), encryptKey.getBytes());
}
public static final byte[] decrypt(String data) {
return decrypt(data.getBytes(), encryptKey.getBytes());
}
public static final byte[] encrypt(String data, String key) {
return encrypt(data.getBytes(), key.getBytes());
}
public static final byte[] decrypt(String data, String key) {
return decrypt(data.getBytes(), key.getBytes());
}
private static final byte[] encrypt(byte[] data, byte[] key) {
if (data.length == 0)
return data;
return toByteArray(encrypt(toIntArray(data, true), toIntArray(key, false)), false);
}
private static final byte[] decrypt(byte[] data, byte[] key) {
if (data.length == 0)
return data;
return toByteArray(decrypt(toIntArray(data, false), toIntArray(key, false)), true);
}
private static final int[] encrypt(int[] v, int[] k) {
int n = v.length - 1;
if (n < 1) {
return v;
}
if (k.length < 4) {
int[] key = new int[4];
System.arraycopy(k, 0, key, 0, k.length);
k = key;
}
int z = v[n], y = v[0], sum = 0, e;
int p, q = 6 + 52 / (n + 1);
while (q-- > 0) {
sum = sum + encryptDelta;
e = sum >>> 2 & 3;
for (p = 0; p < n; p++) {
y = v[p + 1];
z = v[p] += MX(sum, y, z, p, e, k);
}
y = v[0];
z = v[n] += MX(sum, y, z, p, e, k);
}
return v;
}
private static final int[] decrypt(int[] v, int[] k) {
int n = v.length - 1;
if (n < 1) {
return v;
}
if (k.length < 4) {
int[] key = new int[4];
System.arraycopy(k, 0, key, 0, k.length);
k = key;
}
int z = v[n], y = v[0], sum, e;
int p, q = 6 + 52 / (n + 1);
sum = q * encryptDelta;
while (sum != 0) {
e = sum >>> 2 & 3;
for (p = n; p > 0; p--) {
z = v[p - 1];
y = v[p] -= MX(sum, y, z, p, e, k);
}
z = v[n];
y = v[0] -= MX(sum, y, z, p, e, k);
sum = sum - encryptDelta;
}
return v;
}
private static final int[] toIntArray(byte[] data, boolean includeLength) {
int n = (((data.length & 3) == 0)
? (data.length >>> 2)
: ((data.length >>> 2) + 1));
int[] result;
if (includeLength) {
result = new int[n + 1];
result[n] = data.length;
}
else {
result = new int[n];
}
n = data.length;
for (int i = 0; i < n; i++) {
result[i >>> 2] |= (0x000000ff & data[i]) << ((i & 3) << 3);
}
return result;
}
private static final byte[] toByteArray(int[] data, boolean includeLength) {
int n = data.length << 2;
if (includeLength) {
int m = data[data.length - 1];
if (m > n) {
return null;
}
else {
n = m;
}
}
byte[] result = new byte[n];
for (int i = 0; i < n; i++) {
result[i] = (byte) ((data[i >>> 2] >>> ((i & 3) << 3)) & 0xff);
}
return result;
}
private static ShapeRenderer shapeRenderer;
private final static Actor selectionBox = new Actor(){
@Override
public void draw(Batch batch, float alpha){
batch.end();
shapeRenderer.begin(ShapeType.Line);
shapeRenderer.setColor(Color.GREEN);
shapeRenderer.rect(getX(), getY(),
getWidth(),getHeight());
shapeRenderer.end();
batch.begin();
}
};
static void setupFps(){
fpsLabel = new Label("", Asset.skin);
fpsLabel.setName("Fps");
}
public static float stateTime = 0;
public static float gameUptime = 0;
private static float startTime = System.nanoTime();
/*
* The main application listener for the game
*/
public static ApplicationListener app = new ApplicationListener() {
public int dots = 40;
public int xlines;
public int ylines;
@Override
public final void create() {
log("Create");
Config.setup();
Serializer.setup();
stage2d = new com.badlogic.gdx.scenes.scene2d.Stage(Gdx.graphics.getWidth(), Gdx.graphics.getHeight(),
Scene.configJson.getBoolean("keepAspectRatio"));
stage2d.getRoot().setName("Root");
stage2d.getRoot().setTouchable(Touchable.childrenOnly);
stage2d.setCamera(new Camera());
inputMux = new InputMultiplexer();
inputMux.addProcessor(stage2d);
stage3d = new Stage3d();
//camController = new CameraInputController(stage3d.getCamera());
//inputMux.addProcessor(stage3d);
//inputMux.addProcessor(camController);
shapeRenderer = new ShapeRenderer();
selectionBox.setTouchable(Touchable.disabled);
selectionBox.setName("Shape");
JsonValue sv = Scene.jsonReader.parse(Gdx.files.internal(Asset.basePath+"scene"));
for(JsonValue jv: sv.iterator())
scenesMap.put(jv.name, jv.asString());
setScene(scenesMap.firstKey());
Gdx.input.setCatchBackKey(true);
Gdx.input.setCatchMenuKey(true);
Gdx.input.setInputProcessor(inputMux);
xlines = (int)Gdx.graphics.getWidth()/dots;
ylines = (int)Gdx.graphics.getHeight()/dots;
}
/*
* This is the main rendering call that updates the time, updates the stage,
* loads assets asynchronously, updates the camera and FPS text.
*/
@Override
public final void render(){
Gdx.gl.glClearColor(bgColor.r, bgColor.g, bgColor.b, bgColor.a);
Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT |GL20.GL_DEPTH_BUFFER_BIT);
if (System.nanoTime() - startTime >= 1000000000) {
gameUptime +=1 ;
startTime = System.nanoTime();
}
stateTime += Gdx.graphics.getDeltaTime();
Asset.load();
stage3d.act();
stage3d.draw();
//camController.update();
Scene.stage2d.act();//Gdx.graphics.getDeltaTime();
Scene.stage2d.draw();
if(debug){
shapeRenderer.begin(ShapeType.Point);
shapeRenderer.setColor(Color.BLACK);
for(int i = 0; i<=xlines; i++)
for(int j = 0; j<=ylines; j++)
shapeRenderer.point(2+i*dots, j*dots, 0);
shapeRenderer.end();
}
}
@Override
public final void resize(int width, int height) {
log("Resize");
stage2d.setViewport(targetWidth, targetHeight, configJson.getBoolean("keepAspectRatio"));
stage3d.setViewport(targetWidth, targetHeight, configJson.getBoolean("keepAspectRatio"));
}
@Override
public final void pause() {
log("Pause");
Asset.musicPause();
Asset.soundStop();
Scene.pauseState = true;
Scene.getCurrentScene().onPause();
}
@Override
public final void resume() {
log("Resume");
Asset.musicResume();
Scene.pauseState = false;
Scene.getCurrentScene().onResume();
}
@Override
public final void dispose() {
log("Dispose");
Scene.getCurrentScene().onDispose();
Scene.stage2d.dispose();
Asset.unloadAll();
Gdx.app.exit();
}
};
public static final void exit(){
log("Disposing and Exiting");
getCurrentScene().onDispose();
stage2d.dispose();
stage3d.dispose();
Asset.unloadAll();
Gdx.app.exit();
}
public enum GestureType {
None, Up, Down, Left, Right
}
public enum OnEventType {
DoEffect,
SetScene
}
}