public static bool IsBehindCamera(Vector3 point, IViewPoint viewPoint)
{
var cornerDirection = Vector3.Normalize(point - viewPoint.Position);
var dot = Vector3.Dot(viewPoint.Forward, cornerDirection);
return(dot < 0);
}
public ModelBatchList ComputeBatches(IViewPoint viewPoint, TextureCube skybox)
{
var transparentBatches = new List <ModelRenderBatch>(this.TransparentModels.Count);
var transparentModels = this.SortBackToFront(this.TransparentModels, viewPoint);
var batches = this.ComputeBatches(transparentModels, viewPoint);
for (var i = 0; i < batches.Count; i++)
{
transparentBatches.Add(new ModelRenderBatch(batches[i], viewPoint, skybox));
}
this.OpaqueModelBatchList.Clear();
for (var i = 0; i < this.OpaqueModels.Count; i++)
{
var model = this.OpaqueModels[i];
var bounds = this.Bounds.Get(model.Entity);
if (bounds.IsInView)
{
var pose = this.Poses.Get(model.Entity);
var modelPose = new ModelPose(model, pose);
this.OpaqueModelBatchList.Add(modelPose);
}
}
return(new ModelBatchList(new ModelRenderBatch(this.OpaqueModelBatchList, viewPoint, skybox), transparentBatches));
}
public ShadowMap Construct(Entity entity, IViewPoint viewPoint, int resolution = DefaultResolution)
{
var depthMap = new RenderTarget2D(
this.Device,
resolution,
resolution,
false,
SurfaceFormat.Single,
DepthFormat.Depth24,
0,
RenderTargetUsage.DiscardContents,
false);
var colorMap = new RenderTarget2D(
this.Device,
resolution,
resolution,
false,
SurfaceFormat.Color,
DepthFormat.None,
0,
RenderTargetUsage.DiscardContents,
false);
var shadowMap = new ShadowMap(entity, depthMap, colorMap, 0, viewPoint);
this.Container.Add(shadowMap);
return(shadowMap);
}
protected void DrawModel(Effect effectOverride, Model model, Matrix world, IViewPoint viewpoint)
{
effectOverride.Parameters["World"].SetValue(world);
effectOverride.Parameters["View"].SetValue(viewpoint.View);
effectOverride.Parameters["Projection"].SetValue(viewpoint.Projection);
foreach (var mesh in model.Meshes)
{
var effects = new Effect[mesh.MeshParts.Count];
for (var i = 0; i < mesh.MeshParts.Count; i++)
{
var part = mesh.MeshParts[i];
effects[i] = part.Effect;
part.Effect = effectOverride;
}
mesh.Draw();
for (var i = 0; i < mesh.MeshParts.Count; i++)
{
var part = mesh.MeshParts[i];
part.Effect = effects[i];
}
}
}
public ModelRenderBatch(IReadOnlyList <AModel> models, IViewPoint viewPoint, TextureCube skybox)
{
this.Models = models;
this.ViewPoint = viewPoint;
this.Skybox = skybox;
this.Effect = new RenderEffect();
var viewProjection = viewPoint.View * viewPoint.Projection;
this.InverseViewProjection = Matrix.Invert(viewProjection);
}
protected void DrawModel(Model model, Matrix world, IViewPoint viewPoint)
{
foreach (var mesh in model.Meshes)
{
foreach (var effect in mesh.Effects)
{
effect.Parameters["World"].SetValue(world);
effect.Parameters["View"].SetValue(viewPoint.View);
effect.Parameters["Projection"].SetValue(viewPoint.Projection);
}
mesh.Draw();
}
}
public static void GatherParticles <T>(IComponentContainer <T> emitters, IViewPoint viewPoint, List <ParticlePose> particlesOut)
where T : AEmitter
{
for (var iEmitter = 0; iEmitter < emitters.Count; iEmitter++)
{
var emitter = emitters[iEmitter];
for (var iParticle = 0; iParticle < emitter.Particles.Count; iParticle++)
{
var particle = emitter.Particles[iParticle];
var particlePose = ComputePose(viewPoint, emitter, particle);
particlesOut.Add(particlePose);
}
}
}
private static ParticlePose ComputePose(IViewPoint viewPoint, AEmitter emitter, Particle particle)
{
var matrix = Matrix.CreateScale(particle.Scale)
* Matrix.CreateBillboard(particle.Position, viewPoint.Position, Vector3.Up, viewPoint.Forward);
GetFrame(particle.Frame, emitter.Rows, emitter.Columns, out var minUvs, out var maxUvs);
return(new ParticlePose(
minUvs,
maxUvs,
emitter.Texture,
matrix,
Vector3.Distance(particle.Position, viewPoint.Position),
particle.Tint));
}
public void UpdateViewpoint(IViewPoint viewPoint)
{
ViewPoint view = viewPoint as ViewPoint;
if (view == null)
{
throw new InvalidOperationException("viewPoint must be derivative of ViewPoint type");
}
unsafe
{
int res = LibVlcMethods.libvlc_video_update_viewpoint(m_hMediaPlayer, (libvlc_video_viewpoint_t *)view.Pointer.ToPointer(), true);
if (res == -1)
{
throw new LibVlcException("Failed to update view point");
}
}
}
private void RenderGBuffer(IViewPoint viewPoint)
{
this.Device.SetRenderTargets(this.ColorTarget, this.NormalTarget, this.DepthTarget);
using (this.Device.PostProcessState())
{
foreach (var pass in this.ClearEffect.Techniques[0].Passes)
{
pass.Apply();
this.Quad.Render(this.Device);
}
}
using (this.Device.GeometryState())
{
this.Scene.Draw(viewPoint);
}
this.Device.SetRenderTargets(null);
}
public ModelBatchList ComputeBatches(IViewPoint viewPoint)
{
var transparentBatches = new List <ModelRenderBatch>(this.TransparentModels.Count);
var transparentModels = SortBackToFront(this.TransparentModels, viewPoint);
var batches = ComputeBatches(transparentModels, viewPoint);
for (var i = 0; i < batches.Count; i++)
{
transparentBatches.Add(new ModelRenderBatch(batches[i], viewPoint));
}
this.OpaqueModelBatchList.Clear();
for (var i = 0; i < this.OpaqueModels.Count; i++)
{
this.OpaqueModelBatchList.Add(this.OpaqueModels[i]);
}
return(new ModelBatchList(new ModelRenderBatch(this.OpaqueModelBatchList, viewPoint), transparentBatches));
}
private IReadOnlyList <List <ModelPose> > ComputeBatches(List <AModel> models, IViewPoint viewPoint)
{
var batches = new List <List <ModelPose> >();
var currentBatch = new List <ModelPose>();
var currentBounds = new BoundingRectangle();
for (var i = 0; i < models.Count; i++)
{
var model = models[i];
var bounds = this.Bounds.Get(model.Entity);
var pose = this.Poses.Get(model.Entity);
var modelPose = new ModelPose(model, pose);
var boundingRectangle = BoundingRectangle.CreateFromProjectedBoundingBox(bounds.BoundingBox, viewPoint);
if (currentBatch.Count == 0)
{
currentBounds = boundingRectangle;
currentBatch.Add(modelPose);
}
else if (boundingRectangle.Intersects(currentBounds))
{
batches.Add(currentBatch);
currentBatch = new List <ModelPose> {
modelPose
};
currentBounds = boundingRectangle;
}
else
{
currentBatch.Add(modelPose);
currentBounds = BoundingRectangle.CreateMerged(currentBounds, boundingRectangle);
}
}
if (currentBatch.Count > 0)
{
batches.Add(currentBatch);
}
return(batches);
}
private void DrawModel(RenderEffectTechniques technique, Model model, Matrix world, IViewPoint viewPoint)
{
var bones = model.Bones.Count;
if (SharedBoneMatrix is null || SharedBoneMatrix.Length < bones)
{
SharedBoneMatrix = new Matrix[bones];
}
model.CopyAbsoluteBoneTransformsTo(SharedBoneMatrix);
for (var iMesh = 0; iMesh < model.Meshes.Count; iMesh++)
{
var mesh = model.Meshes[iMesh];
for (var iEffect = 0; iEffect < mesh.Effects.Count; iEffect++)
{
var effect = mesh.Effects[iEffect];
this.Effect.Wrap(effect);
this.Effect.World = SharedBoneMatrix[mesh.ParentBone.Index] * world;
this.Effect.View = viewPoint.View;
this.Effect.Projection = viewPoint.Projection;
this.Effect.Apply(technique);
}
mesh.Draw();
}
}
public ModelRenderBatch(IReadOnlyList <AModel> models, IViewPoint viewPoint)
{
this.Models = models;
this.ViewPoint = viewPoint;
this.Effect = new RenderEffect();
}
public void Close(IViewPoint viewPoint) => this.State.Serialize(viewPoint.Position, viewPoint.Position + viewPoint.Forward);
public override void Draw(Effect effectOverride, IViewPoint viewPoint)
{
DrawModel(effectOverride, this.ship1, Matrix.CreateRotationY(MathHelper.Pi) * Matrix.CreateScale(0.5f), viewPoint);
DrawModel(effectOverride, this.lizard, Matrix.CreateRotationY(MathHelper.Pi) * Matrix.CreateScale(0.05f) * Matrix.CreateTranslation(Vector3.Left * 50), viewPoint);
DrawModel(effectOverride, this.ship2, Matrix.CreateRotationX(-MathHelper.PiOver2) * Matrix.CreateRotationY(MathHelper.Pi) * Matrix.CreateScale(0.5f) * Matrix.CreateTranslation(Vector3.Right * 50), viewPoint);
}
private List <AModel> SortBackToFront(IComponentContainer <TransparentModel> models, IViewPoint viewPoint)
{
var modeList = new List <AModel>();
var distanceList = new List <float>();
for (var i = 0; i < models.Count; i++)
{
var model = models[i];
var bounds = this.Bounds.Get(model.Entity);
var viewPosition = Vector4.Transform(bounds.Center, viewPoint.Frustum.Matrix);
// Apply the perspective division
var distance = viewPosition.Z / viewPosition.W;
InsertBackToFront(modeList, distanceList, model, distance);
}
return(modeList);
}
public abstract void Draw(Effect effectOverride, IViewPoint viewPoint);
private static IReadOnlyList <List <AModel> > ComputeBatches(List <AModel> models, IViewPoint viewPoint)
{
var batches = new List <List <AModel> >();
var currentBatch = new List <AModel>();
var currentBounds = new BoundingRectangle();
for (var i = 0; i < models.Count; i++)
{
var model = models[i];
var bounds = BoundingRectangle.CreateFromProjectedBoundingBox(
model.BoundingBox,
viewPoint);
if (currentBatch.Count == 0)
{
currentBounds = bounds;
currentBatch.Add(model);
}
else if (bounds.Intersects(currentBounds))
{
batches.Add(currentBatch);
currentBatch = new List <AModel> {
model
};
currentBounds = bounds;
}
else
{
currentBatch.Add(model);
currentBounds = BoundingRectangle.CreateMerged(currentBounds, bounds);
}
}
if (currentBatch.Count > 0)
{
batches.Add(currentBatch);
}
return(batches);
}
private static List <AModel> SortBackToFront(IComponentContainer <TransparentModel> models, IViewPoint viewPoint)
{
var modeList = new List <AModel>();
var distanceList = new List <float>();
for (var i = 0; i < models.Count; i++)
{
var model = models[i];
if (viewPoint.Frustum.Intersects(model.BoundingSphere))
{
var viewPosition = Vector4.Transform(model.BoundingSphere.Center, viewPoint.Frustum.Matrix);
// Apply the perspective division
var distance = viewPosition.Z / viewPosition.W;
InsertBackToFront(modeList, distanceList, model, distance);
}
}
return(modeList);
}
public static BoundingRectangle CreateFromProjectedBoundingBox(BoundingBox box, IViewPoint viewPoint)
{
var minX = float.MaxValue;
var maxX = float.MinValue;
var minY = float.MaxValue;
var maxY = float.MinValue;
var corners = box.GetCorners();
for (var i = 0; i < corners.Length; i++)
{
var corner = corners[i];
var projectedCorner = ProjectionMath.WorldToView(corner, viewPoint.View * viewPoint.Projection);
minX = Math.Min(minX, projectedCorner.X);
maxX = Math.Max(maxX, projectedCorner.X);
minY = Math.Min(minY, projectedCorner.Y);
maxY = Math.Max(maxY, projectedCorner.Y);
}
return(new BoundingRectangle(minX, maxX, minY, maxY));
}
public override void Draw(IViewPoint viewPoint)
{
DrawModel(this.sponza, this.World, viewPoint);
}
public override void Draw(Effect effectOverride, IViewPoint viewPoint)
{
DrawModel(effectOverride, this.sponza, this.World, viewPoint);
}
internal ShadowMap Construct(Entity entity, RenderTarget2D depthMapArray, RenderTarget2D colorMapArray, int index, IViewPoint viewPoint)
{
var shadowMap = new ShadowMap(entity, depthMapArray, colorMapArray, index, viewPoint);
this.Container.Add(shadowMap);
return(shadowMap);
}
private void DrawModel(RenderEffectTechniques technique, AModel modelPose, Matrix world, IViewPoint viewPoint)
{
var model = modelPose.Model;
var bones = model.Bones.Count;
if (SharedBoneMatrix is null || SharedBoneMatrix.Length < bones)
{
SharedBoneMatrix = new Matrix[bones];
}
model.CopyAbsoluteBoneTransformsTo(SharedBoneMatrix);
for (var iMesh = 0; iMesh < model.Meshes.Count; iMesh++)
{
var mesh = model.Meshes[iMesh];
for (var iEffect = 0; iEffect < mesh.Effects.Count; iEffect++)
{
var effect = mesh.Effects[iEffect];
this.Effect.Wrap(effect);
if (modelPose.HasAnimations && RenderEffect.TechniqueSupportsSkinning(technique))
{
technique = RenderEffect.GetSkinnedTechnique(technique);
this.Effect.BoneTransforms = modelPose.SkinTransforms;
}
this.Effect.TextureOffset = modelPose.UVOffsets[iMesh];
this.Effect.World = SharedBoneMatrix[mesh.ParentBone.Index] * world;
this.Effect.View = viewPoint.View;
this.Effect.Projection = viewPoint.Projection;
this.Effect.InverseViewProjection = this.InverseViewProjection;
this.Effect.Skybox = this.Skybox;
this.Effect.CameraPosition = viewPoint.Position;
this.Effect.TextureScale = modelPose.TextureScale;
this.Effect.Apply(technique);
}
mesh.Draw();
}
}
public ShadowMap(Entity entity, RenderTarget2D depthMap, RenderTarget2D colorMap, int index, IViewPoint viewPoint)
{
this.Entity = entity;
this.DepthMap = depthMap;
this.ColorMap = colorMap;
this.Index = index;
this.ViewPoint = viewPoint;
}
public abstract void Draw(IViewPoint viewPoint);
