VR-приложение с нуля на libgdx: часть 1

package com.sinuxvr.sample;
import com.badlogic.gdx.math.Quaternion;
/** Интерфейс для взаимодействия с платформо-зависимым кодом */
interface VRSensorManager {
    /** Проверка наличия гироскопа */
    boolean isGyroAvailable();
    /** Проверка наличия магнитометра */
    boolean isMagAvailable();
    /** Регистрация листенеров */
    void startTracking();
    /** Отключение листенеров */
    void endTracking();
    /** Включение-выключение коррекции дрифта на лету
     * @param use - true - включено, false - отключено */
    void useDriftCorrection(boolean use);
    /** Получение вычисленного кватерниона ориентации головы
     * @return кватернион для вращения камеры */
    Quaternion getHeadQuaternion();
}

package com.sinuxvr.sample;

import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.math.MathUtils;
import com.badlogic.gdx.math.Quaternion;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.math.Vector3;

/** Реализация листенера датчиков под Android. Вычисляет и предоставляет готовый кватернион
 * ориентации устройства в пространстве для камеры в зависимости от имеющихся датчиков в телефоне.
 * Поддерживаемые варианты: акселерометр, акселерометр + магнитометр, гироскоп + акселерометр,
 * гироскоп + акселерометр + магнитометр */

class VRSensorManagerAndroid implements VRSensorManager {

    /** Перечень режимов работы в зависимости от наличия датчиков */
    private enum VRControlMode { ACC_ONLY, ACC_GYRO, ACC_MAG, ACC_GYRO_MAG }

    private SensorManager sensorManager;                // Сенсорный менеджер
    private SensorEventListener accelerometerListener;  // Листенер акселерометра
    private SensorEventListener gyroscopeListener;      // Листенер гироскопа
    private SensorEventListener compassListener;        // Листенер магнитометра
    private Context context;                            // Контекст приложения

    /** Массивы для получения данных */
    private final float[] accelerometerValues = new float[3];   // Акселерометр
    private final float[] gyroscopeValues = new float[3];       // Гироскоп
    private final float[] magneticFieldValues = new float[3];   // Магнитометр
    private final boolean gyroAvailable;                        // Флаг наличия гироскопа
    private final boolean magAvailable;                         // Флаг наличия магнитометра
    private volatile boolean useDC;                             // Использовать ли магнитометр

    /** Кватернионы и векторы для нахождения ориентации, итоговый результат в headOrientation */
    private final Quaternion gyroQuaternion;
    private final Quaternion deltaQuaternion;
    private final Vector3 accInVector;
    private final Vector3 accInVectorTilt;
    private final Vector3 magInVector;
    private final Quaternion headQuaternion;
    private VRControlMode vrControlMode;

    /** Конструктор */
    VRSensorManagerAndroid(Context context) {
        this.context = context;
        // Получение сенсорного менеджера
        sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);

        // Проверка наличия датчиков (акселерометр есть всегда 100%, наверное)
        magAvailable = (sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD) != null);
        gyroAvailable = (sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE) != null);
        useDC = false;

        // Определение режима работы в зависимости от имеющихся датчиков
        vrControlMode = VRControlMode.ACC_ONLY;
        if (gyroAvailable) vrControlMode = VRControlMode.ACC_GYRO;
        if (magAvailable) vrControlMode = VRControlMode.ACC_MAG;
        if (gyroAvailable && magAvailable) vrControlMode = VRControlMode.ACC_GYRO_MAG;

        // Инициализация кватернионов
        gyroQuaternion = new Quaternion(0, 0, 0, 1);
        deltaQuaternion = new Quaternion(0, 0, 0, 1);
        accInVector = new Vector3(0, 10, 0);
        accInVectorTilt = new Vector3(0, 0, 0);
        magInVector = new Vector3(1, 0, 0);
        headQuaternion = new Quaternion(0, 0, 0, 1);

        // Регистрация датчиков
        startTracking();
    }

    /** Возврат наличия гироскопа */
    @Override
    public boolean isGyroAvailable() {
        return gyroAvailable;
    }

    /** Возврат наличия магнитометра */
    @Override
    public boolean isMagAvailable() {
        return magAvailable;
    }

    /** Старт трекинга - регистрация листенеров */
    @Override
    public void startTracking() {
        // Акселерометр инициализируется при любом раскладе
        sensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
        Sensor accelerometer = sensorManager.getSensorList(Sensor.TYPE_ACCELEROMETER).get(0);
        accelerometerListener = new SensorListener(this.accelerometerValues, this.magneticFieldValues, this.gyroscopeValues);
        sensorManager.registerListener(accelerometerListener, accelerometer, SensorManager.SENSOR_DELAY_GAME);
        // Магнитометр
        if (magAvailable) {
            sensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
            Sensor compass = sensorManager.getSensorList(Sensor.TYPE_MAGNETIC_FIELD).get(0);
            compassListener = new SensorListener(this.accelerometerValues, this.magneticFieldValues, this.gyroscopeValues);
            sensorManager.registerListener(compassListener, compass, SensorManager.SENSOR_DELAY_GAME);
        }
        // Гироскоп
        if (gyroAvailable) {
            sensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
            Sensor gyroscope = sensorManager.getSensorList(Sensor.TYPE_GYROSCOPE).get(0);
            gyroscopeListener = new SensorListener(this.gyroscopeValues, this.magneticFieldValues, this.gyroscopeValues);
            sensorManager.registerListener(gyroscopeListener, gyroscope, SensorManager.SENSOR_DELAY_GAME);
        }
    }

    /** Остановка трекинга - отключение листенеров */
    @Override
    public void endTracking() {
        if (sensorManager != null) {
            if (accelerometerListener != null) {
                sensorManager.unregisterListener(accelerometerListener);
                accelerometerListener = null;
            }
            if (gyroscopeListener != null) {
                sensorManager.unregisterListener(gyroscopeListener);
                gyroscopeListener = null;
            }
            if (compassListener != null) {
                sensorManager.unregisterListener(compassListener);
                compassListener = null;
            }
            sensorManager = null;
        }
    }

    /** Включение-выключение использования магнитометра на лету */
    @Override
    public void useDriftCorrection(boolean useDC) {
        // Реально листенер магнитометра не отключается, просто игнорируем его при вычислениях
        this.useDC = useDC;
    }

    /** Вычисление и возврат кватерниона ориентации */
    @Override
    public synchronized Quaternion getHeadQuaternion() {
        // Выбираем последовательность действий в зависимости от режима управления
        switch (vrControlMode) {
            // Управление одним акселерометром
            case ACC_ONLY: updateAccData(0.1f);
                // Вращение по Yaw наклонами головы из стороны в сторону (как во всяких гонках)
                headQuaternion.setFromAxisRad(0, 1, 0, -MathUtils.sin(accelerometerValues[0] / 200f)).mul(gyroQuaternion).nor();
                gyroQuaternion.set(headQuaternion);
                break;

            // Акселерометр + магнитометр (если в телефоне стоит вменяемый компас, то данная комбинация
            // ведет себя почти как гироскоп, получается этакая эмуляция гиро)
            case ACC_MAG: updateAccData(0.2f);
                if (!useDC) {
                    headQuaternion.setFromAxisRad(0, 1, 0, -MathUtils.sin(accelerometerValues[0] / 200f)).mul(gyroQuaternion).nor();
                    gyroQuaternion.set(headQuaternion);
                } else updateMagData(1f, 0.05f);
                break;

            // Гироскоп + акселерометр
            case ACC_GYRO: updateGyroData(0.1f);
                updateAccData(0.02f);
                break;

            // Все три датчика - must have, но только если компас откалиброван
            case ACC_GYRO_MAG: float dQLen = updateGyroData(0.1f);
                updateAccData(0.02f);
                if (useDC) updateMagData(dQLen, 0.005f);
        }

        return headQuaternion;
    }

    /** Логика определения ориентации
     * Интегрирование показаний гироскопа в кватернион
     * @param driftThreshold - порог для отсечения дрифта покоя
     * @return - длина кватерниона deltaQuaternion */
    private synchronized float updateGyroData(float driftThreshold) {
        float wX = gyroscopeValues[0];
        float wY = gyroscopeValues[1];
        float wZ = gyroscopeValues[2];

        // Интегрирование показаний гироскопа
        float l = Vector3.len(wX, wY, wZ);
        float dtl2 = Gdx.graphics.getDeltaTime() * l * 0.5f;
        if (l > driftThreshold) {
            float sinVal = MathUtils.sin(dtl2) / l;
            deltaQuaternion.set(sinVal * wX, sinVal * wY, sinVal * wZ, MathUtils.cos(dtl2));
        } else deltaQuaternion.set(0, 0, 0, 1);
        gyroQuaternion.mul(deltaQuaternion);
        return l;
    }

    /** Коррекция Tilt при помощи акселерометра
     * @param filterAlpha - коэффициент фильтрации */
    private synchronized void updateAccData(float filterAlpha) {
        // Преобразование значений акселерометра в инерциальные координаты
        accInVector.set(accelerometerValues[0], accelerometerValues[1], accelerometerValues[2]);
        gyroQuaternion.transform(accInVector);
        accInVector.nor();

        // Вычисление нормализованной оси вращения между accInVector и UP(0, 1, 0)
        float xzLen = 1f / Vector2.len(accInVector.x, accInVector.z);
        accInVectorTilt.set(-accInVector.z * xzLen, 0, accInVector.x * xzLen);

        // Вычисление угла между вектором accInVector и UP(0, 1, 0)
        float fi = (float)Math.acos(accInVector.y);

        // Получение Tilt-скорректированного кватерниона по данным акселерометра
        headQuaternion.setFromAxisRad(accInVectorTilt, filterAlpha * fi).mul(gyroQuaternion).nor();
        gyroQuaternion.set(headQuaternion);
    }

    /** Коррекция угла по Yaw магнитометром
     * @param dQLen - длина кватерниона deltaQuaternion
     * @param filterAlpha - коэффициент фильтрации
     * Коррекция производится только в движении */
    private synchronized void updateMagData(float dQLen, float filterAlpha) {
        // Проверка длины deltaQuaternion для коррекции только в движении
        if (dQLen < 0.1f) return;
        // Преобразование значений магнитометра в инерциальные координаты
        magInVector.set(magneticFieldValues[0], magneticFieldValues[1], magneticFieldValues[2]);
        gyroQuaternion.transform(magInVector);

        // Вычисление корректирующего Yaw угла с магнитометра
        float theta = MathUtils.atan2(magInVector.z, magInVector.x);

        // Коррекция ориентации
        headQuaternion.setFromAxisRad(0, 1, 0, filterAlpha * theta).mul(gyroQuaternion).nor();
        gyroQuaternion.set(headQuaternion);
    }

    /** Своя имплементация класса сенсорного листенера (копипаст из AndroidInput) */
    private class SensorListener implements SensorEventListener {
        final float[] accelerometerValues;
        final float[] magneticFieldValues;
        final float[] gyroscopeValues;

        SensorListener (float[] accelerometerValues, float[] magneticFieldValues, float[] gyroscopeValues) {
            this.accelerometerValues = accelerometerValues;
            this.magneticFieldValues = magneticFieldValues;
            this.gyroscopeValues = gyroscopeValues;
        }

        // Смена точности (нас не интересует)
        @Override
        public void onAccuracyChanged (Sensor arg0, int arg1) { }

        // Получение данных от датчиков
        @Override
        public synchronized void onSensorChanged (SensorEvent event) {
            if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
                accelerometerValues[0] = -event.values[1];
                accelerometerValues[1] = event.values[0];
                accelerometerValues[2] = event.values[2];
            }
            if (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) {
                magneticFieldValues[0] = -event.values[1];
                magneticFieldValues[1] = event.values[0];
                magneticFieldValues[2] = event.values[2];
            }
            if (event.sensor.getType() == Sensor.TYPE_GYROSCOPE) {
                gyroscopeValues[0] = -event.values[1];
                gyroscopeValues[1] = event.values[0];
                gyroscopeValues[2] = event.values[2];
            }
        }
    }
}

package com.sinuxvr.sample;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.PerspectiveCamera;
import com.badlogic.gdx.math.Matrix4;
import com.badlogic.gdx.math.Quaternion;
import com.badlogic.gdx.math.Vector3;

/** Класс VR камеры
 * Данные об ориентации берутся из VRSensorManager при вызове update() */

class VRCamera {
    private PerspectiveCamera leftCam;   // Левая камера
    private PerspectiveCamera rightCam;  // Правая камера
    private Vector3 position;            // Позиция VR камеры
    private float parallax;              // Расстояние между камерами
    private Vector3 direction;           // Вектор направления VR камеры
    private Vector3 up;                  // Вектор UP VR камеры
    private Vector3 upDirCross;          // Векторное произведение up и direction (понадобится в части 2, сейчас не трогаем)

    /** Конструктор */
    VRCamera(float fov, float parallax, float near, float far) {
        this.parallax = parallax;
        leftCam = new PerspectiveCamera(fov, Gdx.graphics.getWidth() / 2, Gdx.graphics.getHeight());
        leftCam.near = near;
        leftCam.far = far;
        leftCam.update();
        rightCam = new PerspectiveCamera(fov, Gdx.graphics.getWidth() / 2, Gdx.graphics.getHeight());
        rightCam.near = near;
        rightCam.far = far;
        rightCam.update();
        position = new Vector3(0, 0, 0);
        direction = new Vector3(0, 0, 1);
        up = new Vector3(0, 1, 0);
        upDirCross = new Vector3().set(direction).crs(up).nor();
    }

    /** Обновление ориентации камеры */
    void update() {
        Quaternion headQuaternion = GdxVR.vrSensorManager.getHeadQuaternion();

        // Из-за обхода стандартного механизма вращения камеры необходимо вручную
        // получать векторы ее направления из кватерниона
        direction.set(0, 0, 1);
        headQuaternion.transform(direction);
        up.set(0, 1, 0);
        headQuaternion.transform(up);
        upDirCross.set(direction);
        upDirCross.crs(up).nor();

        // Вычисление углов вращения камер из кватерниона
        float angle = 2 * (float)Math.acos(headQuaternion.w);
        float s = 1f / (float)Math.sqrt(1 - headQuaternion.w * headQuaternion.w);
        float vx = headQuaternion.x * s;
        float vy = headQuaternion.y * s;
        float vz = headQuaternion.z * s;

        // Вращение левой камеры
        leftCam.view.idt(); // Сброс матрицы вида
        leftCam.view.translate(parallax, 0, 0); // Перенос в начало координат + parallax по X
        leftCam.view.rotateRad(vx, vy, vz, -angle); // Поворот кватернионом
        leftCam.view.translate(-position.x, -position.y, -position.z); // Смещение в position
        leftCam.combined.set(leftCam.projection);
        Matrix4.mul(leftCam.combined.val, leftCam.view.val);

        // Вращение правой камеры
        rightCam.view.idt(); // Сброс матрицы вида
        rightCam.view.translate(-parallax, 0, 0); // Перенос в начало координат + parallax по X
        rightCam.view.rotateRad(vx, vy, vz, -angle); // Поворот кватернионом
        rightCam.view.translate(-position.x, -position.y, -position.z); // Смещение в position
        rightCam.combined.set(rightCam.projection);
        Matrix4.mul(rightCam.combined.val, rightCam.view.val);
    }

    /** Изменение местоположения камеры */
    void setPosition(float x, float y, float z) {
        position.set(x, y, z);
    }

    /** Возврат левой камеры */
    PerspectiveCamera getLeftCam() {
        return leftCam;
    }

    /** Возврат правой камеры */
    PerspectiveCamera getRightCam() {
        return rightCam;
    }

    /** Возврат позиции, направления и вектора UP камеры, а так же их векторного произведения*/
    public Vector3 getPosition() { return position; }
    public Vector3 getDirection() { return direction; }
    public Vector3 getUp() { return up; }
    public Vector3 getUpDirCross() { return upDirCross; }
}

package com.sinuxvr.sample;

import android.os.Bundle;
import com.badlogic.gdx.backends.android.AndroidApplication;
import com.badlogic.gdx.backends.android.AndroidApplicationConfiguration;

public class AndroidLauncher extends AndroidApplication {

	private VRSensorManagerAndroid vrSensorManagerAndroid;    // Менеджер датчиков

	/** Инициализация приложения */
	@Override
	protected void onCreate (Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		AndroidApplicationConfiguration config = new AndroidApplicationConfiguration();

		// Запрет на отключение экрана и использование датчиков имплементацией libgdx
		config.useWakelock = true;
		config.useAccelerometer = false;
		config.useGyroscope = false;
		config.useCompass = false;
		config.numSamples = 2;

		// Создание своего листенера данных с датчиков (поэтому useAccelerometer и т.п. не нужны)
		vrSensorManagerAndroid = new VRSensorManagerAndroid(this.getContext());
		initialize(new GdxVR(vrSensorManagerAndroid), config);
	}

	/** Обработка паузы приложения - отключение листенера датчиков */
	@Override
	public void onPause() {
		vrSensorManagerAndroid.endTracking();
		super.onPause();
	}

	/** При возвращении - снова зарегистрировать листенеры датчиков */
	@Override
	public void onResume() {
		super.onResume();
		vrSensorManagerAndroid.startTracking();
	}
}

package com.sinuxvr.sample;

import com.badlogic.gdx.ApplicationAdapter;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.assets.AssetManager;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.g3d.Model;
import com.badlogic.gdx.graphics.g3d.ModelBatch;
import com.badlogic.gdx.graphics.g3d.ModelInstance;

/** Главный класс приложения, здесь производим инициализацию камеры, модели и выполняем отрисовку */

class GdxVR extends ApplicationAdapter {

	static VRSensorManager vrSensorManager;  // Менеджер для получения данных с датчиков
	private int scrHeight, scrHalfWidth;     // Для хранения размеров viewport
	private AssetManager assets;			 // Загрузчик ресурсов
	private ModelBatch modelBatch;			 // Пакетник для модели
	private ModelInstance roomInstance;      // Экземпляр модели комнаты
	private VRCamera vrCamera;               // VR камера

	/** Конструктор */
	GdxVR(VRSensorManager vrSensorManager) {
		GdxVR.vrSensorManager = vrSensorManager;
	}

	/** Инициализация и загрузка ресурсов */
	@Override
	public void create () {
		// Размеры экрана
		scrHalfWidth = Gdx.graphics.getWidth() / 2;
		scrHeight = Gdx.graphics.getHeight();

		// Загрузка модели из файла
		modelBatch = new ModelBatch();
		assets = new  AssetManager();
		assets.load("room.g3db", Model.class);
		assets.finishLoading();
		Model roomModel = assets.get("room.g3db");
		roomInstance = new ModelInstance(roomModel);

		// Создание камеры (fov, parallax, near, far) и установка позиции
		vrCamera = new VRCamera(90, 0.4f, 0.1f, 30f);
		vrCamera.setPosition(-1.7f, 3f, 3f);

		// Разрешаем коррекцию дрифта при помощи компаса
		vrSensorManager.useDriftCorrection(true);
	}

	/** Отрисовка стереопары осуществляется при помощи изменения viewport-а */
	@Override
	public void render () {
		// Очистка экрана
		Gdx.gl.glClearColor(0f, 0f, 0f, 1f);
		Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT | GL20.GL_DEPTH_BUFFER_BIT);

		// Обновление параметров камеры
		vrCamera.update();

		// Отрисовка сцены для левого глаза
		Gdx.gl.glViewport(0, 0, scrHalfWidth, scrHeight);
		modelBatch.begin(vrCamera.getLeftCam());
		modelBatch.render(roomInstance);
		modelBatch.end();

		// Отрисовка сцены для правого глаза
		Gdx.gl.glViewport(scrHalfWidth, 0, scrHalfWidth, scrHeight);
		modelBatch.begin(vrCamera.getRightCam());
		modelBatch.render(roomInstance);
		modelBatch.end();
	}

	/** Высвобождение ресурсов */
	@Override
	public void dispose () {
		modelBatch.dispose();
		assets.dispose();
	}
}