fove.headset.Compositor Class Reference

Class that manages accesses to the compositor. More...

Inheritance diagram for fove.headset.Compositor:

Collaboration diagram for fove.headset.Compositor:

Public Member Functions
def	__init__ (self, headset)
	Defines a compositor that can be created from a headset. More...
def	__enter__ (self)
	Creates a compositor interface to the given headset. More...
def	__exit__ (self, _e_type, _e_val, _traceback)
	Frees resources used by the compositor object, including memory and sockets. More...
def	createLayer (self, layerInfo)
	Create a layer for this client. More...
def	getAdapterId (self)
	Returns the ID of the GPU currently attached to the headset. More...
def	getLastRenderPose (self)
	Gets the last cached pose for rendering purposes, without waiting for a new frame to arrive. More...
def	isReady (self)
	Checks whether we are connected to a running compositor and ready to submit frames for composing. More...
def	submit (self, submitInfo, layerCount)
	Submit a frame to the compositor. More...
def	waitForRenderPose (self)
	Wait for the most recent pose for rendering purposes. More...

Detailed Description

Class that manages accesses to the compositor.

All Compositor-related API requests will be done through an instance of this class.

The class provides Compositor.__enter__ and Compositor.__exit__ methods that do relevant resource managements, and the Headset instance has a factory method that creates a compositor.

It is fine to create multiple compositors from the same headset. It is also fine for the compositor to outlive the headset passed in.

A typical use of this class would be as follows:

with Headset(ClientCapabilities.Gaze) as headset,
     headset.createCompositor() as compositor:
    # use compositor
    pass

Constructor & Destructor Documentation

__init__()

def fove.headset.Compositor.__init__	(		self,
			headset
	)

Defines a compositor that can be created from a headset.

Normally, this method is invoked through Headset.createCompositor. But unlike in the C API, the user has to call Compositor.__enter__ on the result of Compositor.__init__ or Headset.createCompositor to actually connect to a compositor.

Parameters

headset

An instance of capi.Headset from which this compositor will be created. (Note that it is not an instance of the Headset class defined in this module.)

See also

Headset.createCompositor

Compositor.__enter__

Member Function Documentation

__enter__()

def fove.headset.Compositor.__enter__

(

self

)

Creates a compositor interface to the given headset.

Each call to this function creates and stores a new compositor object, which should be destroyed by calling Compositor.__exit__ on self, which is also retuned from this function.

Returns

self with a reference to a compositor object

See also

Headset.createCompositor

Compositor.__exit__

__exit__()

def fove.headset.Compositor.__exit__	(		self,
			_e_type,
			_e_val,
			_traceback
	)

Frees resources used by the compositor object, including memory and sockets.

Upon return, this instance for the compositor should no longer be used.

See also

Compositor.__enter__

Headset.createCompositor

createLayer()

def fove.headset.Compositor.createLayer	(		self,
			layerInfo
	)

Create a layer for this client.

This function creates a layer upon which frames may be submitted to the compositor by this client.

A connection to the compositor must exist for this to pass. This means you need to wait for Compositor.isReady before calling this function. However, if connection to the compositor is lost and regained, this layer will persist. For this reason, you should not recreate your layers upon reconnection, simply create them once.

There is no way to delete a layer once created, other than to destroy the Compositor object. This is a feature we would like to add in the future.

Parameters

layerInfo

The settings for the layer to be created

Returns

A struct that holds the defaults of the newly created layer

See also

Compositor.isReady

Compositor.submit

submit()

def fove.headset.Compositor.submit	(		self,
			submitInfo,
			layerCount
	)

Submit a frame to the compositor.

This function takes the feed from your game engine to the compositor for output.

Parameters

submitInfo	An array of layerCount capi.CompositorLayerSubmitInfo structs, each of which provides texture data for a unique layer
layerCount	The number of layers you are submitting

Returns

True if successfully submitted, or None in case of API failure

waitForRenderPose()

def fove.headset.Compositor.waitForRenderPose

(

self

)

Wait for the most recent pose for rendering purposes.

All compositor clients should use this function as the sole means of limiting their frame rate. This allows the client to render at the correct frame rate for the HMD display. Upon this function returning, the client should proceed directly to rendering, to reduce the chance of missing the frame. This function will return the latest pose (valid if not None) as a conveience to the caller.

In general, a client's main loop should look like:

# with compositor
while True:
   Update()                                   # Run AI, physics, etc, for the next frame
   pose, err = compositor.waitForRenderPose() # Wait for the next frame, and get the pose
   if pose:
       Draw(pose)                             # Render the scene using the new pose
   elif err is False:
       # sleep a bit and retry
       continue
   else:
       # permanent error
       break

Returns

(Optional[capi.Pose], Optional[bool])

The first return value is the current pose if the call synced with the compositor frames; otherwise it is None.

When the first return value is None, the second return value indicates whether the error is permanent: i.e. it is False when the call to an internal API has just timed out and retry on the client side might be useful; it is otherwise True, e.g. if the Orientation capability was not registered.

getLastRenderPose()

def fove.headset.Compositor.getLastRenderPose

(

self

)

Gets the last cached pose for rendering purposes, without waiting for a new frame to arrive.

Returns

Last cached pose, or None in case of API failure

isReady()

def fove.headset.Compositor.isReady

(

self

)

Checks whether we are connected to a running compositor and ready to submit frames for composing.

Returns

True if we are connected to a running compositor and ready to submit frames for compositing, False if not, or else None in case of API failure

getAdapterId()

def fove.headset.Compositor.getAdapterId

(

self

)

Returns the ID of the GPU currently attached to the headset.

For systems with multiple GPUs, submitted textures to the compositor must come from the same GPU that the compositor is using.

Returns

The adapter ID, or None in case of API failure