public void Update(ComponentizedEntity entity, IGameContext gameContext, IUpdateContext updateContext)
{
if (Texture != null)
{
if (Texture.IsReady)
{
if (Texture.Asset.Texture != _cachedTextureAssetRef)
{
_cachedTextureAssetRef = Texture.Asset.Texture;
_cachedPixelWidth = _cachedTextureAssetRef.Width;
_cachedPixelHeight = _cachedTextureAssetRef.Height;
if (IsCompressedFormat(_cachedTextureAssetRef.Format))
{
throw new InvalidOperationException(
"The texture provided to the PerPixelCollisionTexture component is a " +
"compressed texture. Only uncompressed textures can be used with the " +
"per-pixel collision algorithm, as the texture must be read to the CPU.");
}
else
{
_cachedPixelData = new Color[_cachedPixelWidth * _cachedPixelHeight];
}
_cachedTextureAssetRef.GetData(_cachedPixelData);
}
}
}
Update();
}
public void Update(ComponentizedEntity entity, IGameContext gameContext, IUpdateContext updateContext)
{
if (!string.IsNullOrWhiteSpace(UserInterfaceAssetName))
{
if (_userInterfaceAssetRef == null ||
_userInterfaceControllerAsset != UserInterfaceAssetName)
{
_userInterfaceAssetRef = _assetManager.Get <UserInterfaceAsset>(UserInterfaceAssetName);
_userInterfaceControllerAsset = UserInterfaceAssetName;
}
if (_userInterfaceAssetRef.IsReady && _userInterfaceAssetRef.Asset != _userInterfaceAsset)
{
if (_userInterfaceController != null)
{
_userInterfaceController.Enabled = false;
}
_userInterfaceAsset = _userInterfaceAssetRef.Asset;
_userInterfaceController = _userInterfaceFactory.CreateUserInterfaceController(_userInterfaceAsset);
_userInterfaceController.Enabled = true;
// Register behaviours.
foreach (var behaviour in _behaviourRegistration)
{
behaviour(_userInterfaceController);
}
}
}
if (_userInterfaceController != null)
{
_userInterfaceController.Update(gameContext, updateContext);
}
}
public void Render(ComponentizedEntity entity, IGameContext gameContext, IRenderContext renderContext)
{
if (!Enabled)
{
return;
}
if (renderContext.IsCurrentRenderPass <I2DBatchedRenderPass>() && Texture != null)
{
Vector2?size = null;
if (Texture.IsReady)
{
size = new Vector2(
Texture.Asset.Texture.Width * entity.Transform.LocalScale.X,
Texture.Asset.Texture.Width * entity.Transform.LocalScale.Y);
}
var defaultVec = Vector3.Right;
var transformedVec = Vector3.Transform(defaultVec, entity.Transform.LocalRotation);
var twodVec = new Vector2(transformedVec.X, transformedVec.Y);
var rotation = (float)Math.Atan2(twodVec.Y, twodVec.X);
_renderUtilities.RenderTexture(
renderContext,
new Vector2(entity.Transform.LocalPosition.X, entity.Transform.LocalPosition.Y),
Texture,
size,
Color,
rotation,
RotationAnchor,
FlipHorizontally,
FlipVertically,
SourceArea);
}
}
public void Update(ComponentizedEntity entity, IServerContext serverContext, IUpdateContext updateContext)
{
if (_didUpdateSync)
{
return;
}
Update();
}
public void Render(ComponentizedEntity entity, IGameContext gameContext, IRenderContext renderContext)
{
if (!renderContext.Is3DContext && Texture != null)
{
_renderUtilities.RenderTexture(
renderContext,
new Vector2(entity.X, entity.Y),
Texture);
}
}
public void Render(ComponentizedEntity entity, IGameContext gameContext, IRenderContext renderContext)
{
if (!renderContext.Is3DContext && Texture != null)
{
_renderUtilities.RenderTexture(
renderContext,
new Vector2(entity.X, entity.Y),
Texture);
}
}
public void Render(ComponentizedEntity entity, IGameContext gameContext, IRenderContext renderContext)
{
if (!renderContext.Is3DContext && Font != null)
{
_renderUtilities.RenderText(
renderContext,
new Vector2(entity.LocalMatrix.Translation.X, entity.LocalMatrix.Translation.Y),
Text,
Font);
}
}
public void Render(ComponentizedEntity entity, IGameContext gameContext, IRenderContext renderContext)
{
var matrix = Matrix.Identity;
var matrixComponent = _node.Parent?.UntypedValue as IHasMatrix;
if (matrixComponent != null)
{
matrix *= matrixComponent.GetFinalMatrix();
}
_renderUtilities.RenderPlane(renderContext, matrix, Color);
}
public void Update(ComponentizedEntity entity, IGameContext gameContext, IUpdateContext updateContext)
{
if (!Enabled)
{
return;
}
if (_jitterWorld != _physicsEngine.GetInternalPhysicsWorld())
{
// TODO: Deregister rigid bodies from old world.
if (_jitterWorld != null && _physicsControllerConstraint != null)
{
_jitterWorld.RemoveConstraint(_physicsControllerConstraint);
_physicsControllerConstraint = null;
}
_jitterWorld = _physicsEngine.GetInternalPhysicsWorld();
}
if (_physicalComponent.RigidBodies.Length > 0 && _physicalComponent.RigidBodies[0] != _rigidBody)
{
if (_physicsControllerConstraint != null)
{
_jitterWorld.RemoveConstraint(_physicsControllerConstraint);
_physicsControllerConstraint = null;
}
}
if (_physicalComponent.RigidBodies.Length > 0)
{
if (_physicsControllerConstraint == null)
{
_physicsControllerConstraint = new PhysicsControllerConstraint(
_jitterWorld,
_physicalComponent.RigidBodies[0]);
_jitterWorld.AddConstraint(_physicsControllerConstraint);
}
_physicsControllerConstraint.TargetVelocity = TargetVelocity.ToJitterVector();
_physicsControllerConstraint.TryJump = TryJump;
_physicsControllerConstraint.JumpVelocity = JumpVelocity;
_physicsControllerConstraint.Stiffness = Stiffness;
if (TargetVelocity.LengthSquared() > 0f)
{
// Wake up the rigid body.
_physicalComponent.RigidBodies[0].IsActive = true;
}
}
}
public void Update(ComponentizedEntity entity, IGameContext gameContext, IUpdateContext updateContext)
{
if (!Enabled)
{
return;
}
if (_jitterWorld != _physicsEngine.GetInternalPhysicsWorld())
{
// TODO: Deregister rigid bodies from old world.
if (_jitterWorld != null && _physicsControllerConstraint != null)
{
_jitterWorld.RemoveConstraint(_physicsControllerConstraint);
_physicsControllerConstraint = null;
}
_jitterWorld = _physicsEngine.GetInternalPhysicsWorld();
}
if (_physicalComponent.RigidBodies.Length > 0 && _physicalComponent.RigidBodies[0] != _rigidBody)
{
if (_physicsControllerConstraint != null)
{
_jitterWorld.RemoveConstraint(_physicsControllerConstraint);
_physicsControllerConstraint = null;
}
}
if (_physicalComponent.RigidBodies.Length > 0)
{
if (_physicsControllerConstraint == null)
{
_physicsControllerConstraint = new PhysicsControllerConstraint(
_jitterWorld,
_physicalComponent.RigidBodies[0]);
_jitterWorld.AddConstraint(_physicsControllerConstraint);
}
_physicsControllerConstraint.TargetVelocity = TargetVelocity.ToJitterVector();
_physicsControllerConstraint.TryJump = TryJump;
_physicsControllerConstraint.JumpVelocity = JumpVelocity;
_physicsControllerConstraint.Stiffness = Stiffness;
if (TargetVelocity.LengthSquared() > 0f)
{
// Wake up the rigid body.
_physicalComponent.RigidBodies[0].IsActive = true;
}
}
}
public void Render(ComponentizedEntity entity, IGameContext gameContext, IRenderContext renderContext)
{
if (!Enabled)
{
return;
}
if (!renderContext.IsCurrentRenderPass <I3DRenderPass>() && Texture != null)
{
_renderUtilities.RenderTexture(
renderContext,
new Vector2(entity.Transform.LocalPosition.X, entity.Transform.LocalPosition.Y),
Texture);
}
}
public void Render(ComponentizedEntity entity, IGameContext gameContext, IRenderContext renderContext)
{
if (!Enabled)
{
return;
}
if (!renderContext.IsCurrentRenderPass<I3DRenderPass>() && Texture != null)
{
_renderUtilities.RenderTexture(
renderContext,
new Vector2(entity.Transform.LocalPosition.X, entity.Transform.LocalPosition.Y),
Texture);
}
}
public void Prerender(ComponentizedEntity entity, IGameContext gameContext, IRenderContext renderContext)
{
var enabled = Enabled && renderContext.IsCurrentRenderPass <I3DRenderPass>();
var debugEnabled = DebugEnabled && renderContext.IsCurrentRenderPass <IDebugRenderPass>();
if (enabled || DebugEnabled)
{
var parentFinalTransform = (_node?.Parent?.UntypedValue as IHasTransform)?.FinalTransform;
if (parentFinalTransform == null)
{
return;
}
var sourceLocal = HeadOffset;
var lookAtLocal = HeadOffset + Vector3.Transform(Vector3.Forward, Transform.LocalMatrix);
var upLocal = HeadOffset + Vector3.Up;
var sourceAbsolute = Vector3.Transform(sourceLocal, parentFinalTransform.AbsoluteMatrix);
var lookAtAbsolute = Vector3.Transform(lookAtLocal, parentFinalTransform.AbsoluteMatrix);
var upAbsolute = Vector3.Transform(upLocal, parentFinalTransform.AbsoluteMatrix) -
Vector3.Transform(sourceLocal, parentFinalTransform.AbsoluteMatrix);
if (enabled)
{
_firstPersonCamera.Apply(
renderContext,
sourceAbsolute,
lookAtAbsolute,
upAbsolute,
FieldOfView);
}
else if (debugEnabled)
{
_debugRenderer.RenderDebugLine(
renderContext,
sourceAbsolute,
lookAtAbsolute,
Color.Cyan,
Color.Cyan);
_debugRenderer.RenderDebugLine(
renderContext,
sourceAbsolute,
sourceAbsolute + upAbsolute,
Color.Cyan,
Color.Lime);
}
}
}
public void Update(ComponentizedEntity entity, IGameContext gameContext, IUpdateContext updateContext)
{
if (!Enabled)
{
return;
}
if (!_didSetVelocityLastFrame)
{
_firstPersonControllerPhysicsComponent.TargetVelocity = Vector3.Zero;
}
_didSetVelocityLastFrame = false;
_cumulativeMoveX = 0;
_cumulativeMoveZ = 0;
}
public void Update(ComponentizedEntity entity, IGameContext gameContext, IUpdateContext updateContext)
{
if (!Enabled)
{
return;
}
if (!_didSetVelocityLastFrame)
{
_firstPersonControllerPhysicsComponent.TargetVelocity = Vector3.Zero;
}
_didSetVelocityLastFrame = false;
_cumulativeMoveX = 0;
_cumulativeMoveZ = 0;
}
public void Prerender(ComponentizedEntity entity, IGameContext gameContext, IRenderContext renderContext)
{
var enabled = Enabled && renderContext.IsCurrentRenderPass<I3DRenderPass>();
var debugEnabled = DebugEnabled && renderContext.IsCurrentRenderPass<IDebugRenderPass>();
if (enabled || DebugEnabled)
{
var parentFinalTransform = (_node?.Parent?.UntypedValue as IHasTransform)?.FinalTransform;
if (parentFinalTransform == null)
{
return;
}
var sourceLocal = HeadOffset;
var lookAtLocal = HeadOffset + Vector3.Transform(Vector3.Forward, Transform.LocalMatrix);
var upLocal = HeadOffset + Vector3.Up;
var sourceAbsolute = Vector3.Transform(sourceLocal, parentFinalTransform.AbsoluteMatrix);
var lookAtAbsolute = Vector3.Transform(lookAtLocal, parentFinalTransform.AbsoluteMatrix);
var upAbsolute = Vector3.Transform(upLocal, parentFinalTransform.AbsoluteMatrix) -
Vector3.Transform(sourceLocal, parentFinalTransform.AbsoluteMatrix);
if (enabled)
{
_firstPersonCamera.Apply(
renderContext,
sourceAbsolute,
lookAtAbsolute,
upAbsolute,
FieldOfView);
}
else if (debugEnabled)
{
_debugRenderer.RenderDebugLine(
renderContext,
sourceAbsolute,
lookAtAbsolute,
Color.Cyan,
Color.Cyan);
_debugRenderer.RenderDebugLine(
renderContext,
sourceAbsolute,
sourceAbsolute + upAbsolute,
Color.Cyan,
Color.Lime);
}
}
}
public void Render(ComponentizedEntity entity, IGameContext gameContext, IRenderContext renderContext)
{
if (!Enabled)
{
return;
}
if (_physicsControllerConstraint != null && _physicalComponent.RigidBodies.Length > 0)
{
_debugRenderer.RenderDebugLine(
renderContext,
_physicalComponent.RigidBodies[0].Position.ToXNAVector(),
_physicalComponent.RigidBodies[0].Position.ToXNAVector() + TargetVelocity,
Color.Yellow,
Color.Yellow);
}
}
public void Render(ComponentizedEntity entity, IGameContext gameContext, IRenderContext renderContext)
{
if (!Enabled)
{
return;
}
if (renderContext.IsCurrentRenderPass <I3DRenderPass>())
{
var matrix = Matrix.Identity;
var matrixComponent = _node.Parent?.UntypedValue as IHasTransform;
if (matrixComponent != null)
{
matrix *= matrixComponent.FinalTransform.AbsoluteMatrix;
}
_renderUtilities.RenderPlane(renderContext, Effect.Effect, Effect.Effect.CreateParameterSet(), matrix, Color);
}
}
public void Render(ComponentizedEntity entity, IGameContext gameContext, IRenderContext renderContext)
{
if (!Enabled)
{
return;
}
if (renderContext.IsCurrentRenderPass<I3DRenderPass>())
{
var matrix = Matrix.Identity;
var matrixComponent = _node.Parent?.UntypedValue as IHasTransform;
if (matrixComponent != null)
{
matrix *= matrixComponent.FinalTransform.AbsoluteMatrix;
}
_renderUtilities.RenderPlane(renderContext, Effect.Effect, Effect.Effect.CreateParameterSet(), matrix, Color);
}
}
public void Render(ComponentizedEntity entity, IGameContext gameContext, IRenderContext renderContext)
{
if (!Enabled)
{
return;
}
if (renderContext.IsCurrentRenderPass<I3DRenderPass>())
{
_renderUtilities.RenderCube(
renderContext,
Effect,
Effect.CreateParameterSet(),
Matrix.CreateTranslation(-0.5f, -0.5f, -0.5f) *
FinalTransform.AbsoluteMatrix,
Color);
}
}
public void Render(ComponentizedEntity entity, IGameContext gameContext, IRenderContext renderContext)
{
if (!Enabled)
{
return;
}
if (renderContext.IsCurrentRenderPass <I3DRenderPass>())
{
_renderUtilities.RenderCube(
renderContext,
Effect,
Effect.CreateParameterSet(),
Matrix.CreateTranslation(-0.5f, -0.5f, -0.5f) *
FinalTransform.AbsoluteMatrix,
Color);
}
}
public void Update(ComponentizedEntity entity, IGameContext gameContext, IUpdateContext updateContext)
{
if (!_enabled || _serverOnly)
{
return;
}
_localTick++;
_isRunningOnClient = true;
// For all synchronised values, update them with their time machine if they have one.
foreach (var data in _synchronisedData)
{
if (data.Value.TimeMachine != null)
{
data.Value.SetValueDelegate(
data.Value.TimeMachine.Get(_localTick));
}
}
if (!_uniqueIdentifierForEntity.HasValue)
{
// TODO: Support predicted entities here.
// We don't have an identifier provided by the server, so skip all this logic.
return;
}
if (ClientAuthoritiveMode != ClientAuthoritiveMode.None)
{
// This client has some level of authority over the entity, so send data that's important.
switch (ClientAuthoritiveMode)
{
case ClientAuthoritiveMode.TrustClient:
PrepareAndTransmitSynchronisation(entity, _localTick, true, ClientAuthoritiveMode);
break;
case ClientAuthoritiveMode.ReplayInputs:
throw new NotSupportedException("Replaying inputs provided by clients is not yet supported.");
default:
throw new InvalidOperationException("Unknown client authoritivity mode: " + ClientAuthoritiveMode);
}
}
}
public void Update(ComponentizedEntity entity, IGameContext gameContext, IUpdateContext updateContext)
{
if (Texture != null)
{
if (Texture.IsReady)
{
if (Texture.Asset.Texture != _cachedTextureAssetRef)
{
_cachedTextureAssetRef = Texture.Asset.Texture;
_cachedPixelWidth = _cachedTextureAssetRef.Width;
_cachedPixelHeight = _cachedTextureAssetRef.Height;
_cachedPixelData = new Color[_cachedPixelWidth * _cachedPixelHeight];
_cachedTextureAssetRef.GetData(_cachedPixelData);
}
}
}
Update();
}
public void Update(ComponentizedEntity entity, IGameContext gameContext, IUpdateContext updateContext)
{
if (_standardPointLight == null)
{
throw new InvalidOperationException(
"The light was null (presumably because this code is executing on a server), " +
"but the Update method that accepts a game context was called.");
}
var matrix = Matrix.Identity;
var matrixComponent = _node.Parent?.UntypedValue as IHasTransform;
if (matrixComponent != null)
{
matrix *= matrixComponent.FinalTransform.AbsoluteMatrix;
}
_standardPointLight.LightPosition = Vector3.Transform(Vector3.Zero, matrix);
}
public bool ReceiveMessage(ComponentizedEntity entity, IGameContext gameContext, IUpdateContext updateContext, MxDispatcher dispatcher, MxClient server,
byte[] payload, uint protocolId)
{
if (!_enabled)
{
return(false);
}
if (_uniqueIdentifierForEntity == null)
{
return(false);
}
var propertyMessage = _networkMessageSerialization.Deserialize(payload) as EntityPropertiesMessage;
if (propertyMessage == null || propertyMessage.EntityID != _uniqueIdentifierForEntity.Value)
{
return(false);
}
// If the entity is a synchronised entity, collect properties of the synchronised object
// directly.
var synchronisedEntity = entity as ISynchronisedObject;
if (synchronisedEntity != null)
{
_synchronisationContext = synchronisedEntity;
_synchronisationContext.DeclareSynchronisedProperties(this);
}
// Iterate through all the components on the entity and get their synchronisation data as well.
foreach (var synchronisedComponent in entity.Components.OfType <ISynchronisedObject>())
{
_synchronisationContext = synchronisedComponent;
_synchronisationContext.DeclareSynchronisedProperties(this);
}
AssignMessageToSyncData(propertyMessage, _synchronisedData, server.Group);
return(true);
}
public void Render(ComponentizedEntity entity, IGameContext gameContext, IRenderContext renderContext)
{
if (!Enabled)
{
return;
}
if (renderContext.IsCurrentRenderPass <I3DRenderPass>())
{
IEffect effect;
if (Effect != null)
{
effect = Effect;
}
else if (_defaultSurfaceEffect.IsReady)
{
effect = _defaultSurfaceEffect.Asset.Effects?["Color"];
}
else
{
return;
}
if (effect == null)
{
return;
}
var matrix = Matrix.Identity;
var matrixComponent = _node.Parent?.UntypedValue as IHasTransform;
if (matrixComponent != null)
{
matrix *= matrixComponent.FinalTransform.AbsoluteMatrix;
}
_renderUtilities.RenderPlane(renderContext, effect, effect.CreateParameterSet(), matrix, Color);
}
}
public void Render(ComponentizedEntity entity, IGameContext gameContext, IRenderContext renderContext)
{
if (!Enabled)
{
return;
}
if (renderContext.IsCurrentRenderPass <I3DRenderPass>())
{
IEffect effect;
if (Effect != null)
{
effect = Effect;
}
else if (_defaultSurfaceEffect.IsReady)
{
effect = _defaultSurfaceEffect.Asset.Effects?["Color"];
}
else
{
return;
}
if (effect == null)
{
return;
}
_renderUtilities.RenderCube(
renderContext,
effect,
effect.CreateParameterSet(),
Matrix.CreateTranslation(-0.5f, -0.5f, -0.5f) *
FinalTransform.AbsoluteMatrix,
Color);
}
}
public void Update(ComponentizedEntity entity, IGameContext gameContext, IUpdateContext updateContext)
{
if (_standardPointLight == null)
{
throw new InvalidOperationException(
"The light was null (presumably because this code is executing on a server), " +
"but the Update method that accepts a game context was called.");
}
var matrix = Matrix.Identity;
var matrixComponent = _node.Parent?.UntypedValue as IHasTransform;
if (matrixComponent != null)
{
matrix *= matrixComponent.FinalTransform.AbsoluteMatrix;
}
_standardPointLight.LightPosition = Vector3.Transform(Vector3.Zero, matrix);
}
public bool Handle(ComponentizedEntity componentizedEntity, IGameContext gameContext,
IEventEngine<IGameContext> eventEngine, Event @event)
{
if (!Enabled)
{
return false;
}
var gamepadEvent = @event as GamePadEvent;
var keyHeldEvent = @event as KeyHeldEvent;
var mouseEvent = @event as MouseEvent;
if (gamepadEvent != null)
{
_firstPersonCameraComponent.Yaw -= gamepadEvent.GamePadState.ThumbSticks.Right.X*
ThumbstickLookSensitivity;
_firstPersonCameraComponent.Pitch += gamepadEvent.GamePadState.ThumbSticks.Right.Y*
ThumbstickLookSensitivity;
var limit = MathHelper.PiOver2 - MathHelper.ToRadians(5);
_firstPersonCameraComponent.Pitch = MathHelper.Clamp(_firstPersonCameraComponent.Pitch, -limit, limit);
var lookAt = _firstPersonCameraComponent.Transform.LocalMatrix;
var relativeMovementVector = new Vector3(
gamepadEvent.GamePadState.ThumbSticks.Left.X*ThumbstickMoveSensitivity* MovementSpeed,
0f,
-gamepadEvent.GamePadState.ThumbSticks.Left.Y*ThumbstickMoveSensitivity * MovementSpeed);
var absoluteMovementVector =
_firstPersonCameraComponent.ComputeWorldSpaceVectorFromLocalSpace(relativeMovementVector);
_firstPersonControllerPhysicsComponent.TargetVelocity = absoluteMovementVector;
_didSetVelocityLastFrame = true;
return true;
}
if (mouseEvent != null && MouseLock)
{
var centerX = gameContext.Window.ClientBounds.Width/2;
var centerY = gameContext.Window.ClientBounds.Height/2;
_firstPersonCameraComponent.Yaw += (centerX - mouseEvent.MouseState.X)/1000f;
_firstPersonCameraComponent.Pitch += (centerY - mouseEvent.MouseState.Y)/1000f;
var limit = MathHelper.PiOver2 - MathHelper.ToRadians(5);
_firstPersonCameraComponent.Pitch = MathHelper.Clamp(_firstPersonCameraComponent.Pitch, -limit, limit);
Mouse.SetPosition(centerX, centerY);
return true;
}
if (keyHeldEvent != null)
{
var didConsume = false;
var moveX = 0;
var moveZ = 0;
if (keyHeldEvent.Key == Keys.A)
{
_cumulativeMoveX -= 1;
didConsume = true;
}
if (keyHeldEvent.Key == Keys.D)
{
_cumulativeMoveX += 1;
didConsume = true;
}
if (keyHeldEvent.Key == Keys.W)
{
_cumulativeMoveZ += 1;
didConsume = true;
}
if (keyHeldEvent.Key == Keys.S)
{
_cumulativeMoveZ -= 1;
didConsume = true;
}
var relativeMovementVector = new Vector3(
_cumulativeMoveX * ThumbstickMoveSensitivity * MovementSpeed,
0f,
-_cumulativeMoveZ * ThumbstickMoveSensitivity * MovementSpeed);
var absoluteMovementVector =
_firstPersonCameraComponent.ComputeWorldSpaceVectorFromLocalSpace(relativeMovementVector);
_firstPersonControllerPhysicsComponent.TargetVelocity = absoluteMovementVector;
_didSetVelocityLastFrame = true;
return didConsume;
}
return false;
}
public void Update(ComponentizedEntity entity, IServerContext serverContext, IUpdateContext updateContext)
{
Update();
}
public void Update(ComponentizedEntity entity, IServerContext serverContext, IUpdateContext updateContext)
{
Update();
}
public bool Handle(ComponentizedEntity componentizedEntity, IGameContext gameContext,
IEventEngine<IGameContext> eventEngine, Event @event)
{
if (!Enabled)
{
return false;
}
var gamepadEvent = @event as GamePadEvent;
var keyHeldEvent = @event as KeyHeldEvent;
var mouseEvent = @event as MouseEvent;
if (gamepadEvent != null)
{
_firstPersonCameraComponent.Yaw -= gamepadEvent.GamePadState.ThumbSticks.Right.X*
ThumbstickLookSensitivity;
_firstPersonCameraComponent.Pitch += gamepadEvent.GamePadState.ThumbSticks.Right.Y*
ThumbstickLookSensitivity;
var limit = MathHelper.PiOver2 - MathHelper.ToRadians(5);
_firstPersonCameraComponent.Pitch = MathHelper.Clamp(_firstPersonCameraComponent.Pitch, -limit, limit);
var lookAt = _firstPersonCameraComponent.Transform.LocalMatrix;
var relativeMovementVector = new Vector3(
gamepadEvent.GamePadState.ThumbSticks.Left.X*ThumbstickMoveSensitivity,
0f,
-gamepadEvent.GamePadState.ThumbSticks.Left.Y*ThumbstickMoveSensitivity);
var absoluteMovementVector = Vector3.Transform(relativeMovementVector, lookAt);
componentizedEntity.Transform.LocalPosition += absoluteMovementVector;
return true;
}
if (mouseEvent != null)
{
var centerX = gameContext.Window.ClientBounds.Width/2;
var centerY = gameContext.Window.ClientBounds.Height/2;
_firstPersonCameraComponent.Yaw += (centerX - mouseEvent.MouseState.X)/1000f;
_firstPersonCameraComponent.Pitch += (centerY - mouseEvent.MouseState.Y)/1000f;
var limit = MathHelper.PiOver2 - MathHelper.ToRadians(5);
_firstPersonCameraComponent.Pitch = MathHelper.Clamp(_firstPersonCameraComponent.Pitch, -limit, limit);
Mouse.SetPosition(centerX, centerY);
return true;
}
if (keyHeldEvent != null)
{
var didConsume = false;
var moveX = 0;
var moveZ = 0;
if (keyHeldEvent.Key == Keys.A)
{
moveX = -1;
didConsume = true;
}
if (keyHeldEvent.Key == Keys.D)
{
moveX = 1;
didConsume = true;
}
if (keyHeldEvent.Key == Keys.W)
{
moveZ = 1;
didConsume = true;
}
if (keyHeldEvent.Key == Keys.S)
{
moveZ = -1;
didConsume = true;
}
var lookAt = _firstPersonCameraComponent.Transform.LocalMatrix;
var relativeMovementVector = new Vector3(
moveX*ThumbstickMoveSensitivity,
0f,
-moveZ*ThumbstickMoveSensitivity);
var absoluteMovementVector = Vector3.Transform(relativeMovementVector, lookAt);
componentizedEntity.Transform.LocalPosition += absoluteMovementVector;
return didConsume;
}
return false;
}
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);
}
}
}
}
}
private void PrepareAndTransmitSynchronisation(ComponentizedEntity entity, int tick, bool isFromClient, ClientAuthoritiveMode clientAuthoritiveMode)
{
if (!_uniqueIdentifierForEntity.HasValue)
{
throw new InvalidOperationException("PrepareAndTransmit should not be called without an entity ID!");
}
// If the entity is a synchronised entity, collect properties of the synchronised object
// directly.
var synchronisedEntity = entity as ISynchronisedObject;
if (synchronisedEntity != null)
{
_synchronisationContext = synchronisedEntity;
_synchronisationContext.DeclareSynchronisedProperties(this);
}
// Iterate through all the components on the entity and get their synchronisation data as well.
foreach (var synchronisedComponent in entity.Components.OfType <ISynchronisedObject>())
{
_synchronisationContext = synchronisedComponent;
_synchronisationContext.DeclareSynchronisedProperties(this);
}
// Sync properties to each client.
foreach (var dispatcher in _networkEngine.CurrentDispatchers)
{
foreach (var group in dispatcher.ValidClientGroups)
{
if (ClientAuthoritiveMode != ClientAuthoritiveMode.None &&
ClientOwnership != null &&
OnlySendToAuthoritiveClient)
{
if (ClientOwnership != group)
{
// This client doesn't own the entity, and this entity is only
// synchronised with clients that own it.
continue;
}
}
if (isFromClient || _clientsEntityIsKnownOn.Contains(group))
{
if (_synchronisedData.Count > 0)
{
// Now calculate the delta to transmit over the network.
var currentTick = tick; // TODO: Use TimeTick
_synchronisedDataToTransmit.Clear();
foreach (var data in _synchronisedData.Values)
{
var needsSync = false;
// Check the target for this data to see whether or not we send it to
// this particular client.
if (data.SynchronisationTargets == SynchroniseTargets.OwningClient &&
(ClientOwnership == null ||
!(ClientOwnership == group)))
{
// This data should only be synchronised to the owning client, and
// we are not the owning client.
continue;
}
else if (data.SynchronisationTargets == SynchroniseTargets.NonOwningClients &&
(ClientOwnership == null ||
ClientOwnership == group))
{
// This data should only be synchronised to non-owning clients, and
// we either are the owning client, or no client ownership has been set.
continue;
}
// If we're on the client and we haven't had an initial piece of data from the server,
// we never synchronise because we don't know what the initial value is.
if (isFromClient && !data.HasReceivedInitialSync.GetOrDefault(group, false))
{
continue;
}
// If we haven't performed the initial synchronisation, we always transmit the data.
if (!data.HasPerformedInitialSync.GetOrDefault(group, false))
{
_networkEngine.LogSynchronisationEvent(
"Must send property '" + data.Name + "' on entity ID " + _uniqueIdentifierForEntity +
" because the endpoint " + group + " has not received it's initial sync.");
needsSync = true;
}
// If we are on the client (i.e. the client assumes it's authoritive), or if the
// server knows that the client does not have authority, then allow this next section.
// Or to put it another way, if we're not on the client and we know the client has
// authority, only transmit data for the first time because the client will make
// decisions from that point onwards.
if (isFromClient || clientAuthoritiveMode != ClientAuthoritiveMode.TrustClient ||
(clientAuthoritiveMode == ClientAuthoritiveMode.TrustClient &&
group != ClientOwnership))
{
var lastValue = data.LastValue;
var currentValue = data.CurrentValue;
if (lastValue is ITransform)
{
throw new InvalidOperationException(
"Last value property got stored as ITransform, but should have been stored as NetworkTransform!");
}
if (currentValue is ITransform)
{
currentValue = ((ITransform)currentValue).SerializeToNetwork();
}
if (!Equals(lastValue, currentValue))
{
if (data.LastFrameSynced.GetOrDefault(group, 0) + data.FrameInterval < currentTick)
{
_networkEngine.LogSynchronisationEvent(
"Sending property '" + data.Name + "' on entity ID " + _uniqueIdentifierForEntity +
" because the value has changed (old value: " + lastValue + ", new value: " + currentValue + ")," +
" and the next frame synced target for group " + group + "" +
" is " + (data.LastFrameSynced.GetOrDefault(group, 0) + data.FrameInterval) + "" +
" and the current tick is " + currentTick + ".");
needsSync = true;
}
}
}
if (needsSync)
{
_synchronisedDataToTransmit.Add(data);
}
}
if (_synchronisedDataToTransmit.Count > 0)
{
// Build up the synchronisation message.
var message = new EntityPropertiesMessage();
message.EntityID = _uniqueIdentifierForEntity.Value;
message.FrameTick = currentTick;
message.PropertyNames = new string[_synchronisedDataToTransmit.Count];
message.PropertyTypes = new int[_synchronisedDataToTransmit.Count];
message.IsClientMessage = isFromClient;
message.MessageOrder = _messageOrder++;
bool reliable;
AssignSyncDataToMessage(_synchronisedDataToTransmit, message, currentTick, group, out reliable);
// Send an entity properties message to the client.
_networkEngine.Send(
dispatcher,
group,
message,
reliable);
}
}
}
}
}
}
public void Update(ComponentizedEntity entity, IGameContext gameContext, IUpdateContext updateContext)
{
Update();
}
public bool Handle(ComponentizedEntity componentizedEntity, IGameContext gameContext,
IEventEngine <IGameContext> eventEngine, Event @event)
{
if (!Enabled)
{
return(false);
}
var gamepadEvent = @event as GamePadEvent;
var keyHeldEvent = @event as KeyHeldEvent;
var mouseEvent = @event as MouseEvent;
if (gamepadEvent != null)
{
_firstPersonCameraComponent.Yaw -= gamepadEvent.GamePadState.ThumbSticks.Right.X *
ThumbstickLookSensitivity;
_firstPersonCameraComponent.Pitch += gamepadEvent.GamePadState.ThumbSticks.Right.Y *
ThumbstickLookSensitivity;
var limit = MathHelper.PiOver2 - MathHelper.ToRadians(5);
_firstPersonCameraComponent.Pitch = MathHelper.Clamp(_firstPersonCameraComponent.Pitch, -limit, limit);
var lookAt = _firstPersonCameraComponent.Transform.LocalMatrix;
var relativeMovementVector = new Vector3(
gamepadEvent.GamePadState.ThumbSticks.Left.X * ThumbstickMoveSensitivity * MovementSpeed,
0f,
-gamepadEvent.GamePadState.ThumbSticks.Left.Y * ThumbstickMoveSensitivity * MovementSpeed);
var absoluteMovementVector =
_firstPersonCameraComponent.ComputeWorldSpaceVectorFromLocalSpace(relativeMovementVector);
_firstPersonControllerPhysicsComponent.TargetVelocity = absoluteMovementVector;
_didSetVelocityLastFrame = true;
return(true);
}
if (mouseEvent != null && MouseLock)
{
var centerX = gameContext.Window.ClientBounds.Width / 2;
var centerY = gameContext.Window.ClientBounds.Height / 2;
_firstPersonCameraComponent.Yaw += (centerX - mouseEvent.MouseState.X) / 1000f;
_firstPersonCameraComponent.Pitch += (centerY - mouseEvent.MouseState.Y) / 1000f;
var limit = MathHelper.PiOver2 - MathHelper.ToRadians(5);
_firstPersonCameraComponent.Pitch = MathHelper.Clamp(_firstPersonCameraComponent.Pitch, -limit, limit);
Mouse.SetPosition(centerX, centerY);
return(true);
}
if (keyHeldEvent != null)
{
var didConsume = false;
var moveX = 0;
var moveZ = 0;
if (keyHeldEvent.Key == Keys.A)
{
_cumulativeMoveX -= 1;
didConsume = true;
}
if (keyHeldEvent.Key == Keys.D)
{
_cumulativeMoveX += 1;
didConsume = true;
}
if (keyHeldEvent.Key == Keys.W)
{
_cumulativeMoveZ += 1;
didConsume = true;
}
if (keyHeldEvent.Key == Keys.S)
{
_cumulativeMoveZ -= 1;
didConsume = true;
}
var relativeMovementVector = new Vector3(
_cumulativeMoveX * ThumbstickMoveSensitivity * MovementSpeed,
0f,
-_cumulativeMoveZ * ThumbstickMoveSensitivity * MovementSpeed);
var absoluteMovementVector =
_firstPersonCameraComponent.ComputeWorldSpaceVectorFromLocalSpace(relativeMovementVector);
_firstPersonControllerPhysicsComponent.TargetVelocity = absoluteMovementVector;
_didSetVelocityLastFrame = true;
return(didConsume);
}
return(false);
}
public void Update(ComponentizedEntity entity, IServerContext serverContext, IUpdateContext updateContext)
{
if (!_enabled)
{
return;
}
_localTick++;
_isRunningOnClient = false;
if (_uniqueIdentifierForEntity == null)
{
_uniqueIdentifierForEntity = _uniqueIdentifierAllocator.Allocate();
_networkEngine.RegisterObjectAsNetworkId(_uniqueIdentifierForEntity.Value, entity);
}
if (_serverOnly)
{
return;
}
// Sync the entity to the client if it hasn't been already.
foreach (var dispatcher in _networkEngine.CurrentDispatchers)
{
foreach (var group in dispatcher.ValidClientGroups)
{
if (ClientAuthoritiveMode != ClientAuthoritiveMode.None &&
ClientOwnership != null &&
OnlySendToAuthoritiveClient)
{
if (ClientOwnership != group)
{
// This client doesn't own the entity, and this entity is only
// synchronised with clients that own it.
_consoleHandle.LogDebug("Entity is owned by " + ClientOwnership + ", and target client is " + group + " who doesn't own it, so I'm not syncing it.");
continue;
}
}
if (!_clientsEntityIsKnownOn.Contains(group))
{
_consoleHandle.LogDebug("Entity is not known to " + group + ", sending creation message.");
// Send an entity creation message to the client.
var createMessage = new EntityCreateMessage
{
EntityID = _uniqueIdentifierForEntity.Value,
EntityType = entity.GetType().AssemblyQualifiedName,
InitialTransform = entity.Transform.SerializeToNetwork(),
FrameTick = _localTick,
MessageOrder = _messageOrder++,
};
_networkEngine.Send(
dispatcher,
group,
createMessage,
true);
_clientsEntityIsKnownOn.Add(group);
}
}
}
PrepareAndTransmitSynchronisation(entity, _localTick, false, ClientAuthoritiveMode);
}
public void Update(ComponentizedEntity entity, IGameContext gameContext, IUpdateContext updateContext)
{
Update();
}
public void Render(ComponentizedEntity entity, IGameContext gameContext, IRenderContext renderContext)
{
if (!Enabled)
{
return;
}
if (renderContext.IsCurrentRenderPass<I3DRenderPass>())
{
if (Effect == null)
{
_useDefaultEffects = true;
}
else
{
_useDefaultEffects = false;
}
if (_useDefaultEffects && _uberEffectAsset == null)
{
_uberEffectAsset = _assetManager.Get<UberEffectAsset>("effect.BuiltinSurface");
}
if (Model != null)
{
var matrix = FinalTransform.AbsoluteMatrix;
bool changedRenderRequest = _lastWorldMatrix != matrix;
string changedRenderRequestBy = changedRenderRequest ? "matrix" : "";
var material = OverrideMaterial ?? _model.Material;
UpdateCachedModel(material, ref changedRenderRequest, ref changedRenderRequestBy);
var effect = GetEffect(ref changedRenderRequest, ref changedRenderRequestBy);
var parameterSet = GetEffectParameterSet(material, ref changedRenderRequest, ref changedRenderRequestBy);
var animation = GetModelAnimation(ref changedRenderRequest, ref changedRenderRequestBy);
if (animation != null)
{
animation.Apply(_model, _animationTracker.ElapsedMilliseconds / 1000f, 0.5f);
_renderRequest = _model.CreateRenderRequest(renderContext, effect, parameterSet, matrix);
}
else if (changedRenderRequest || _renderRequest == null)
{
_renderRequest = _model.CreateRenderRequest(renderContext, effect, parameterSet, matrix);
}
_lastWorldMatrix = matrix;
_renderBatcher.QueueRequest(
renderContext,
_renderRequest);
}
else
{
_lastCachedModel = null;
_lastCachedDiffuseTexture = null;
}
}
}
public void Render(ComponentizedEntity entity, IGameContext gameContext, IRenderContext renderContext)
{
if (!Enabled)
{
return;
}
if (_physicsControllerConstraint != null && _physicalComponent.RigidBodies.Length > 0)
{
_debugRenderer.RenderDebugLine(
renderContext,
_physicalComponent.RigidBodies[0].Position.ToXNAVector(),
_physicalComponent.RigidBodies[0].Position.ToXNAVector() + TargetVelocity,
Color.Yellow,
Color.Yellow);
}
}
public bool Handle(ComponentizedEntity componentizedEntity, IGameContext gameContext,
IEventEngine <IGameContext> eventEngine, Event @event)
{
if (!Enabled)
{
return(false);
}
var gamepadEvent = @event as GamePadEvent;
var keyHeldEvent = @event as KeyHeldEvent;
var mouseEvent = @event as MouseEvent;
if (gamepadEvent != null)
{
_firstPersonCameraComponent.Yaw -= gamepadEvent.GamePadState.ThumbSticks.Right.X *
ThumbstickLookSensitivity;
_firstPersonCameraComponent.Pitch += gamepadEvent.GamePadState.ThumbSticks.Right.Y *
ThumbstickLookSensitivity;
var limit = MathHelper.PiOver2 - MathHelper.ToRadians(5);
_firstPersonCameraComponent.Pitch = MathHelper.Clamp(_firstPersonCameraComponent.Pitch, -limit, limit);
var lookAt = _firstPersonCameraComponent.Transform.LocalMatrix;
var relativeMovementVector = new Vector3(
gamepadEvent.GamePadState.ThumbSticks.Left.X * ThumbstickMoveSensitivity,
0f,
-gamepadEvent.GamePadState.ThumbSticks.Left.Y * ThumbstickMoveSensitivity);
var absoluteMovementVector = Vector3.Transform(relativeMovementVector, lookAt);
componentizedEntity.Transform.LocalPosition += absoluteMovementVector;
return(true);
}
if (mouseEvent != null)
{
var centerX = gameContext.Window.ClientBounds.Width / 2;
var centerY = gameContext.Window.ClientBounds.Height / 2;
_firstPersonCameraComponent.Yaw += (centerX - mouseEvent.MouseState.X) / 1000f;
_firstPersonCameraComponent.Pitch += (centerY - mouseEvent.MouseState.Y) / 1000f;
var limit = MathHelper.PiOver2 - MathHelper.ToRadians(5);
_firstPersonCameraComponent.Pitch = MathHelper.Clamp(_firstPersonCameraComponent.Pitch, -limit, limit);
Mouse.SetPosition(centerX, centerY);
return(true);
}
if (keyHeldEvent != null)
{
var didConsume = false;
var moveX = 0;
var moveZ = 0;
if (keyHeldEvent.Key == Keys.A)
{
moveX = -1;
didConsume = true;
}
if (keyHeldEvent.Key == Keys.D)
{
moveX = 1;
didConsume = true;
}
if (keyHeldEvent.Key == Keys.W)
{
moveZ = 1;
didConsume = true;
}
if (keyHeldEvent.Key == Keys.S)
{
moveZ = -1;
didConsume = true;
}
var lookAt = _firstPersonCameraComponent.Transform.LocalMatrix;
var relativeMovementVector = new Vector3(
moveX * ThumbstickMoveSensitivity,
0f,
-moveZ * ThumbstickMoveSensitivity);
var absoluteMovementVector = Vector3.Transform(relativeMovementVector, lookAt);
componentizedEntity.Transform.LocalPosition += absoluteMovementVector;
return(didConsume);
}
return(false);
}
public bool ReceiveMessage(ComponentizedEntity entity, IServerContext serverContext, IUpdateContext updateContext, MxDispatcher dispatcher, MxClient client, byte[] payload, uint protocolId)
{
if (!_enabled)
{
return(false);
}
if (_uniqueIdentifierForEntity == null)
{
return(false);
}
// See what kind of messages we accept, based on the client authority.
switch (ClientAuthoritiveMode)
{
case ClientAuthoritiveMode.None:
// We don't accept any client data about this entity, so ignore it.
return(false);
case ClientAuthoritiveMode.TrustClient:
{
// Check to see if the message is coming from a client that has authority.
if (ClientOwnership != null && ClientOwnership != client.Group)
{
// We don't trust this message.
return(false);
}
// We trust the client, so process this information like a client would.
var propertyMessage = _networkMessageSerialization.Deserialize(payload) as EntityPropertiesMessage;
if (propertyMessage == null || propertyMessage.EntityID != _uniqueIdentifierForEntity.Value)
{
return(false);
}
// If the entity is a synchronised entity, collect properties of the synchronised object
// directly.
var synchronisedEntity = entity as ISynchronisedObject;
if (synchronisedEntity != null)
{
_synchronisationContext = synchronisedEntity;
_synchronisationContext.DeclareSynchronisedProperties(this);
}
// Iterate through all the components on the entity and get their synchronisation data as well.
foreach (var synchronisedComponent in entity.Components.OfType <ISynchronisedObject>())
{
_synchronisationContext = synchronisedComponent;
_synchronisationContext.DeclareSynchronisedProperties(this);
}
AssignMessageToSyncData(propertyMessage, _synchronisedData, client.Group);
return(true);
}
case ClientAuthoritiveMode.ReplayInputs:
// We don't implement this yet, but we don't want to allow client packets to cause
// a server error, so silently consume it.
return(false);
}
return(false);
}
public void Render(ComponentizedEntity entity, IGameContext gameContext, IRenderContext renderContext)
{
if (!Enabled)
{
return;
}
if (renderContext.IsCurrentRenderPass <I3DRenderPass>())
{
if (Effect == null)
{
_useDefaultEffects = true;
}
else
{
_useDefaultEffects = false;
}
if (_useDefaultEffects && _uberEffectAsset == null)
{
_uberEffectAsset = _assetManager.Get <UberEffectAsset>("effect.BuiltinSurface");
}
if (Model != null)
{
var matrix = FinalTransform.AbsoluteMatrix;
bool changedRenderRequest = _lastWorldMatrix != matrix;
string changedRenderRequestBy = changedRenderRequest ? "matrix" : "";
var material = OverrideMaterial ?? _model.Material;
UpdateCachedModel(material, ref changedRenderRequest, ref changedRenderRequestBy);
var effect = GetEffect(ref changedRenderRequest, ref changedRenderRequestBy);
var parameterSet = GetEffectParameterSet(material, ref changedRenderRequest, ref changedRenderRequestBy);
var animation = GetModelAnimation(ref changedRenderRequest, ref changedRenderRequestBy);
if (animation != null)
{
animation.Apply(_model, _animationTracker.ElapsedMilliseconds / 1000f, 0.5f);
_renderRequest = _model.CreateRenderRequest(renderContext, effect, parameterSet, matrix);
}
else if (changedRenderRequest || _renderRequest == null)
{
_renderRequest = _model.CreateRenderRequest(renderContext, effect, parameterSet, matrix);
}
_lastWorldMatrix = matrix;
_renderBatcher.QueueRequest(
renderContext,
_renderRequest);
}
else
{
_lastCachedModel = null;
_lastCachedDiffuseTexture = null;
}
}
}
