godot/servers/arvr_server.h

/*************************************************************************/
/*  arvr_server.h                                                        */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                      https://godotengine.org                          */
/*************************************************************************/
/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
/*                                                                       */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the       */
/* "Software"), to deal in the Software without restriction, including   */
/* without limitation the rights to use, copy, modify, merge, publish,   */
/* distribute, sublicense, and/or sell copies of the Software, and to    */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions:                                             */
/*                                                                       */
/* The above copyright notice and this permission notice shall be        */
/* included in all copies or substantial portions of the Software.       */
/*                                                                       */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
/*************************************************************************/

#ifndef ARVR_SERVER_H
#define ARVR_SERVER_H

#include "core/os/os.h"
#include "core/os/thread_safe.h"
#include "core/reference.h"
#include "core/rid.h"
#include "core/variant.h"

class ARVRInterface;
class ARVRPositionalTracker;

/**
	@author Bastiaan Olij <mux213@gmail.com>

	The ARVR server is a singleton object that gives access to the various
	objects and SDKs that are available on the system.
	Because there can be multiple SDKs active this is exposed as an array
	and our ARVR server object acts as a pass through
	Also each positioning tracker is accessible from here.

	I've added some additional info into this header file that should move
	into the documentation, I will do so when we're close to accepting this PR
	or as a separate PR once this has been merged into the master branch.
**/

class ARVRServer : public Object {
	GDCLASS(ARVRServer, Object);
	_THREAD_SAFE_CLASS_

public:
	enum TrackerType {
		TRACKER_CONTROLLER = 0x01, /* tracks a controller */
		TRACKER_BASESTATION = 0x02, /* tracks location of a base station */
		TRACKER_ANCHOR = 0x04, /* tracks an anchor point, used in AR to track a real live location */
		TRACKER_UNKNOWN = 0x80, /* unknown tracker */

		TRACKER_ANY_KNOWN = 0x7f, /* all except unknown */
		TRACKER_ANY = 0xff /* used by get_connected_trackers to return all types */
	};

	enum RotationMode {
		RESET_FULL_ROTATION = 0, /* we reset the full rotation, regardless of how the HMD is oriented, we're looking dead ahead */
		RESET_BUT_KEEP_TILT = 1, /* reset rotation but keep tilt. */
		DONT_RESET_ROTATION = 2, /* don't reset the rotation, we will only center on position */
	};

private:
	Vector<Ref<ARVRInterface> > interfaces;
	Vector<ARVRPositionalTracker *> trackers;

	Ref<ARVRInterface> primary_interface; /* we'll identify one interface as primary, this will be used by our viewports */

	real_t world_scale; /* scale by which we multiply our tracker positions */
	Transform world_origin; /* our world origin point, maps a location in our virtual world to the origin point in our real world tracking volume */
	Transform reference_frame; /* our reference frame */

	uint64_t last_process_usec; /* for frame timing, usec when we did our processing */
	uint64_t last_commit_usec; /* for frame timing, usec when we finished committing both eyes */
	uint64_t last_frame_usec; /* time it took between process and committing, we should probably average this over the last x frames */

protected:
	static ARVRServer *singleton;

	static void _bind_methods();

public:
	static ARVRServer *get_singleton();

	/*
		World scale allows you to specify a scale factor that is applied to all positioning vectors in our VR world in essence scaling up, or scaling down the world.
		For stereoscopic rendering specifically this is very important to give an accurate sense of scale.
		Add controllers into the mix and an accurate mapping of real world movement to perceived virtual movement becomes very important.

		Most VR platforms, and our assumption, is that 1 unit in our virtual world equates to 1 meter in the real mode.
		This scale basically effects the unit size relationship to real world size.

		I may remove access to this property in GDScript in favour of exposing it on the ARVROrigin node
	*/
	real_t get_world_scale() const;
	void set_world_scale(real_t p_world_scale);

	/*
		The world maps the 0,0,0 coordinate of our real world coordinate system for our tracking volume to a location in our
		virtual world. It is this origin point that should be moved when the player is moved through the world by controller
		actions be it straffing, teleporting, etc. Movement of the player by moving through the physical space is always tracked
		in relation to this point.

		Note that the ARVROrigin spatial node in your scene automatically updates this property and it should be used instead of
		direct access to this property and it therefore is not available in GDScript

		Note: this should not be used in AR and should be ignored by an AR based interface as it would throw what you're looking at in the real world
		and in the virtual world out of sync
	*/
	Transform get_world_origin() const;
	void set_world_origin(const Transform p_world_origin);

	/*
		center_on_hmd calculates a new reference frame. This ensures the HMD is positioned to 0,0,0 facing 0,0,-1 (need to verify this direction)
		in the virtual world.

		You can ignore the tilt of the device ensuring you're looking straight forward even if the player is looking down or sideways.
		You can chose to keep the height the tracking provides which is important for room scale capable tracking.

		Note: this should not be used in AR and should be ignored by an AR based interface as it would throw what you're looking at in the real world
		and in the virtual world out of sync
	*/
	Transform get_reference_frame() const;
	void center_on_hmd(RotationMode p_rotation_mode, bool p_keep_height);

	/*
		get_hmd_transform gets our hmd transform (centered between eyes) with most up to date tracking, relative to the origin
	*/
	Transform get_hmd_transform();

	/*
		Interfaces are objects that 'glue' Godot to an AR or VR SDK such as the Oculus SDK, OpenVR, OpenHMD, etc.
	*/
	void add_interface(const Ref<ARVRInterface> &p_interface);
	void remove_interface(const Ref<ARVRInterface> &p_interface);
	int get_interface_count() const;
	Ref<ARVRInterface> get_interface(int p_index) const;
	Ref<ARVRInterface> find_interface(const String &p_name) const;
	Array get_interfaces() const;

	/*
		note, more then one interface can technically be active, especially on mobile, but only one interface is used for
		rendering. This interface identifies itself by calling set_primary_interface when it is initialized
	*/
	Ref<ARVRInterface> get_primary_interface() const;
	void set_primary_interface(const Ref<ARVRInterface> &p_primary_interface);
	void clear_primary_interface_if(const Ref<ARVRInterface> &p_primary_interface); /* this is automatically called if an interface destructs */

	/*
		Our trackers are objects that expose the orientation and position of physical devices such as controller, anchor points, etc.
		They are created and managed by our active AR/VR interfaces.
	*/
	bool is_tracker_id_in_use_for_type(TrackerType p_tracker_type, int p_tracker_id) const;
	int get_free_tracker_id_for_type(TrackerType p_tracker_type);
	void add_tracker(ARVRPositionalTracker *p_tracker);
	void remove_tracker(ARVRPositionalTracker *p_tracker);
	int get_tracker_count() const;
	ARVRPositionalTracker *get_tracker(int p_index) const;
	ARVRPositionalTracker *find_by_type_and_id(TrackerType p_tracker_type, int p_tracker_id) const;

	uint64_t get_last_process_usec();
	uint64_t get_last_commit_usec();
	uint64_t get_last_frame_usec();

	void _process();
	void _mark_commit();

	ARVRServer();
	~ARVRServer();
};

#define ARVR ARVRServer

VARIANT_ENUM_CAST(ARVRServer::TrackerType);
VARIANT_ENUM_CAST(ARVRServer::RotationMode);

#endif