Tilt Five Development Preferences

matt

Hi All,

I'm curious if the Tilt Five team have ever done a survey or poll on which SDK/engine choices developers preferred and how this influenced the priority given to when these SDKs are produced?

We have now had the Unity engine SDK/preview to look at, which was nice to see. but as I am not a Unity user, there isn't a lot I have to say about it. Doesn't appear to be much discussion from others either so far.

My preference is native/low-level. I'm not fussy, just give me a projection matrix.

Interested to know what others think.

Matt.

matt

Hi Jamie ,
Thanks for that. Good information.

Jamie

Hi Matt,

The plan is to release a native SDK with a C API and to have the UE and Unity plugins built on top of that. Right now things are still being done using our internal APIs. It's on my TODO list to go through and turn those internals into a public API, but I just haven't gotten to it yet. We'll certainly share it when it exists

Part of the reason we released the Unity SDK Preview before the others is that we wanted to collect feedback from folks on the UI aspects of the plugin. We wanted to get some of that figured out first on the Unity side so that it could inform the work on the Unreal Engine side. For the native API, I think there's less need for feedback since it's less open-ended - like you said, we just need to give you guys a projection matrix. We'll still release a preview of the C API to collect feedback, but I don't think we'll need as long a lead time for it.

You can get some idea of what a part of the interface will look like from this code in the Unity SDK Preview (mostly the GetGlassesPose and QueueStereoImages methods). In the non-preview plugin these are implemented in native code. It'll also probably be informative to look around at the code that calls these methods.

Since they're not especially well documented there, here's what the arguments are:

(please keep in mind these are internal APIs, and various details may change)

public static int GetGlassesPose(
    // A unit quaternion encoding the rotation that takes points in the
    // "global" reference frame (origin at the game board center) to the
    // "glasses" reference frame (origin half way between the projectors).
    // This should actually be called rotToUGLS_UGBL.
    //
    // (output parameter)
    [MarshalAs(UnmanagedType.LPArray, SizeConst = 4)] float[] rotToGLS_WRLD,

    // The 3D position of the "glasses" reference frame origin relative to
    // the "global" reference frame. This should actually be called
    // posUGLS_UGBL.
    //
    // (output parameter)
    [MarshalAs(UnmanagedType.LPArray, SizeConst = 3)] float[] posGLS_WRLD)

public static int QueueStereoImages(
  // The two textures containing the rendered left- and right-eye images. We
  // kick off a compute shader to prepare these images to be sent to the glasses
  // and then wait for that to complete on another thread, which then sends the
  // images.
  System.IntPtr leftEyeTextureHandle,
  System.IntPtr rightEyeTextureHandle,
  ushort texWidth_PIX,
  ushort texHeight_PIX,

  // Whether the textures are an sRGB texel format; i.e. whether sampling from
  // them in a shader will result in a value that's in a linear RGB colorspace.
  bool isSrgb,

  // The image rectangle in the "virtual camera z=1 image-space" reference
  // frame. Essentially, these are the frustum parameters used when rendering
  // the images.
  float startX_VCI, float startY_VCI, float width_VCI, float height_VCI,

  // A unit quaternion encoding the rotation that takes points in the "global"
  // reference frame to the "left virtual camera" reference frame (the view
  // space when rendering the left image).
  [MarshalAs(UnmanagedType.LPArray,
             SizeConst = 4)] float[] rotToULVC_UGBL,

  // The 3D position of the "left virtual camera" reference frame origin
  // relative to the "global" reference frame.
  [MarshalAs(UnmanagedType.LPArray, SizeConst = 3)] float[] posULVC_UGBL,

  // A unit quaternion encoding the rotation that transforms points in the
  // "global" reference frame to the "right virtual camera" reference frame
  //  (the view space when rendering the right image).
  [MarshalAs(UnmanagedType.LPArray,
             SizeConst = 4)] float[] rotToURVC_UGBL,

  // The 3D position of the "left virtual camera" reference frame origin
  // relative to the "global" reference frame.
  [MarshalAs(UnmanagedType.LPArray,
             SizeConst = 3)] float[] posURVC_UGBL)

Best,
Jamie

Dragon Magic

@matt Those 2 are the most used game engines for the past years.
There are many others nowadays but those are in general considered the 2 primary ones.

The point is that those 2 are most used and therefor getting the most "support" where support means time and effort.
It does not take away that they will support others but its more likely you see SDK for unity and unreal at its start.

Your question was about a poll or survey for which sdk/engine inluenced the priority, i can tell you there are some devs already working on content for tilt 5 before the kickstarter started.
I assume based on that data the choice been made to support that first so those devs can have their content done in time.
If you look at fantasy grounds they are using unity.
Wartile seems to be build on UE4.
I'm using unity3d myself.
Hope it helps to answer your question.

jesgilbert

I'd like to lend support to Matt's question and also assert that, while I do understand the initial focus on game engines, I'm a developer that is interested in accessing the native/low level APIs primarily. It would great to hear from Tilt5 regarding this and at the very least provide a roadmap of when developers will have access.

We do understand that the low level APIs may evolve but this would be expected for early stage hardware. Ideally that would not be a barrier to getting started with custom development once we have the beta hardware in hand.

matt

You state "most used engines which is unity3d and unreal engine." My original post is asking for the basis of this assertion, or is it assumption?

I would also point out that you don't get either of the above without first creating the native/low-level APIs. Albeit, that these may be in flux as the higher level support is added.

Matt.

Dragon Magic

The main focus at start is to support the most used engines which is unity3d and unreal engine.
Tilt 5 is a small team and of course they would like to support and do as much as possible but at the beginning everything needs to be in focus on what is needed the most before going for all those additional alternatives.