public string CreateAnchor(Vec3 at, string id = null)
{
string anchorID = id == null
? Guid.NewGuid().ToString()
: id;
SpatialLocator locator = SpatialLocator.GetDefault();
SpatialStationaryFrameOfReference stationary = locator.CreateStationaryFrameOfReferenceAtCurrentLocation();
SpatialAnchor anchor = SpatialAnchor.TryCreateRelativeTo(stationary.CoordinateSystem);
Pose pose = World.FromPerceptionAnchor(anchor);
Pose newAnchor = pose.ToMatrix().Inverse.Transform(new Pose(at, Quat.Identity));
anchor = SpatialAnchor.TryCreateRelativeTo(stationary.CoordinateSystem, newAnchor.position, newAnchor.orientation);
pose = World.FromPerceptionAnchor(anchor);
if (anchor != null)
{
anchorPoses.Add(anchorID, pose);
}
return(anchorStore.TrySave(anchorID, anchor)
? anchorID
: null);
}
public void SetHolographicSpace(HolographicSpace holographicSpace)
{
this.holographicSpace = holographicSpace;
//
// TODO: Add code here to initialize your content.
//
// <<NEW>> Set up Event Sub Send
this.eventHubSend = new EventHubSend();
// try to send message as test
Debug.WriteLine("EventHubSendStart:call");
this.eventHubSend.EventHubSendStart();
#if DRAW_SAMPLE_CONTENT
// Initialize the sample hologram.
spinningCubeRenderer = new SpinningCubeRenderer(deviceResources);
spatialInputHandler = new SpatialInputHandler();
#endif
// Use the default SpatialLocator to track the motion of the device.
locator = SpatialLocator.GetDefault();
// Be able to respond to changes in the positional tracking state.
locator.LocatabilityChanged += this.OnLocatabilityChanged;
// Respond to camera added events by creating any resources that are specific
// to that camera, such as the back buffer render target view.
// When we add an event handler for CameraAdded, the API layer will avoid putting
// the new camera in new HolographicFrames until we complete the deferral we created
// for that handler, or return from the handler without creating a deferral. This
// allows the app to take more than one frame to finish creating resources and
// loading assets for the new holographic camera.
// This function should be registered before the app creates any HolographicFrames.
holographicSpace.CameraAdded += this.OnCameraAdded;
// Respond to camera removed events by releasing resources that were created for that
// camera.
// When the app receives a CameraRemoved event, it releases all references to the back
// buffer right away. This includes render target views, Direct2D target bitmaps, and so on.
// The app must also ensure that the back buffer is not attached as a render target, as
// shown in DeviceResources.ReleaseResourcesForBackBuffer.
holographicSpace.CameraRemoved += this.OnCameraRemoved;
// The simplest way to render world-locked holograms is to create a stationary reference frame
// when the app is launched. This is roughly analogous to creating a "world" coordinate system
// with the origin placed at the device's position as the app is launched.
referenceFrame = locator.CreateStationaryFrameOfReferenceAtCurrentLocation();
// Notes on spatial tracking APIs:
// * Stationary reference frames are designed to provide a best-fit position relative to the
// overall space. Individual positions within that reference frame are allowed to drift slightly
// as the device learns more about the environment.
// * When precise placement of individual holograms is required, a SpatialAnchor should be used to
// anchor the individual hologram to a position in the real world - for example, a point the user
// indicates to be of special interest. Anchor positions do not drift, but can be corrected; the
// anchor will use the corrected position starting in the next frame after the correction has
// occurred.
}
public void SetHolographicSpace(HolographicSpace holographicSpace)
{
this.holographicSpace = holographicSpace;
//Task.Factory.StartNew(RunAppScript).Wait();
try
{
host = new ChakraHost();
appScript = System.IO.File.ReadAllText(@"Assets/js/app.js");
host.SetHolographicSpace(this.holographicSpace);
host.RunScript(appScript);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
};
// Use the default SpatialLocator to track the motion of the device.
locator = SpatialLocator.GetDefault();
// Be able to respond to changes in the positional tracking state.
locator.LocatabilityChanged += this.OnLocatabilityChanged;
// Respond to camera added events by creating any resources that are specific
// to that camera, such as the back buffer render target view.
// When we add an event handler for CameraAdded, the API layer will avoid putting
// the new camera in new HolographicFrames until we complete the deferral we created
// for that handler, or return from the handler without creating a deferral. This
// allows the app to take more than one frame to finish creating resources and
// loading assets for the new holographic camera.
// This function should be registered before the app creates any HolographicFrames.
holographicSpace.CameraAdded += this.OnCameraAdded;
// Respond to camera removed events by releasing resources that were created for that
// camera.
// When the app receives a CameraRemoved event, it releases all references to the back
// buffer right away. This includes render target views, Direct2D target bitmaps, and so on.
// The app must also ensure that the back buffer is not attached as a render target, as
// shown in DeviceResources.ReleaseResourcesForBackBuffer.
holographicSpace.CameraRemoved += this.OnCameraRemoved;
// The simplest way to render world-locked holograms is to create a stationary reference frame
// when the app is launched. This is roughly analogous to creating a "world" coordinate system
// with the origin placed at the device's position as the app is launched.
referenceFrame = locator.CreateStationaryFrameOfReferenceAtCurrentLocation();
// Notes on spatial tracking APIs:
// * Stationary reference frames are designed to provide a best-fit position relative to the
// overall space. Individual positions within that reference frame are allowed to drift slightly
// as the device learns more about the environment.
// * When precise placement of individual holograms is required, a SpatialAnchor should be used to
// anchor the individual hologram to a position in the real world - for example, a point the user
// indicates to be of special interest. Anchor positions do not drift, but can be corrected; the
// anchor will use the corrected position starting in the next frame after the correction has
// occurred.
}
private void SetHolographicSpace()
{
// from Holographic Face Tracking Example
// Use the default SpatialLocator to track the motion of the device.
m_locator = SpatialLocator.GetDefault();
// The simplest way to render world-locked holograms is to create a stationary reference frame
// when the app is launched. This is roughly analogous to creating a "world" coordinate system
// with the origin placed at the device's position as the app is launched.
m_referenceFrame = m_locator.CreateStationaryFrameOfReferenceAtCurrentLocation();
}
private void OnLocated(SpatialLocator loc, object args)
{
if (frame != null || loc.Locatability != SpatialLocatability.PositionalTrackingActive)
{
return;
}
frame = loc.CreateStationaryFrameOfReferenceAtCurrentLocation();
anchor = SpatialAnchor.TryCreateRelativeTo(frame.CoordinateSystem);
root = World.FromPerceptionAnchor(anchor).ToMatrix();
UpdateBounds(center, radius);
}
// int reconstructionID = 0;
// initialization
void Start()
{
locator = SpatialLocator.GetDefault();
originFrameOfReference = locator.CreateStationaryFrameOfReferenceAtCurrentLocation();
audioData = GetComponent <AudioSource>();
startHeadPosition = Camera.main.transform.position;
newHeadPosition = startHeadPosition;
textMesh.text = photoCount.ToString();
Debug.Log("Airtap to start/stop capture");
//CreateScene("Test");
CreateFolder();
gr = new GestureRecognizer();
gr.TappedEvent += Tap;
gr.StartCapturingGestures();
}
/// <summary>
/// Initializes a new instance of the <see cref="SeeingSharpHolographicsSpacePainter"/> class.
/// </summary>
/// <param name="targetWindow">The target window into which to render.</param>
public SeeingSharpHolographicsSpacePainter(CoreWindow targetWindow)
{
m_targetWindow = targetWindow;
// Call generic initialization
// (choose device, create holographic space)
InitializeHolographicSpace(targetWindow);
// Use the default SpatialLocator to track the motion of the device.
m_spatialLocator = SpatialLocator.GetDefault();
// Be able to respond to changes in the positional tracking state.
m_spatialLocator.LocatabilityChanged += this.OnSpatialLocator_LocatabilityChanged;
// Respond to camera added events by creating any resources that are specific
// to that camera, such as the back buffer render target view.
// When we add an event handler for CameraAdded, the API layer will avoid putting
// the new camera in new HolographicFrames until we complete the deferral we created
// for that handler, or return from the handler without creating a deferral. This
// allows the app to take more than one frame to finish creating resources and
// loading assets for the new holographic camera.
// This function should be registered before the app creates any HolographicFrames.
m_holoSpace.CameraAdded += this.OnHoloSpace_CameraAdded;
// Respond to camera removed events by releasing resources that were created for that
// camera.
// When the app receives a CameraRemoved event, it releases all references to the back
// buffer right away. This includes render target views, Direct2D target bitmaps, and so on.
// The app must also ensure that the back buffer is not attached as a render target, as
// shown in DeviceResources.ReleaseResourcesForBackBuffer.
m_holoSpace.CameraRemoved += this.OnHoloSpace_CameraRemoved;
// The simplest way to render world-locked holograms is to create a stationary reference frame
// when the app is launched. This is roughly analogous to creating a "world" coordinate system
// with the origin placed at the device's position as the app is launched.
m_referenceFrame = m_spatialLocator.CreateStationaryFrameOfReferenceAtCurrentLocation();
}
public HoloLensCamera()
{
locator = SpatialLocator.GetDefault();
originalFrameOfReference = locator.CreateStationaryFrameOfReferenceAtCurrentLocation();
}
public void ResetReferenceFrame()
{
// Allow user to reset the referenceFrame's location
m_referenceFrame = m_locator.CreateStationaryFrameOfReferenceAtCurrentLocation();
}
// Summary:
// Handler for manipulation started events. Obtains the stationary frame of reference for the gesture.
private void OnManipulationStarted(object sender, SpatialManipulationStartedEventArgs e)
{
// Manipulation has started - obtain the frame of reference relative to when the gesture began
stationaryFrameOfReference = spatialLocator.CreateStationaryFrameOfReferenceAtCurrentLocation();
}