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));
}
