libGDX

https://libgdx.com/wiki
Admin
libGDX is a cross-platform game development framework for creating 2D and 3D games, offering...
Tokens:149,352
Snippets:1,866
Trust Score:9.5
Update:3 months ago
Show doc for...
Tokens:
Raw
### Full G3DJ Import and Render Example

Source: https://libgdx.com/wiki/graphics/3d/importing-blender-models-in-libgdx

Complete ApplicationListener implementation demonstrating model loading, environment setup, and rendering loop.

```java
import com.badlogic.gdx.ApplicationListener;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.PerspectiveCamera;
import com.badlogic.gdx.graphics.VertexAttributes.Usage;
import com.badlogic.gdx.graphics.g3d.Environment;
import com.badlogic.gdx.graphics.g3d.Model;
import com.badlogic.gdx.graphics.g3d.ModelBatch;
import com.badlogic.gdx.graphics.g3d.ModelInstance;
import com.badlogic.gdx.graphics.g3d.attributes.ColorAttribute;
import com.badlogic.gdx.graphics.g3d.environment.DirectionalLight;
import com.badlogic.gdx.graphics.g3d.Material;
import com.badlogic.gdx.graphics.g3d.loader.G3dModelLoader;
import com.badlogic.gdx.graphics.g3d.utils.CameraInputController;
import com.badlogic.gdx.graphics.g3d.utils.ModelBuilder;
import com.badlogic.gdx.utils.JsonReader;

/**
 * Example program that imports "myModel.g3dj" from the assets folder and renders it onto the screen.
 */
public class ImportG3DJ implements ApplicationListener {
    private Environment environment;
    private PerspectiveCamera camera;
    private CameraInputController cameraController;
    private ModelBatch modelBatch;
    private Model model;
    private ModelInstance instance;

    @Override
    public void create() {
        // Create an environment so we have some lighting
        environment = new Environment();
        environment.set(new ColorAttribute(ColorAttribute.AmbientLight, 0.4f, 0.4f, 0.4f, 1f));
        environment.add(new DirectionalLight().set(0.8f, 0.8f, 0.8f, -1f, -0.8f, -0.2f));

        modelBatch = new ModelBatch();

        // Create a perspective camera with some sensible defaults
        camera = new PerspectiveCamera(67, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
        camera.position.set(10f, 10f, 10f);
        camera.lookAt(0, 0, 0);
        camera.near = 1f;
        camera.far = 300f;
        camera.update();

        // Import and instantiate our model (called "myModel.g3dj")
        ModelBuilder modelBuilder = new ModelBuilder();
        model = new G3dModelLoader(new JsonReader()).loadModel(Gdx.files.internal("myModel.g3dj"));
        instance = new ModelInstance(model);

        cameraController = new CameraInputController(camera);
        Gdx.input.setInputProcessor(cameraController);
    }

    @Override
    public void render() {
        cameraController.update();

        // Clear the stuff that is left over from the previous render cycle
        Gdx.gl.glViewport(0, 0, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT | GL20.GL_DEPTH_BUFFER_BIT);

        // Let our ModelBatch take care of efficient rendering of our ModelInstance
        modelBatch.begin(camera);
        modelBatch.render(instance, environment);
        modelBatch.end();
    }

    @Override
    public void dispose() {
        modelBatch.dispose();
        model.dispose();
    }

    @Override
    public void resize(int width, int height) { }

    @Override
    public void pause() { }

    @Override
    public void resume() { }
}
```

--------------------------------

### Start Camera Preview

Source: https://libgdx.com/wiki/graphics/integrating-libgdx-and-the-device-camera

Starts the camera preview process, provided via both synchronous and asynchronous methods.

```java
	@Override
	public synchronized void startPreviewAsync() {
		Runnable r = new Runnable() {
			public void run() {
				startPreview();
			}
		};
		activity.post(r);
	}
	@Override
	public synchronized void startPreview() {
		// ...and start previewing. From now on, the camera keeps pushing preview
		// images to the surface.
		if (cameraSurface != null && cameraSurface.getCamera() != null) {
			cameraSurface.getCamera().startPreview();
		}
	}
```

--------------------------------

### Install Android test suite

Source: https://libgdx.com/wiki/misc/building-the-bullet-wrapper

Builds and installs the Android test suite to verify changes.

```bash
gradlew tests:gdx-tests-android:installDebug
```

--------------------------------

### Obtaining FileHandles

Source: https://libgdx.com/wiki/file-handling

Examples of creating FileHandle instances for different storage locations.

```java
FileHandle handle = Gdx.files.internal("data/myfile.txt");
```

```java
FileHandle handle = Gdx.files.classpath("myfile.txt");
```

```java
FileHandle handle = Gdx.files.external("myfile.txt");
```

```java
FileHandle handle = Gdx.files.absolute("/some_dir/subdir/myfile.txt");
```

--------------------------------

### Run and Test HTML5 Project

Source: https://libgdx.com/wiki/articles/maven-integration

Installs the HTML5 project to enable local testing.

```bash
mvn -Phtml install
```

--------------------------------

### Launch the Desktop Application

Source: https://libgdx.com/wiki/graphics/2d/orthographic-camera

Entry point for running the orthographic camera example on a desktop environment.

```java
import com.badlogic.gdx.backends.lwjgl3.Lwjgl3Application;
import com.badlogic.gdx.backends.lwjgl3.Lwjgl3ApplicationConfiguration;

public class DesktopLauncher {
	public static void main (String[] arg) {
		Lwjgl3ApplicationConfiguration config = new Lwjgl3ApplicationConfiguration();
		config.setForegroundFPS(60);
		config.setTitle("orthographic-camera-example");
		new Lwjgl3Application(new OrthographicCameraExample(), config);
	}
}
```

--------------------------------

### Comprehensive Skin JSON Example

Source: https://libgdx.com/wiki/graphics/2d/scene2d/skin

A practical example defining colors, fonts, and text button styles within a skin JSON file.

```json
{
	com.badlogic.gdx.graphics.Color: {
		white: { r: 1, g: 1, b: 1, a: 1 },
		red: { r: 1, g: 0, b: 0, a: 1 },
		yellow: { r: 0.5, g: 0.5, b: 0, a: 1 }
	},
	com.badlogic.gdx.graphics.g2d.BitmapFont: {
		medium: { file: medium.fnt }
	},
	com.badlogic.gdx.scenes.scene2d.ui.TextButton$TextButtonStyle: {
		default: {
			down: round-down, up: round,
			font: medium, fontColor: white
		},
		toggle: {
			down: round-down, up: round, checked: round-down,
			font: medium, fontColor: white, checkedFontColor: red
		},
		green: {
			down: round-down, up: round,
			font: medium, fontColor: { r: 0, g: 1, b: 0, a: 1 }
		}
	}
}
```

--------------------------------

### OrthographicCamera viewport configuration examples

Source: https://libgdx.com/wiki/graphics/2d/orthographic-camera

Examples showing how different viewport dimensions affect the amount of the world visible to the camera.

```text
Some examples -

If we created our camera with viewport width of 100 and viewport height of 100 ('new OrthographicCamera(100, 100)') and centered it correctly, we would be able to see the 'whole' map, our 'whole' world at once.

If we created our camera with viewport width of 100 and viewport height of 50 ('new OrthographicCamera(100, 50)') we would be able to see 'half' of the map at any given time

If we created our camera with viewport width of 50 and viewport height of 50 ('new OrthographicCamera(50, 50)') we would be able to see a 'quarter' of the map at any given time
```

--------------------------------

### Initialize ImGui Context

Source: https://libgdx.com/wiki/graphics/2d/imgui

Setup method to initialize the ImGui context and GLFW/OpenGL3 backends for libGDX.

```java
private static ImGuiImplGlfw imGuiGlfw;
private static ImGuiImplGl3 imGuiGl3;

public static void initImGui() {
   imGuiGlfw = new ImGuiImplGlfw();
   imGuiGl3 = new ImGuiImplGl3();
   long windowHandle = ((Lwjgl3Graphics) Gdx.graphics).getWindow().getWindowHandle();
   ImGui.createContext();
   ImGuiIO io = ImGui.getIO();
   io.setIniFilename(null); //Optional. Disables saving window layouts between sessions
   io.getFonts().addFontDefault();
   io.getFonts().build();
   imGuiGlfw.init(windowHandle, true);
   imGuiGl3.init("#version 150");
}
```

--------------------------------

### Install Android APK

Source: https://libgdx.com/wiki/articles/maven-integration

Installs the generated APK to a connected device or emulator.

```bash
mvn -Pandroid install
```

--------------------------------

### Serve Web Distribution with Node.js

Source: https://libgdx.com/wiki/deployment/deploying-your-application

Installs and runs a simple HTTP server to host the distribution files.

```bash
npm install http-server -g
```

```bash
http-server html/build/dist
```

--------------------------------

### Quickstart Table Layout

Source: https://libgdx.com/wiki/graphics/2d/scene2d/table

Demonstrates creating a basic 2x2 grid layout using Labels and TextFields. Cell properties like width are applied directly to the Cell returned by the add method.

```java
    Label nameLabel = new Label("Name:", skin);
    TextField nameText = new TextField("", skin);
    Label addressLabel = new Label("Address:", skin);
    TextField addressText = new TextField("", skin);
    
    Table table = new Table();
    table.add(nameLabel);
    table.add(nameText).width(100);
    table.row();
    table.add(addressLabel);
    table.add(addressText).width(100);
```

--------------------------------

### Install LibGDX Maven Archetype

Source: https://libgdx.com/wiki/articles/maven-integration

Commands to clone the repository and install the archetype into the local Maven repository.

```bash
git clone git://github.com/libgdx/libgdx-maven-archetype.git
cd libgdx-maven-archetype
mvn install
```

--------------------------------

### Start ImGui Frame

Source: https://libgdx.com/wiki/graphics/2d/imgui

Prepares the ImGui frame and manages input processor state before rendering UI elements.

```java
private static InputProcessor tmpProcessor;

public static void startImGui() {
   if (tmpProcessor != null) { // Restore the input processor after ImGui caught all inputs, see #end()
      Gdx.input.setInputProcessor(tmpProcessor);
      tmpProcessor = null;
   }
      
   imGuiGl3.newFrame();
   imGuiGlfw.newFrame();
   ImGui.newFrame();
}
```

--------------------------------

### Setup Mesh and Texture

Source: https://libgdx.com/wiki/graphics/opengl-utils/shaders

Configures a mesh with specific vertex attributes and loads a texture for rendering.

```java
mesh = new Mesh(true, 4, 6, VertexAttribute.Position(), VertexAttribute.ColorUnpacked(), VertexAttribute.TexCoords(0));
mesh.setVertices(new float[] {
    -0.5f, -0.5f, 0, 1, 1, 1, 1, 0, 1,
    0.5f, -0.5f, 0, 1, 1, 1, 1, 1, 1,
    0.5f, 0.5f, 0, 1, 1, 1, 1, 1, 0,
    -0.5f, 0.5f, 0, 1, 1, 1, 1, 0, 0
});
mesh.setIndices(new short[] {0, 1, 2, 2, 3, 0});
texture = new Texture(Gdx.files.internal("bobrgb888-32x32.png"));
```

--------------------------------

### Play music

Source: https://libgdx.com/wiki/audio/streaming-music

Starts playback of the loaded music instance.

```java
music.play();
```

--------------------------------

### Configure and launch LWJGL3 desktop application

Source: https://libgdx.com/wiki/app/starter-classes-and-configuration

The Lwjgl3Launcher class initializes the application configuration and starts the game using the MyGdxGame listener.

```java
package com.me.mygdxgame;

import com.badlogic.gdx.backends.lwjgl3.Lwjgl3Application;
import com.badlogic.gdx.backends.lwjgl3.Lwjgl3ApplicationConfiguration;
import com.me.mygdxgame.MyGdxGame;

public class Lwjgl3Launcher {
    public static void main(String[] args) {
        if (StartupHelper.startNewJvmIfRequired()) return;
        createApplication();
    }

    private static Lwjgl3Application createApplication() {
        return new Lwjgl3Application(new MyGdxGame(), getDefaultConfiguration());
    }

    private static Lwjgl3ApplicationConfiguration getDefaultConfiguration() {
        Lwjgl3ApplicationConfiguration configuration = new Lwjgl3ApplicationConfiguration();
        configuration.setTitle("my-gdx-game");
        configuration.useVsync(true);
        configuration.setForegroundFPS(Lwjgl3ApplicationConfiguration.getDisplayMode().refreshRate);
        configuration.setWindowedMode(640, 480);
        configuration.setWindowIcon("libgdx128.png", "libgdx64.png", "libgdx32.png", "libgdx16.png");
        return configuration;
    }
}
```

--------------------------------

### Install Local JARs to Maven

Source: https://libgdx.com/wiki/articles/dependency-management-with-gradle

Use Maven commands to install local JAR files and their sources into the local repository.

```bash
mvn install:install-file -Dfile=<path-to-file> -DgroupId=<group-id> -DartifactId=<artifact-id> -Dversion=<version> -Dpackaging=<packaging>
```

```bash
mvn install:install-file -Dfile=<path-to-source-file> -DgroupId=<group-id> -DartifactId=<artifact-id> -Dversion=<version> -Dpackaging=<packaging> -Dclassifier=sources
```

--------------------------------

### Initialize Offscreen GLFW for OpenVR

Source: https://libgdx.com/wiki/graphics/3d/virtual-reality

Demonstrates the manual setup of a headless GLFW window for OpenVR rendering. Requires custom implementations of the libGDX Graphics and Application interfaces.

```java
Lwjgl3NativesLoader.load();
errorCallback = GLFWErrorCallback.createPrint(System.err);
GLFW.glfwSetErrorCallback(errorCallback);
if (!GLFW.glfwInit())
{
   throw new RuntimeException("Unable to initialize GLFW");
}
GLFW.glfwWindowHint(GLFW.GLFW_VISIBLE, GLFW.GLFW_FALSE);
windowHandle = GLFW.glfwCreateWindow(640, 480, "", MemoryUtil.NULL, MemoryUtil.NULL);
GLFW.glfwMakeContextCurrent(windowHandle);
GL.createCapabilities();

Gdx.gl30 = new Lwjgl3GL30();
Gdx.gl = Gdx.gl30;
Gdx.gl20 = Gdx.gl30;
Gdx.files = new Lwjgl3Files();
Gdx.graphics = <minimal implementation of Graphics interface>
Gdx.app = <minimal implementation of Application interface>

// setup a scene and model batch

while (running) // See https://github.com/ValveSoftware/openvr/wiki/IVRCompositor_Overview
{
   // OpenVR waitGetPoses();
   // OpenVR poll events
   // OpenVR Submit eyes
}
GLFW.glfwDestroyWindow(windowHandle);
errorCallback.free();
errorCallback = null;
GLFW.glfwTerminate();
```

--------------------------------

### Example usage of localized string formatting

Source: https://libgdx.com/wiki/internationalization-and-localization

Demonstrates retrieving various localized strings with and without arguments.

```java
String game = myBundle.format("game");
String mission = myBundle.format("newMission", player.getName(), nextLevel.getName());
String coveredPath = myBundle.format("coveredPath", path.getPerc());
String highScoreTime = myBundle.format("highScoreTime", highScore.getDate());
```

--------------------------------

### Initialize Masking Resources

Source: https://libgdx.com/wiki/graphics/2d/masking

Setup the ShapeRenderer, SpriteBatch, BitmapFont, and FrameBuffer required for the masking process.

```java
private ShapeRenderer shapeRenderer;
private SpriteBatch spriteBatch;
private BitmapFont menuItemFont;
private FrameBuffer frameBuffer;
private float textWidth, textHeight, textX, textY;

@Override
public void create() {
    shapeRenderer = new ShapeRenderer();
    shapeRenderer.setAutoShapeType(true);

    spriteBatch = new SpriteBatch();

    menuItemFont = new BitmapFont();
    menuItemFont.getData().setScale(6f);

    int screenWidth = Gdx.graphics.getWidth();
    int screenHeight = Gdx.graphics.getHeight();

    GlyphLayout glyphLayout = new GlyphLayout();
    glyphLayout.setText(menuItemFont, "ONE PLAYER");

    textWidth = glyphLayout.width;
    textHeight = glyphLayout.height;
    textX = screenWidth / 2f - textWidth / 2f;
    textY = screenHeight / 2f + textHeight / 2f;

    frameBuffer = new FrameBuffer(Pixmap.Format.RGBA8888, screenWidth, screenHeight, false);
}
```

--------------------------------

### Configure Font Borders

Source: https://libgdx.com/wiki/extensions/gdx-freetype

Example settings for applying a border to generated font glyphs.

```java
parameter.borderColor = Color.BLACK;
parameter.borderWidth = 3;
```

--------------------------------

### Run Android Application

Source: https://libgdx.com/wiki/start/import-and-running

Installs the debug build and launches the Android application. Requires the ANDROID_HOME environment variable to be set.

```bash
./gradlew android:installDebug android:run
```

--------------------------------

### Initialize Masking Assets

Source: https://libgdx.com/wiki/graphics/2d/masking

Setup the SpriteBatch and load the mask and sprite textures required for the masking process.

```java
/* Some attributes we're gonna need. */
private SpriteBatch spriteBatch;
private Sprite mask, maskedSprite;

@Override
public void create() {
    spriteBatch = new SpriteBatch();

    /* Load the mask containing the alpha information. */
    mask = new Sprite(new Texture("mask.png"));

    /* Load the sprite which will be masked. */
    maskedSprite = new Sprite(new Texture("sprite.png"));
    maskedSprite.setColor(Color.RED);
}
```

--------------------------------

### Configure project dependencies in build.gradle

Source: https://libgdx.com/wiki/articles/dependency-management-with-gradle

Example of a complete project configuration including core libraries, native platforms, and local file dependencies.

```gradle
project(":android") {
    apply plugin: "android"

    configurations { natives }

    dependencies {
        coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:2.0.4'
        implementation "com.badlogicgames.gdx:gdx-backend-android:$gdxVersion"
        implementation project(':core')

        natives "com.badlogicgames.gdx:gdx-freetype-platform:$gdxVersion:natives-arm64-v8a"
        natives "com.badlogicgames.gdx:gdx-freetype-platform:$gdxVersion:natives-armeabi-v7a"
        natives "com.badlogicgames.gdx:gdx-freetype-platform:$gdxVersion:natives-x86"
        natives "com.badlogicgames.gdx:gdx-freetype-platform:$gdxVersion:natives-x86_64"
        natives "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-arm64-v8a"
        natives "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-armeabi-v7a"
        natives "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-x86"
        natives "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-x86_64"
        implementation fileTree(dir: 'libs', include: '*.jar')
    }
}
```

--------------------------------

### Configure and play background music

Source: https://libgdx.com/wiki/start/a-simple-game

Sets music to loop and adjusts volume before starting playback in the create method.

```java
@Override
public void create() {
    ...

    music.setLooping(true);
    music.setVolume(.5f);
    music.play();
}
```

--------------------------------

### Barebones jnigen Example

Source: https://libgdx.com/wiki/utils/jnigen

A complete Java class demonstrating native method declaration with inline C++ code and library loading.

```java
public class Example {
	// @off

	static public native int add (int a, int b); /*
		return a + b;
	*/

	public static void main (String[] args) throws Exception {
		new SharedLibraryLoader().load("my-native-lib");
		System.out.println(add(1, 2));
	}
}
```

--------------------------------

### Initialize Android application view

Source: https://libgdx.com/wiki/third-party/admob-in-libgdx

Internal setup logic for an Android application, including window configuration and content view assignment.

```java
    public void initialize(ApplicationListener listener, AndroidApplicationConfiguration config) {
   	 graphics = new AndroidGraphics(this, ...

...

       requestWindowFeature(Window.FEATURE_NO_TITLE);
       getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
       getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);
       setContentView(graphics.getView(), createLayoutParams());

...
```

--------------------------------

### Implementing InputProcessor for World Space Coordinates

Source: https://libgdx.com/wiki/input/mouse-touch-and-keyboard

A complete example demonstrating how to use an OrthographicCamera and ExtendViewport to translate screen-space touch or mouse input into world-space coordinates.

```java
public class SimplerTouchTest extends ApplicationAdapter implements InputProcessor {
	// we will use 32px/unit in world
	public final static float SCALE = 32f;
	public final static float INV_SCALE = 1.f/SCALE;
	// this is our "target" resolution, note that the window can be any size, it is not bound to this one
	public final static float VP_WIDTH = 1280 * INV_SCALE;
	public final static float VP_HEIGHT = 720 * INV_SCALE;

	private OrthographicCamera camera;
	private ExtendViewport viewport;		
	private ShapeRenderer shapes;

	@Override public void create () {
		camera = new OrthographicCamera();
		// pick a viewport that suits your thing, ExtendViewport is a good start
		viewport = new ExtendViewport(VP_WIDTH, VP_HEIGHT, camera);
		// ShapeRenderer so we can see our touch point
		shapes = new ShapeRenderer();
		Gdx.input.setInputProcessor(this);
	}

	@Override public void render () {
		Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
		shapes.setProjectionMatrix(camera.combined);
		shapes.begin(ShapeRenderer.ShapeType.Filled);
		shapes.circle(tp.x, tp.y, 0.25f, 16);
		shapes.end();
	}

	Vector3 tp = new Vector3();
	boolean dragging;
	@Override public boolean mouseMoved (int screenX, int screenY) {
		// we can also handle mouse movement without anything pressed
//		camera.unproject(tp.set(screenX, screenY, 0));
		return false;
	}

	@Override public boolean touchDown (int screenX, int screenY, int pointer, int button) {
		// ignore if its not left mouse button or first touch pointer
		if (button != Input.Buttons.LEFT || pointer > 0) return false;
		camera.unproject(tp.set(screenX, screenY, 0));
		dragging = true;
		return true;
	}

	@Override public boolean touchDragged (int screenX, int screenY, int pointer) {
		if (!dragging) return false;
		camera.unproject(tp.set(screenX, screenY, 0));
		return true;
	}

	@Override public boolean touchUp (int screenX, int screenY, int pointer, int button) {
		if (button != Input.Buttons.LEFT || pointer > 0) return false;
		camera.unproject(tp.set(screenX, screenY, 0));
		dragging = false;
		return true;
	}

	@Override public void resize (int width, int height) {
		// viewport must be updated for it to work properly
		viewport.update(width, height, true);
	}

	@Override public void dispose () {
		// disposable stuff must be disposed
		shapes.dispose();
	}

	@Override public boolean keyDown (int keycode) {
		return false;
	}

	@Override public boolean keyUp (int keycode) {
		return false;
	}

	@Override public boolean keyTyped (char character) {
		return false;
	}

	@Override public boolean scrolled (int amount) {
		return false;
	}

	public static void main (String[] args) {
		Lwjgl3ApplicationConfiguration config = new Lwjgl3ApplicationConfiguration();
		config.setWindowedMode(1280, 720);
		new Lwjgl3Application(new SimplerTouchTest(), config);
	}
}
```

--------------------------------

### Install MinGW on Arch Linux

Source: https://libgdx.com/wiki/utils/jnigen

Install the MinGW-w64 GCC compiler suite on Arch Linux.

```bash
sudo pacman -S mingw-w64-gcc
```

--------------------------------

### Initialize Desktop Application

Source: https://libgdx.com/wiki/app/the-application-framework

Instantiates the LWJGL 3 backend for desktop platforms.

```java
public class DesktopLauncher {
   public static void main(String[] args) {
      Lwjgl3ApplicationConfiguration config = new Lwjgl3ApplicationConfiguration();
      new Lwjgl3Application(new MyGdxGame(), config);
   }
}
```

--------------------------------

### Configure Initial LWJGL 3 Window

Source: https://libgdx.com/wiki/graphics/querying-and-configuring-graphics

Sets up the primary application window using Lwjgl3ApplicationConfiguration.

```java
Lwjgl3ApplicationConfiguration config = new Lwjgl3ApplicationConfiguration();
config.setWindowedMode(800, 600);
new Lwjgl3Application(new MyMainWindowListener(), config);
```

--------------------------------

### Embed a GWT example

Source: https://libgdx.com/wiki/misc/wiki-style-guide

Embed a libGDX example as an iframe by specifying the directory path and container dimensions.

```html
{% include embed-gwt.html dir='viewport-example' width="800" height="500" %}
```

--------------------------------

### Install MinGW on Fedora/CentOS/RHEL

Source: https://libgdx.com/wiki/utils/jnigen

Install the required MinGW compiler and thread support packages for Fedora and RHEL-based systems.

```bash
sudo dnf install mingw32-gcc-c++ mingw64-gcc-c++ mingw32-winpthreads-static mingw64-winpthreads-static
```

--------------------------------

### Install MinGW on Ubuntu

Source: https://libgdx.com/wiki/utils/jnigen

Install the necessary MinGW cross-compilers for 32-bit and 64-bit Windows targets on Debian-based systems.

```bash
sudo apt-get install g++-mingw-w64-i686 g++-mingw-w64-x86-64
```

--------------------------------

### Implement desktop launcher in desktop_launcher.clj

Source: https://libgdx.com/wiki/jvm-langs/using-libgdx-with-clojure

Initializes the LwjglApplication and enables keyboard repeat events.

```clojure
(ns demo.core.desktop-launcher
  (:require [demo.core :refer :all])
  (:import [com.badlogic.gdx.backends.lwjgl LwjglApplication]
           [org.lwjgl.input Keyboard])
  (:gen-class))

(defn -main []
  (LwjglApplication. (demo.core.Game.) "demo" 800 600)
  (Keyboard/enableRepeatEvents true))
```

--------------------------------

### Define a basic game screen and game object

Source: https://libgdx.com/wiki/jvm-langs/using-libgdx-with-clojure

This core.clj file demonstrates setting up a main screen with a label and initializing the game object.

```clojure
(ns hello-world.core
  (:require [play-clj.core :refer :all]
            [play-clj.ui :refer :all]))

(defscreen main-screen
  :on-show
  (fn [screen entities]
    (update! screen :renderer (stage))
    (label "Hello world!" (color :white)))

  :on-render
  (fn [screen entities]
    (clear!)
    (render! screen entities)))

(defgame hello-world
  :on-create
  (fn [this]
    (set-screen! this main-screen)))
```

--------------------------------

### Get Touch Coordinates

Source: https://libgdx.com/wiki/input/polling

Retrieves the screen coordinates for specific pointer indices.

```java
int firstX = Gdx.input.getX();
int firstY = Gdx.input.getY();
int secondX = Gdx.input.getX(1);
int secondY = Gdx.input.getY(1);
```

--------------------------------

### Querying Layer Dimensions

Source: https://libgdx.com/wiki/graphics/2d/tile-maps

Get the number of horizontal and vertical tiles in a layer.

```java
int columns = tileLayer.getWidth();
int rows = tileLayer.getHeight();
```

--------------------------------

### Initialize a new libGDX Scala project

Source: https://libgdx.com/wiki/jvm-langs/using-libgdx-with-scala

Use the Giter8 template to generate a new project structure.

```bash
$ sbt new ajhager/libgdx-sbt-project.g8
```

--------------------------------

### Initiate Picture Capture Process

Source: https://libgdx.com/wiki/graphics/integrating-libgdx-and-the-device-camera

Triggers the camera configuration and starts the autofocus process.

```java
	@Override
	public synchronized void takePicture() {
		// the user request to take a picture - start the process by requesting focus
	    	setCameraParametersForPicture(cameraSurface.getCamera());
	    	cameraSurface.getCamera().autoFocus(this);
	}
```

--------------------------------

### ccache Wrapper Script

Source: https://libgdx.com/wiki/utils/jnigen

Example content for a compiler wrapper script that invokes ccache.

```bash
echo "g++ ccache!"
ccache /usr/bin/g++ "$@"
```

--------------------------------

### Run desktop project

Source: https://libgdx.com/wiki/jvm-langs/using-libgdx-with-scala

Execute the desktop application target.

```sbt
> desktop/run
```

--------------------------------

### Run Desktop Application

Source: https://libgdx.com/wiki/start/import-and-running

Executes the LWJGL3 desktop target using the Gradle wrapper.

```bash
./gradlew lwjgl3:run
```

--------------------------------

### Define Data Classes for Serialization

Source: https://libgdx.com/wiki/utils/reading-and-writing-json

Example classes used for demonstrating object graph serialization.

```java
public class Person {
   private String name;
   private int age;
   private ArrayList numbers;
}

public class PhoneNumber {
   private String name;
   private String number;
}
```

--------------------------------

### Initialize a basic scene2d.ui application with a root table

Source: https://libgdx.com/wiki/graphics/2d/scene2d/scene2d-ui

Sets up a stage and a root table configured to fill the parent, providing a foundation for UI layouts.

```java
private Stage stage;
private Table table;

public void create () {
	stage = new Stage();
	Gdx.input.setInputProcessor(stage);

	table = new Table();
	table.setFillParent(true);
	stage.addActor(table);

	table.setDebug(true); // This is optional, but enables debug lines for tables.

	// Add widgets to the table here.
}

public void resize (int width, int height) {
	stage.getViewport().update(width, height, true);
}

public void render () {
	Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
	stage.act(Gdx.graphics.getDeltaTime());
	stage.draw();
}

public void dispose() {
	stage.dispose();
}
```

--------------------------------

### Define HelloWorldDesktop entry point

Source: https://libgdx.com/wiki/third-party/admob-in-libgdx

Standard desktop application entry point for a libGDX project.

```java
public class HelloWorldDesktop {
    public static void main (String[] argv) {
        new LwjglApplication(new HelloWorld(), "Hello World", 480, 320, false);
    }
}
```

--------------------------------

### Render ImGui UI Element

Source: https://libgdx.com/wiki/graphics/2d/imgui

Example of rendering a simple button within the ImGui frame.

```java
ImGui.button("I'm a Button!");
```

--------------------------------

### Configure Font Shadows

Source: https://libgdx.com/wiki/extensions/gdx-freetype

Example settings for applying a drop shadow to generated font glyphs.

```java
parameter.shadowColor = Color.BLACK;
parameter.shadowOffsetX = 3;
parameter.shadowOffsetY = 3;
```

--------------------------------

### Initialize and update a basic Stage with ScreenViewport

Source: https://libgdx.com/wiki/graphics/2d/scene2d/scene2d

Sets up a stage using ScreenViewport where units correspond to pixels, and demonstrates the required resize and render lifecycle methods.

```java
private Stage stage;

public void create () {
	stage = new Stage(new ScreenViewport());
	Gdx.input.setInputProcessor(stage);
}

public void resize (int width, int height) {
	// See below for what true means.
	stage.getViewport().update(width, height, true);
}

public void render () {
	float delta = Gdx.graphics.getDeltaTime();
	Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
	stage.act(delta);
	stage.draw();
}

public void dispose () {
	stage.dispose();
}
```

--------------------------------

### Initialize a play-clj project

Source: https://libgdx.com/wiki/jvm-langs/using-libgdx-with-clojure

Use this command to generate a new project structure with Leiningen.

```bash
lein new play-clj hello-world
```

--------------------------------

### Implement desktop and HTML5 leaderboard

Source: https://libgdx.com/wiki/app/interfacing-with-platform-specific-code

Provide mock implementations for desktop and HTML5 targets using logging.

```java
/** Desktop implementation, we simply log invocations **/
public class Lwjgl3Leaderboard implements Leaderboard {
   public void submitScore(String user, int score) {
      Gdx.app.log("Lwjgl3Leaderboard", "would have submitted score for user " + user + ": " + score);
   }
}
```

```java
/** Html5 implementation, same as Lwjgl3Leaderboard **/
public class Html5Leaderboard implements Leaderboard {
   public void submitScore(String user, int score) {
      Gdx.app.log("Html5Leaderboard", "would have submitted score for user " + user + ": " + score);
   }
}
```

--------------------------------

### Initialize ParticleSystem and Batches

Source: https://libgdx.com/wiki/graphics/3d/3d-particle-effects

Create a ParticleSystem and the corresponding batch renderer for the desired particle type.

```java
ParticleSystem particleSystem = new ParticleSystem();
// Since our particle effects are PointSprites, we create a PointSpriteParticleBatch
PointSpriteParticleBatch pointSpriteBatch = new PointSpriteParticleBatch();
pointSpriteBatch.setCamera(cam);
particleSystem.add(pointSpriteBatch);
```

--------------------------------

### Initialize ShapeRenderer for Masking

Source: https://libgdx.com/wiki/graphics/2d/masking

Setup the ShapeRenderer and OpenGL line thickness before rendering masked elements.

```java
private ShapeRenderer shapeRenderer;

@Override
public void create() {
    /* We can use a SpriteBatch or a ShapeRenderer to draw our masked elements. */
    shapeRenderer = new ShapeRenderer();
    shapeRenderer.setAutoShapeType(true);

    /* Increase the OpenGL line thickness for better visualization. */
    Gdx.gl.glLineWidth(2);
}
```

--------------------------------

### Initialize a Viewport

Source: https://libgdx.com/wiki/graphics/viewports

Create a camera and associate it with a Viewport instance during initialization.

```java
    private Viewport viewport;
    private Camera camera;

    public void create() {
        camera = new PerspectiveCamera();
        viewport = new FitViewport(800, 480, camera);
    }
```

--------------------------------

### Run Desktop test suite

Source: https://libgdx.com/wiki/misc/building-the-bullet-wrapper

Executes the desktop test suite using the Gradle wrapper.

```bash
gradlew tests:gdx-tests-lwjgl
```

--------------------------------

### Handle Gradle manifest merger error

Source: https://libgdx.com/wiki/third-party/google-play-games-services-in-libgdx

Example of the error message encountered when minSdkVersion is incompatible with the library.

```text
Error:Execution failed for task ':android:processDebugManifest'.
> Manifest merger failed : uses-sdk:minSdkVersion 9 cannot be smaller than version 15 declared in library [libgdx-GPGS:BaseGameUtils:1.0]
```

--------------------------------

### Build Desktop Runnable JAR

Source: https://libgdx.com/wiki/articles/maven-integration

Creates a JAR file containing all dependencies, assets, and a manifest.

```bash
mvn -Pdesktop package
```

--------------------------------

### Initialize and use SpriteBatch

Source: https://libgdx.com/wiki/graphics/2d/spritebatch-textureregions-and-sprites

Demonstrates the basic lifecycle of a SpriteBatch within an ApplicationAdapter.

```java
public class Game implements ApplicationAdapter {
	private SpriteBatch batch;

	public void create () {
		batch = new SpriteBatch();
	}

	public void render () {
		ScreenUtils.clear(Color.DARK_GRAY);
		batch.begin();
		// Drawing goes here!
		batch.end();
	}
}
```

--------------------------------

### Configure Android dependencies

Source: https://libgdx.com/wiki/articles/dependency-management-with-gradle

Example of a dependencies block for an Android project, including native library declarations.

```gradle
dependencies {
    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:2.0.4'
    implementation "com.badlogicgames.gdx:gdx-backend-android:$gdxVersion"
    implementation project(':core')

    natives "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-arm64-v8a"
    natives "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-armeabi-v7a"
    natives "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-x86"
    natives "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-x86_64"
}
```

--------------------------------

### Get Rotation Matrix

Source: https://libgdx.com/wiki/input/accelerometer

Obtain a rotation matrix based on device orientation for use in OpenGL rendering.

```java
Matrix4 matrix = new Matrix4();
Gdx.input.getRotationMatrix(matrix.val);
// use the matrix, Luke
```

--------------------------------

### Initialize and Use ModelBatch

Source: https://libgdx.com/wiki/graphics/3d/modelbatch

Demonstrates the standard lifecycle of a ModelBatch instance, including creation, rendering within the frame loop, and disposal.

```java
    ModelBatch modelBatch;
    ...

    @Override
    public void create () {
        modelBatch = new ModelBatch();
        ...
    }

    @Override
    public void render () {
        ... // call glClear etc.
        modelBatch.begin(camera);
        modelBatch.render(...);
        ... // add other render calls
        modelBatch.end();
        ...
    }

    @Override
    public void dispose () {
        modelBatch.dispose();
        ...
    }
```

--------------------------------

### Configure OrthographicCamera in create method

Source: https://libgdx.com/wiki/graphics/2d/orthographic-camera

Initialize the camera with specific viewport dimensions and aspect ratio to maintain correct proportions.

```java
@Override
public void create() {
	rotationSpeed = 0.5f;                                                    #1

	mapSprite = new Sprite(new Texture(Gdx.files.internal("sc_map.png")));   #2
	mapSprite.setPosition(0, 0);                                             #3
	mapSprite.setSize(WORLD_WIDTH, WORLD_HEIGHT);                            #4

	float w = Gdx.graphics.getWidth();                                       #5
	float h = Gdx.graphics.getHeight();                                      #6
	cam = new OrthographicCamera(30, 30 * (h / w));                          #7
	cam.position.set(cam.viewportWidth / 2f, cam.viewportHeight / 2f, 0);    #8
	cam.update();                                                            #9

	batch = new SpriteBatch();                                               #10
}
```

--------------------------------

### Initialize rendering components

Source: https://libgdx.com/wiki/start/a-simple-game

Instantiate the SpriteBatch and FitViewport within the create method.

```java
@Override
public void create() {
    ...

    spriteBatch = new SpriteBatch();
    viewport = new FitViewport(8, 5);
}
```

--------------------------------

### Include Local Maven Dependency in Gradle

Source: https://libgdx.com/wiki/articles/dependency-management-with-gradle

Add the installed local dependency to the core project configuration in build.gradle.

```gradle
project(":core") {
   ...

    dependencies {
        ...
        implementation "<group-id>:<artifact-id>:<version>"
        implementation "<group-id>:<artifact-id>:<version>:sources"
    }
}
```

--------------------------------

### Configure Activity Window

Source: https://libgdx.com/wiki/third-party/admob-in-libgdx

Set the activity to full-screen mode before initializing the game view.

```java
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, 
        		WindowManager.LayoutParams.FLAG_FULLSCREEN);
        getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);

        View gameView = initializeForView(new HelloWorld(), false);
```

--------------------------------

### Initialize Texture Assets

Source: https://libgdx.com/wiki/start/a-simple-game

Load image files into memory as textures within the create method after the application has started.

```java
@Override
public void create() {
    backgroundTexture = new Texture("background.png");
    bucketTexture = new Texture("bucket.png");
    dropTexture = new Texture("drop.png");
}
```

--------------------------------

### Package desktop project

Source: https://libgdx.com/wiki/jvm-langs/using-libgdx-with-scala

Create a single executable JAR file for the desktop project.

```sbt
> assembly
```

--------------------------------

### Initialize Sprite

Source: https://libgdx.com/wiki/start/a-simple-game

Set up the sprite size and texture within the create method.

```java
@Override
public void create() {
    ...
    bucketSprite = new Sprite(bucketTexture); // Initialize the sprite based on the texture
    bucketSprite.setSize(1, 1); // Define the size of the sprite
}
```

--------------------------------

### Implement OrthographicCamera in a libGDX Application

Source: https://libgdx.com/wiki/graphics/2d/orthographic-camera

A complete example demonstrating camera movement, rotation, and zooming within a 2D world.

```java
import com.badlogic.gdx.ApplicationListener;
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.Texture;
import com.badlogic.gdx.graphics.g2d.Sprite;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.math.MathUtils;

public class OrthographicCameraExample implements ApplicationListener {

	static final int WORLD_WIDTH = 100;
	static final int WORLD_HEIGHT = 100;

	private OrthographicCamera cam;
	private SpriteBatch batch;

	private Sprite mapSprite;
	private float rotationSpeed;

	@Override
	public void create() {
		rotationSpeed = 0.5f;

		mapSprite = new Sprite(new Texture(Gdx.files.internal("sc_map.png")));
		mapSprite.setPosition(0, 0);
		mapSprite.setSize(WORLD_WIDTH, WORLD_HEIGHT);

		float w = Gdx.graphics.getWidth();
		float h = Gdx.graphics.getHeight();

		// Constructs a new OrthographicCamera, using the given viewport width and height
		// Height is multiplied by aspect ratio.
		cam = new OrthographicCamera(30, 30 * (h / w));

		cam.position.set(cam.viewportWidth / 2f, cam.viewportHeight / 2f, 0);
		cam.update();

		batch = new SpriteBatch();
	}

	@Override
	public void render() {
		handleInput();
		cam.update();
		batch.setProjectionMatrix(cam.combined);

		Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

		batch.begin();
		mapSprite.draw(batch);
		batch.end();
	}

	private void handleInput() {
		if (Gdx.input.isKeyPressed(Input.Keys.A)) {
			cam.zoom += 0.02;
		}
		if (Gdx.input.isKeyPressed(Input.Keys.Q)) {
			cam.zoom -= 0.02;
		}
		if (Gdx.input.isKeyPressed(Input.Keys.LEFT)) {
			cam.translate(-3, 0, 0);
		}
		if (Gdx.input.isKeyPressed(Input.Keys.RIGHT)) {
			cam.translate(3, 0, 0);
		}
		if (Gdx.input.isKeyPressed(Input.Keys.DOWN)) {
			cam.translate(0, -3, 0);
		}
		if (Gdx.input.isKeyPressed(Input.Keys.UP)) {
			cam.translate(0, 3, 0);
		}
		if (Gdx.input.isKeyPressed(Input.Keys.W)) {
			cam.rotate(-rotationSpeed, 0, 0, 1);
		}
		if (Gdx.input.isKeyPressed(Input.Keys.E)) {
			cam.rotate(rotationSpeed, 0, 0, 1);
		}

		cam.zoom = MathUtils.clamp(cam.zoom, 0.1f, 100/cam.viewportWidth);

		float effectiveViewportWidth = cam.viewportWidth * cam.zoom;
		float effectiveViewportHeight = cam.viewportHeight * cam.zoom;

		cam.position.x = MathUtils.clamp(cam.position.x, effectiveViewportWidth / 2f, 100 - effectiveViewportWidth / 2f);
		cam.position.y = MathUtils.clamp(cam.position.y, effectiveViewportHeight / 2f, 100 - effectiveViewportHeight / 2f);
	}

	@Override
	public void resize(int width, int height) {
		cam.viewportWidth = 30f;
		cam.viewportHeight = 30f * height/width;
		cam.update();
	}

	@Override
	public void resume() {
	}

	@Override
	public void dispose() {
		mapSprite.getTexture().dispose();
		batch.dispose();
	}

	@Override
	public void pause() {
	}

}
```

--------------------------------

### Configure Windowed Mode and Position (LWJGL 3)

Source: https://libgdx.com/wiki/graphics/querying-and-configuring-graphics

Sets the initial window dimensions and screen position.

```java
Lwjgl3ApplicationConfiguration config = new Lwjgl3ApplicationConfiguration();
config.setWindowedMode(800, 600);
```

```java
config.setWindowPosition(100, 100);
```

--------------------------------

### Define Plural Forms with ChoiceFormat

Source: https://libgdx.com/wiki/internationalization-and-localization

Example of a properties file entry using the choice format to handle different plural counts.

```properties
collectedCoins=You collected {0,choice,0#no coins|1#one coin|1<{0,number,integer} coins|100<hundreds of coins} along the path.
```

--------------------------------

### Generate Distance Field Image with Options

Source: https://libgdx.com/wiki/graphics/2d/fonts/distance-field-fonts

Example command to generate a distance field image with specific downscale and spread parameters.

```bash
java -cp extensions/gdx-tools.jar:gdx.jar com.badlogic.gdx.tools.distancefield.DistanceFieldGenerator
     --downscale 32
     --spread 128
     logo.png logo-df.png
```

--------------------------------

### Initialize AndroidLauncher with RelativeLayout

Source: https://libgdx.com/wiki/third-party/smaato-in-libgdx

Sets up the AndroidLauncher to host both the LibGDX game view and an ad view within a RelativeLayout.

```java
public class AndroidLauncher extends AndroidApplication {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        RelativeLayout layout = new RelativeLayout(this);
        layout.setLayoutParams(new RelativeLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT));
        layout.addView(createGameView());
        createAdView(layout);
        setContentView(layout);
    }

    private View createGameView() {
        View gameView = initializeForView(new MyGame(this), new AndroidApplicationConfiguration());
        RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(MATCH_PARENT, WRAP_CONTENT);
        params.addRule(RelativeLayout.ALIGN_PARENT_TOP, RelativeLayout.TRUE);
        params.addRule(RelativeLayout.CENTER_HORIZONTAL, RelativeLayout.TRUE);
        gameView.setLayoutParams(params);
        return gameView;
    }
}
```

--------------------------------

### Run iOS project

Source: https://libgdx.com/wiki/jvm-langs/using-libgdx-with-scala

Launch the iOS application on a connected device.

```sbt
> ios/device
```

--------------------------------

### Prepare Camera Surface

Source: https://libgdx.com/wiki/graphics/integrating-libgdx-and-the-device-camera

Initializes the CameraSurface and adds it to the activity content view.

```java
	@Override
	public void prepareCamera() {
		if (cameraSurface == null) {
			cameraSurface = new CameraSurface(activity);
		}
		activity.addContentView( cameraSurface, new LayoutParams( LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT ) );
	}
```
Tokens:
Raw