private void Collider_BeginCollision(ICollisionInfo2D contact)
{
WaveForegroundTask.Run(() =>
{
var colliderA = contact.ColliderA; // Obstacle
var colliderB = contact.ColliderB; // Arrow
if (colliderA != null && colliderB != null && colliderA.CollisionCategories == ColliderCategory2D.Cat2)
{
var physicBodyA = colliderA.RigidBody.UserData as RigidBody2D;
var physicBodyB = colliderB.RigidBody.UserData as RigidBody2D;
Entity obstacle = physicBodyA.Owner;
Entity arrow = physicBodyB.Owner;
Transform2D obstacleTransform = obstacle.FindComponent <Transform2D>();
Transform2D arrowTransform = arrow.FindComponent <Transform2D>();
Vector2 arrowHeadLocalPosition = Vector2.UnitX * 178;
Vector2 arrowHeadWorldPosition = Vector2.Transform(arrowHeadLocalPosition, arrowTransform.WorldTransform);
Vector2 obstacleLocalPosition = Vector2.Transform(arrowHeadWorldPosition, obstacleTransform.WorldInverseTransform);
WeldJoint2D distance = new WeldJoint2D()
{
ConnectedEntityPath = obstacle.EntityPath,
Anchor = arrowHeadLocalPosition,
ConnectedAnchor = obstacleLocalPosition,
ReferenceAngle = obstacleTransform.LocalRotation - arrowTransform.LocalRotation,
};
arrow.AddComponent(distance);
}
});
}
public override Task <Observation> Reset(ServiceMessage request, ServerCallContext context)
{
return(WaveForegroundTask.Run(() =>
{
var newScene = new MyScene();
WaveServices.ScreenContextManager.To(new ScreenContext(newScene), true);
var tcs = new TaskCompletionSource <Observation>();
void StartedHandler(object sender, EventArgs args)
{
newScene.Started -= StartedHandler;
WaveForegroundTask.Run(() =>
{
this.service.SetScene(newScene);
this.service.enginesComponent.ApplyInitialForce();
this.service.enginesComponent.ApplyEngineAction(EngineActions.None);
this.service.scene.NextStep(TimeSpan.FromSeconds(1 / LunarConstants.FPS));
var actionResult = this.service.GetActionResult(EngineActions.None);
tcs.SetResult(actionResult.Observation);
});
}
newScene.Started += StartedHandler;
return tcs.Task;
}));
}
public override Task <ServiceMessage> Render(ServiceMessage request, ServerCallContext context)
{
return(WaveForegroundTask.Run(() =>
{
this.service.Rendered?.Invoke(this, null);
return new ServiceMessage();
}));
}
private void OnGestureRecognitionStarted(SpatialGestureRecognizer sender, SpatialRecognitionStartedEventArgs args)
{
if (this.RecognitionStartedEvent != null)
{
WaveForegroundTask.Run(() =>
{
this.RecognitionStartedEvent(this.service, (SpatialSource)args.InteractionSourceKind);
});
}
}
public override Task <ActionResult> PerformAction(Lunar2D.Action request, ServerCallContext context)
{
return(WaveForegroundTask.Run(() =>
{
var action = request.EngineAction.ToEngineAction();
this.service.enginesComponent.ApplyEngineAction(action);
this.service.scene.NextStep(TimeSpan.FromSeconds(1 / LunarConstants.FPS));
return this.service.GetActionResult(action);
}));
}
private void InternalRaiseEvent(Action eventAction)
{
if (Framework.Game.Current != null)
{
WaveForegroundTask.Run(eventAction);
}
else
{
Task.Factory.StartNew(eventAction, CancellationToken.None, TaskCreationOptions.HideScheduler, this.concurrentSchedulerPair.Value.ExclusiveScheduler);
}
}
/// <summary>
/// Occurs when a hand or controller has experienced a change to its SpatialInteractionSourceState.
/// </summary>
/// <param name="sender">Sender object.</param>
/// <param name="args">Raw args.</param>
private void OnSourceUpdated(SpatialInteractionManager sender, SpatialInteractionSourceEventArgs args)
{
this.UpdatedState(args);
if (this.SourceUpdated != null)
{
WaveForegroundTask.Run(() =>
{
this.SourceUpdated(this.service, this.currentSpatialState);
});
}
}
private void OnGestureNavigationCanceled(SpatialGestureRecognizer sender, SpatialNavigationCanceledEventArgs args)
{
if (this.NavigationCanceledEvent != null)
{
WaveForegroundTask.Run(() =>
{
this.NavigationCanceledEvent(
this.service,
(SpatialSource)args.InteractionSourceKind,
this.mixedRealityApplication.HeadRay);
});
}
}
private void OnGestureManipulationUpdated(SpatialGestureRecognizer sender, SpatialManipulationUpdatedEventArgs args)
{
if (this.ManipulationUpdatedEvent != null)
{
WaveForegroundTask.Run(() =>
{
this.ManipulationUpdatedEvent(
this.service,
(SpatialSource)args.InteractionSourceKind,
args.TryGetCumulativeDelta(this.CoordinateSystem).Translation.ToWave(),
this.mixedRealityApplication.HeadRay);
});
}
}
/// <summary>
/// Handle events fired when a result is generated.
/// </summary>
/// <param name="sender">The Recognition session that generated this result</param>
/// <param name="args">Details about the recognized speech</param>
private void ContinuousRecognitionSession_ResultGenerated(SpeechContinuousRecognitionSession sender, SpeechContinuousRecognitionResultGeneratedEventArgs args)
{
var confidence = args.Result.Confidence;
var text = args.Result.Text;
Debug.WriteLine($"VoiceCommand: Text recognized '{text}' with condifence {confidence}");
// We may choose to discard content that has low confidence, as that could indicate that we're picking up
// noise via the microphone, or someone could be talking out of earshot.
if (confidence == SpeechRecognitionConfidence.Medium ||
confidence == SpeechRecognitionConfidence.High)
{
WaveForegroundTask.Run(() => this.CommandRecognized?.Invoke(this, text));
}
}
/// <summary>
/// Handles the SurfaceObserver's OnSurfaceChanged event.
/// </summary>
/// <param name="id">The identifier assigned to the surface which has changed.</param>
/// <param name="surface">The surface</param>
/// <param name="changeType">The type of change that occurred on the surface.</param>
/// <param name="updateTime">The date and time at which the change occurred.</param>
protected virtual void OnSurfaceChanged(Guid id, SpatialMappingSurface surface, SurfaceChange changeType, DateTimeOffset updateTime)
{
WaveForegroundTask.Run(() =>
{
if (surface.Mesh == null)
{
return;
}
Debug.WriteLine("OnSurfaceChanged [" + changeType + "] " + id);
string entityId = this.GetEntityNameFromSurfaceId(id);
switch (changeType)
{
case SurfaceChange.Added:
case SurfaceChange.Updated:
var surfaceEntity = this.Owner.FindChild(entityId);
if (surfaceEntity == null)
{
surfaceEntity = this.CreateNewSurfaceEntity(entityId, surface);
surfaceEntity.Tag = SurfaceEntityTag;
if (surfaceEntity != null)
{
this.Owner.AddChild(surfaceEntity);
}
}
else
{
this.RefreshModel(surface, surfaceEntity);
this.UpdateSurfaceEntity(surface, surfaceEntity);
}
break;
case SurfaceChange.Removed:
// Remove the child entity
this.Owner.RemoveChild(entityId);
break;
default:
break;
}
});
}
/// <inheritdoc/>
protected override void Terminate()
{
base.Terminate();
if (this.noesisInitialized)
{
this.noesisInitialized = false;
WaveForegroundTask.Run(() =>
{
Noesis.GUI.UnregisterNativeTypes();
this.renderDevice = null;
});
}
}
protected override void CreateScene()
{
this.Load(WaveContent.Scenes.MyScene);
this.camera3DEntity = this.EntityManager.Find("defaultCamera3D");
// Create effects
this.CreateEffects();
// Button next effect
this.effectButton = new Button()
{
Text = "Original",
VerticalTextAlignment = VerticalAlignment.Center,
Width = 250,
BackgroundColor = Color.Purple,
HorizontalAlignment = HorizontalAlignment.Center,
};
this.effectButton.Click += (s, o) =>
{
if (!this.flag)
{
WaveForegroundTask.Run(() =>
{
this.flag = true;
if (this.lastEffect != null)
{
this.camera3DEntity.RemoveComponent(this.lastEffect);
}
this.lastEffect = this.effects[this.currentEffectIndex];
this.currentEffectIndex = (this.currentEffectIndex + 1) % this.effects.Count;
this.effectButton.Text = this.lastEffect.GetType().Name;
WaveServices.Layout.PerformLayout();
if (this.lastEffect != null)
{
this.camera3DEntity.AddComponent(this.lastEffect);
}
this.flag = false;
});
}
};
this.EntityManager.Add(this.effectButton);
}
private async Task <Texture2D> LoadTextureAsync(string imageUrl, CancellationToken cancellationToken)
{
using (var imageStreamResult = await ImagesHelper.LoadImageStreamAsync(imageUrl, cancellationToken).ConfigureWaveAwait(WaveTaskContinueOn.Background))
{
if (!imageStreamResult.IsSuccess)
{
return(null);
}
cancellationToken.ThrowIfCancellationRequested();
var texture = Texture2D.FromFile(this.RenderManager.GraphicsDevice, imageStreamResult.Stream);
this.downloadedImages++;
await WaveForegroundTask.Run((Action)UpdateText, cancellationToken).ConfigureAwait(false);
return(texture);
}
}
public override Task <Observation> Reset(ServiceMessage request, ServerCallContext context)
{
return(WaveForegroundTask.Run(() =>
{
if (!this.service.sceneLoaded)
{
this.service.sceneLoaded = true;
var newScene = new MyScene3D();
WaveServices.ScreenContextManager.To(new ScreenContext(newScene), true);
newScene.Initialize(WaveServices.GraphicsDevice);
}
this.service.OnReset?.Invoke(this.service, null);
return this.service.GetUpdatedObservation();
}));
}
protected async Task InitializeAsync(bool forceCreateContextInWaveThread)
{
base.Initialize();
// Get ScreenContextManager
var screenContextManager = this.Container.Resolve <ScreenContextManager>();
ScreenContext screenContext;
if (forceCreateContextInWaveThread)
{
screenContext = await WaveForegroundTask.Run(() => this.CreateScreenContext());
}
else
{
screenContext = this.CreateScreenContext();
}
// Navigate to scene
screenContextManager.To(screenContext, false);
}
public override Task <ActionResult> PerformAction(Lunar3D.Action request, ServerCallContext context)
{
// count++;
// test.Start();
return(WaveForegroundTask.Run(() =>
{
var action = request.EngineAction.ToEngineAction();
this.service.ActionReveiced?.Invoke(this, action);
// Next step
this.service.Updated?.Invoke(this, TimeSpan.FromSeconds(1 / LunarConstants.FPS));
return this.service.GetActionResult(action);
}));/*.ContinueWith(t =>
* {
* test.Stop();
* if (count % 1000 == 0)
* {
* Debug.WriteLine(test.ElapsedMilliseconds / (double)count);
* }
* return t.Result;
* });*/
}
private void GetResponseCallback(IAsyncResult asynchronousResult)
{
WaveForegroundTask.Run(() =>
{
HttpWebRequest request = asynchronousResult.AsyncState as HttpWebRequest;
try
{
using (HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(asynchronousResult))
using (var imageStream = response.GetResponseStream())
{
if (!this.disposed)
{
this.LoadTextureFromStream(imageStream);
this.IsImageDownloaded = true;
}
}
}
catch (Exception)
{
}
});
}
/// <summary>
/// Called when message is received.
/// </summary>
/// <param name="host">The host endpoint that sent the message.</param>
/// <param name="receivedMessage">The received message.</param>
protected virtual void OnMessageReceived(NetworkEndpoint host, IncomingMessage receivedMessage)
{
WaveForegroundTask.Run(() => this.MessageReceived?.Invoke(this, new MessageReceivedEventArgs(host, receivedMessage)));
}
/// <summary>
/// Called when the client lose the connection with the host.
/// </summary>
/// <param name="host">The host endpoint.</param>
protected virtual void OnHostDisconnected(NetworkEndpoint host)
{
WaveForegroundTask.Run(() => this.HostDisconnected?.Invoke(this, new HostDisconnectedEventArgs(host)));
}
