public static IFinalTransform Create(IHasTransform detachedChild) { var attachedTransform = new DefaultFinalTransform { _child = detachedChild }; return(attachedTransform); }
public static IFinalTransform Create(IHasTransform parent, IHasTransform child) { var attachedTransform = new DefaultFinalTransform { _parent = parent, _child = child }; return(attachedTransform); }
/// <summary> /// Returns a final transform by combining the final transform of the parent in the hierarchy (if the parent /// node has a transform), and the local transform of this object. You should use this method to implement /// <see cref="IHasTransform.FinalTransform"/> if your object resides in the hierarchy. /// </summary> /// <param name="hasTransform">The current object.</param> /// <param name="node"> /// The node in the dependency injection hierarchy that points to this object. This value /// can be obtained by injecting <see cref="INode"/> into the constructor of your object. /// </param> /// <returns>A final computed transform.</returns> public static IFinalTransform GetAttachedFinalTransformImplementation(this IHasTransform hasTransform, INode node) { var parentHasTransform = node?.Parent?.UntypedValue as IHasTransform; if (parentHasTransform != null) { return(DefaultFinalTransform.Create(parentHasTransform, hasTransform)); } return(DefaultFinalTransform.Create(hasTransform)); }
public void Render(ComponentizedEntity entity, IGameContext gameContext, IRenderContext renderContext) { if (!_enabled || _serverOnly) { return; } if (renderContext.IsCurrentRenderPass <IDebugRenderPass>()) { var debugRenderPass = renderContext.GetCurrentRenderPass <IDebugRenderPass>(); var entityTransformSync = _synchronisedData.Select(x => x.Value).FirstOrDefault(x => x.Name == "entity.transform"); if (entityTransformSync != null && debugRenderPass.EnabledLayers.OfType <ServerStateDebugLayer>().Any()) { var lastValueSerialized = entityTransformSync.LastValueFromServer as NetworkTransform; if (lastValueSerialized != null) { var timeMachine = entityTransformSync.TimeMachine; if (timeMachine != null) { var lastValueRelative = lastValueSerialized.DeserializeFromNetwork(); var lastValueAbsolute = DefaultFinalTransform.Create(entity.FinalTransform.ParentObject, new TransformContainer(lastValueRelative)); var clientLocalTickValueRelative = timeMachine.Get(_localTick) as ITransform; var clientLocalTickValueAbsolute = DefaultFinalTransform.Create(entity.FinalTransform.ParentObject, new TransformContainer(clientLocalTickValueRelative)); var clientRewindValueRelative = timeMachine.Get(_localTick - _networkEngine.ClientRenderDelayTicks) as ITransform; var clientRewindValueAbsolute = DefaultFinalTransform.Create(entity.FinalTransform.ParentObject, new TransformContainer(clientRewindValueRelative)); var lastValuePoint = Vector3.Transform(Vector3.Zero, lastValueAbsolute.AbsoluteMatrix); var lastValueUp = Vector3.Transform(Vector3.Up, lastValueAbsolute.AbsoluteMatrix); var lastValueForward = Vector3.Transform(Vector3.Forward, lastValueAbsolute.AbsoluteMatrix); var lastValueLeft = Vector3.Transform(Vector3.Left, lastValueAbsolute.AbsoluteMatrix); var clientLocalTickPoint = Vector3.Transform(Vector3.Zero, clientLocalTickValueAbsolute.AbsoluteMatrix); var clientLocalTickUp = Vector3.Transform(Vector3.Up, clientLocalTickValueAbsolute.AbsoluteMatrix); var clientLocalTickForward = Vector3.Transform(Vector3.Forward, clientLocalTickValueAbsolute.AbsoluteMatrix); var clientLocalTickLeft = Vector3.Transform(Vector3.Left, clientLocalTickValueAbsolute.AbsoluteMatrix); var clientRewindValueTickPoint = Vector3.Transform(Vector3.Zero, clientRewindValueAbsolute.AbsoluteMatrix); var clientRewindValueTickUp = Vector3.Transform(Vector3.Up, clientRewindValueAbsolute.AbsoluteMatrix); var clientRewindValueTickForward = Vector3.Transform(Vector3.Forward, clientRewindValueAbsolute.AbsoluteMatrix); var clientRewindValueTickLeft = Vector3.Transform(Vector3.Left, clientRewindValueAbsolute.AbsoluteMatrix); if (entity.GetType().Name == "CubeEntity") { Console.WriteLine(lastValueSerialized); } // Render the previous and next server states. _debugRenderer.RenderDebugLine(renderContext, lastValuePoint, lastValueUp, Color.Red, Color.Red); _debugRenderer.RenderDebugLine(renderContext, lastValuePoint, lastValueForward, Color.Red, Color.Red); _debugRenderer.RenderDebugLine(renderContext, lastValuePoint, lastValueLeft, Color.Red, Color.Red); _debugRenderer.RenderDebugLine(renderContext, clientLocalTickPoint, clientLocalTickUp, Color.Orange, Color.Orange); _debugRenderer.RenderDebugLine(renderContext, clientLocalTickPoint, clientLocalTickForward, Color.Orange, Color.Orange); _debugRenderer.RenderDebugLine(renderContext, clientLocalTickPoint, clientLocalTickLeft, Color.Orange, Color.Orange); _debugRenderer.RenderDebugLine(renderContext, clientRewindValueTickPoint, clientRewindValueTickUp, Color.Yellow, Color.Yellow); _debugRenderer.RenderDebugLine(renderContext, clientRewindValueTickPoint, clientRewindValueTickForward, Color.Yellow, Color.Yellow); _debugRenderer.RenderDebugLine(renderContext, clientRewindValueTickPoint, clientRewindValueTickLeft, Color.Yellow, Color.Yellow); } } } } }
/// <summary> /// Gets a final transform which is just representative of the local transform. This method should be used /// sparingly, but is intended when either you know the parent of this object will have no transform (i.e. /// you are implementing an entity which resides directly in the world), or when there's no way for the caller /// to know it's position in the hierarchy. /// </summary> /// <param name="hasTransform">The current object.</param> /// <returns>A final computed transform.</returns> public static IFinalTransform GetDetachedFinalTransformImplementation(this IHasTransform hasTransform) { return(DefaultFinalTransform.Create(hasTransform)); }