/// <inheritdoc/>
protected override bool IsToRender(PositionableRenderable body)
{
#region Sanity checks
if (body == null)
{
throw new ArgumentNullException(nameof(body));
}
#endregion
switch (body.RenderIn)
{
case ViewType.All:
case ViewType.SupportOnly:
return(true);
case ViewType.GlowOnly:
return(Name.EndsWith(" Glow", StringComparison.OrdinalIgnoreCase));
case ViewType.NormalOnly:
return(false);
default:
throw new ArgumentException("Invalid ViewType!", nameof(body));
}
}
/// <summary>
/// Pick an <see cref="PositionableRenderable"/> in 3D-space using the mouse
/// </summary>
/// <param name="location">The screen space location to start the ray from (usually mouse coordinates)</param>
/// <param name="position">Returns the position of the vertex closest to the intersection in entity space</param>
/// <returns>The picked <see cref="PositionableRenderable"/> or <c>null</c>.</returns>
public PositionableRenderable Pick(Point location, out DoubleVector3 position)
{
Ray pickingRay = PickingRay(location);
PositionableRenderable closestBody = null;
float closestDistance = float.MaxValue;
foreach (PositionableRenderable body in _sortedBodies)
{
// Find bodies that intersect the ray
float distance;
if (body.Pickable && body.Intersects(pickingRay, out distance))
{
// Check if new hit is closer that the previous best
if (distance < closestDistance)
{
closestBody = body;
closestDistance = distance;
}
}
}
if (closestBody == null)
{
position = default(DoubleVector3);
}
else
{
// Calculate position along the ray and compensate for position offset
position = (pickingRay.Position + closestDistance * pickingRay.Direction) - ((IPositionableOffset)closestBody).Offset;
}
return(closestBody);
}
private void ConfigureParticleSystem(Entity entity, PositionableRenderable particleSystem, ParticleSystem component)
{
particleSystem.Name = entity.Name;
particleSystem.PreTransform = Matrix.Translation(component.Shift);
particleSystem.VisibilityDistance = component.VisibilityDistance;
particleSystem.Wireframe = WireframeEntities;
particleSystem.DrawBoundingSphere = BoundingSphereEntities;
particleSystem.DrawBoundingBox = BoundingBoxEntities;
}
private readonly List <PositionableRenderable> _sortedOpaqueBodies = new List <PositionableRenderable>(30); // Use educated guess for list capacity
#endregion
#region Sorting algorithms
/// <summary>
/// The difference between the distance of <paramref name="body1"/> and <paramref name="body2"/> to the camera
/// </summary>
/// <returns>The inverted difference value usable for sorting</returns>
private static int CameraDistSort(PositionableRenderable body1, PositionableRenderable body2)
{
double distance = body1.CurrentCameraDistance - body2.CurrentCameraDistance;
if (distance > int.MaxValue - 1)
{
return(int.MaxValue);
}
if (distance < int.MinValue + 2)
{
return(int.MinValue + 1);
}
return((int)distance);
}
/// <summary>
/// Renders a <see cref="PositionableRenderable"/> from the <see cref="Scene"/>
/// </summary>
/// <param name="body">The <see cref="PositionableRenderable"/> to render</param>
protected virtual void RenderBody(PositionableRenderable body)
{
#region Sanity checks
if (body == null)
{
throw new ArgumentNullException(nameof(body));
}
#endregion
// Apply the camera offset to make sure positioning is right
ApplyCameraBase(body);
using (new ProfilerEvent(() => "Render " + body))
body.Render(Camera, Scene.GetEffectiveLights);
}
/// <summary>
/// Applies the position and rotation of a Model element to a View representation.
/// </summary>
protected void UpdateRepresentation(Entity element, PositionableRenderable representation)
{
#region Sanity checks
if (element == null)
{
throw new ArgumentNullException(nameof(element));
}
if (representation == null)
{
throw new ArgumentNullException(nameof(representation));
}
#endregion
representation.Position = Universe.Terrain.ToEngineCoords(element.Position);
representation.Rotation = Quaternion.RotationYawPitchRoll(element.Rotation.DegreeToRadian(), 0, 0);
}
/// <summary>
/// Swings the camera to look at a specifc <see cref="PositionableRenderable"/>.
/// </summary>
public void SwingCameraTo(PositionableRenderable target)
{
#region Sanity checks
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
#endregion
SwingCameraTo(new CameraState <Vector2>
{
Name = View.Camera.Name,
Position = target.Position.Flatten(),
Radius = target.WorldBoundingSphere.HasValue ? target.WorldBoundingSphere.Value.Radius * 2.5f : 50,
});
}
//--------------------//
#region Render body
/// <inheritdoc/>
protected override void RenderBody(PositionableRenderable body)
{
#region Sanity checks
if (body == null)
{
throw new ArgumentNullException(nameof(body));
}
#endregion
// Backup the current surface effect and replace it by a special one for depth
SurfaceEffect surfaceEffect = body.SurfaceEffect;
body.SurfaceEffect = SurfaceEffect.Depth;
base.RenderBody(body);
// Restore the original surface effect
body.SurfaceEffect = surfaceEffect;
}
//--------------------//
#region Visibility check
/// <inheritdoc/>
protected override bool IsToRender(PositionableRenderable body)
{
#region Sanity checks
if (body == null)
{
throw new ArgumentNullException(nameof(body));
}
#endregion
// Filter bodies if this is a terrain-only reflection
if (Reflection && Engine.Effects.WaterEffects <= WaterEffectsType.ReflectTerrain && !(body is Terrain))
{
return(false);
}
// Perform the the more generic tests
return(base.IsToRender(body));
}
private void ConfigureModel(PositionableRenderable model, Mesh component)
{
model.PreTransform = Matrix.Scaling(component.Scale, component.Scale, component.Scale) *
Matrix.RotationYawPitchRoll(
component.RotationY.DegreeToRadian(),
component.RotationX.DegreeToRadian(),
component.RotationZ.DegreeToRadian()) *
Matrix.Translation(component.Shift);
model.Alpha = component.Alpha;
model.Pickable = component.Pickable;
model.RenderIn = (ViewType)component.RenderIn;
if (Lighting)
{
model.SurfaceEffect = SurfaceEffect.Shader;
}
model.Wireframe = WireframeEntities;
model.DrawBoundingSphere = BoundingSphereEntities;
model.DrawBoundingBox = BoundingBoxEntities;
}
/// <summary>
/// Checks if a <see cref="PositionableRenderable"/> is supposed to be rendered in this type of <see cref="View"/>
/// </summary>
/// <param name="body">The <see cref="PositionableRenderable"/> to check</param>
/// <returns><c>true</c> if the <see cref="PositionableRenderable"/> is supposed to be rendered</returns>
protected virtual bool IsToRender(PositionableRenderable body)
{
#region Sanity checks
if (body == null)
{
throw new ArgumentNullException(nameof(body));
}
#endregion
switch (body.RenderIn)
{
case ViewType.All:
case ViewType.NormalOnly:
return(true);
case ViewType.SupportOnly:
case ViewType.GlowOnly:
return(false);
default:
throw new ArgumentException("Invalid ViewType!", nameof(body));
}
}
