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