예제 #1
0
        public void CullMeshes(ref ChunkCoordinate current, ref BoundingFrustum frustum)
        {
            BoundingBox box;
            if (!current.Equals(ref _previous))
            {
                _solidMeshes.Sort((x, y) => x.Position.LengthSquared().CompareTo(y.Position.LengthSquared()));
                _transparentMeshes.Sort((x, y) => -x.Position.LengthSquared().CompareTo(y.Position.LengthSquared()));
            }

            for (int i = 0; i < _solidMeshes.Count; i++)
            {
                _solidMeshes[i].GetBoundingBox(out box);
                if (frustum.Contains(box) != ContainmentType.Disjoint)
                {
                    _solidMeshRenderQueue.Enqueue(_solidMeshes[i]);
                }
            }

            for (int i = 0; i < _transparentMeshes.Count; i++)
            {
               _transparentMeshes[i].GetBoundingBox(out box);
               if (frustum.Contains(box) != ContainmentType.Disjoint)
               {
                   _transparentMeshRenderQueue.Enqueue(_transparentMeshes[i]);
               }
            }
        }
예제 #2
0
        /// <summary>
        /// Vykreslí jeden snímek trojrozměrného světa.
        /// </summary>
        public void Draw()
        {
            if (_body3Ds.Count > 0 || _backdrop3Ds.Count > 0)
            {
                _boundingFrustum = new BoundingFrustum(Camera3D.View * Camera3D.Projection);
            }

            if (_body3Ds.Count > 0)
            {
                for (int i = 0; i < _body3Ds.Count; i++)
                {
                    _body3Ds[i].Update3DPosition();

                    if (_boundingFrustum.Contains(_body3Ds[i].BoundingSphere) != ContainmentType.Disjoint)
                    {
                        //Těleso je uvnitř promítacího kuželu, potom se vždy simuluje a vykresluje
                        _body3Ds[i].EnableSimulation();
                        _body3Ds[i].Draw(Camera3D);
                    }
                    else
                    {
                        //Těleso není uvnitř promítacího kuželu
                        //Chce uživatel v této situaci neprovádět simulaci?
                        if (DisableSimulationWhenOutOfBoundingFrustum)
                        {
                            _body3Ds[i].DisableSimulation();
                        }
                    }
                }
            }

            if (_backdrop3Ds.Count > 0)
            {
                for (int i = 0; i < _backdrop3Ds.Count; i++)
                {
                    if (_boundingFrustum.Contains(_backdrop3Ds[i].BoundingSphere) != ContainmentType.Disjoint)
                    {
                        _backdrop3Ds[i].Draw(Camera3D);
                    }
                }
            }
        }
예제 #3
0
 public bool IsInVolume(BoundingFrustum frustum)
 {
     if (frustum.Contains(masterRegion.RegionBox) != ContainmentType.Disjoint)
     {
         return(true);
     }
     else
     {
         return(false);
     }
 }
예제 #4
0
 public IEnumerable <VoxelChunk> EnumerateChunksInBounds(BoundingFrustum Frustum)
 {
     return(EnumerateChunksInBounds(MathFunctions.GetBoundingBox(Frustum.GetCorners()))
            .Where(c =>
     {
         var min = new GlobalVoxelCoordinate(c.ID, new LocalVoxelCoordinate(0, 0, 0));
         var box = new BoundingBox(min.ToVector3(), min.ToVector3() + new Vector3(VoxelConstants.ChunkSizeX, VoxelConstants.ChunkSizeY, VoxelConstants.ChunkSizeZ));
         var r = Frustum.Contains(box) != ContainmentType.Disjoint;
         return r;
     }));
 }
예제 #5
0
 public bool InScreen(Vector3 p, BoundingFrustum bf)
 {
     if (bf.Contains(p) != ContainmentType.Disjoint)
     {
         return(true);
     }
     else
     {
         return(false);
     }
 }
예제 #6
0
파일: Camera.cs 프로젝트: RuiVarela/atlas
 private bool Contains(BoundingFrustum bf, Vector3[] pts)
 {
     foreach (Vector3 p in pts)
     {
         if (bf.Contains(p) != ContainmentType.Contains)
         {
             return(false);
         }
     }
     return(true);
 }
        public static bool IntersectObject(BoundingFrustum boundingFrustum, IGeometry geometry, Matrix matrix)
        {
            for (int i = 0; i < geometry.VertexCount(); i++)
            {
                if (boundingFrustum.Contains(Vector3.Transform(geometry.GetVertexById(i), matrix)) != ContainmentType.Disjoint)
                {
                    return(true);
                }
            }

            return(false);
        }
예제 #8
0
        public void EnumerateItems(BoundingFrustum SearchBounds, HashSet <T> Into, Func <T, bool> Filter)
        {
            lock (this)
            {
                switch (SearchBounds.Contains(Bounds))
                {
                case ContainmentType.Disjoint:
                    return;

                case ContainmentType.Intersects:
                    if (Children == null)
                    {
                        for (var i = 0; i < Items.Count; ++i)
                        {
                            if (Filter(Items[i].Body) && FastIntersects(SearchBounds, Items[i].BoundingBox))
                            {
                                Into.Add(Items[i].Body);
                            }
                        }
                    }
                    else
                    {
                        for (var i = 0; i < 8; ++i)
                        {
                            Children[i].EnumerateItems(SearchBounds, Into, Filter);
                        }
                    }
                    break;

                case ContainmentType.Contains:
                    if (Children == null)
                    {
                        foreach (var item in Items)
                        {
                            if (Filter(item.Body))
                            {
                                Into.Add(item.Body);
                            }
                        }
                    }
                    else
                    {
                        for (var i = 0; i < 8; ++i)
                        {
                            Children[i].EnumerateItems(Into, Filter);
                        }
                    }

                    break;
                }
            }
        }
예제 #9
0
 public virtual void Render(GraphicsDevice graphics, Effect effect, EffectPass pass, BoundingFrustum viewFrustum, bool isInstanced)
 {
     if (!isInstanced)
     {
         if (viewFrustum.Contains(Bounds) == ContainmentType.Disjoint)
         {
             return;
         }
         effect.Parameters["World"].SetValue(WorldTransform);
         effect.Parameters["WorldInverseTranspose"].SetValue(Matrix.Transpose(Matrix.Invert(WorldTransform)));
         Geometry.Render(graphics, effect, pass);
     }
 }
예제 #10
0
        public void BoundingFrustum_CalculatesContainsBoundingFrustumCorrectly()
        {
            var view1    = Matrix.CreateLookAt(new Vector3(0, 0, 5), Vector3.Zero, Vector3.Up);
            var proj1    = Matrix.CreatePerspectiveFieldOfView((float)Math.PI / 4f, 4f / 3f, 1f, 1000f);
            var frustum1 = new BoundingFrustum(view1 * proj1);

            var view2    = Matrix.CreateLookAt(new Vector3(0, 0, 5), new Vector3(0, 0, 10), Vector3.Up);
            var proj2    = Matrix.CreatePerspectiveFieldOfView((float)Math.PI / 4f, 4f / 3f, 1f, 1000f);
            var frustum2 = new BoundingFrustum(view2 * proj2);

            var view3    = Matrix.CreateLookAt(new Vector3(0, 0, 5), new Vector3(2, 0, 0), Vector3.Up);
            var proj3    = Matrix.CreatePerspectiveFieldOfView((float)Math.PI / 4f, 4f / 3f, 1f, 1000f);
            var frustum3 = new BoundingFrustum(view3 * proj3);

            var r1 = frustum1.Contains(frustum2);
            var r2 = frustum1.Contains(frustum3);
            var r3 = frustum1.Contains(frustum1);

            TheResultingValue(r1).ShouldBe(ContainmentType.Disjoint);
            TheResultingValue(r2).ShouldBe(ContainmentType.Intersects);
            TheResultingValue(r3).ShouldBe(ContainmentType.Contains);
        }
        /// <summary>
        /// Draws all particles
        /// </summary>
        /// <param name="gt">The gt.</param>
        /// <param name="view">The view.</param>
        /// <param name="Projection">The projection.</param>
        /// <param name="render">The render.</param>
        protected override void Draw(GameTime gt, Matrix view, Matrix Projection, RenderHelper render)
        {
            //manager.DrawAllParticleSystems();
            BoundingFrustum bf = new BoundingFrustum(view * Projection);

            foreach (var item in ParticleSystem.Values)
            {
                if (item.BoundingBox == null || (bf.Contains(item.BoundingBox.Value) == ContainmentType.Disjoint))
                {
                    item.IDPSFParticleSystem.Draw();
                }
            }
        }
예제 #12
0
        public void BoundingFrustumToBoundingBoxTests()
        {
            var view = Matrix.CreateLookAt(new Vector3(0, 0, 5), Vector3.Zero, Vector3.Up);
            var projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4, 1, 1, 100);
            var testFrustum = new BoundingFrustum(view * projection);

            var bbox1 = new BoundingBox(new Vector3(0, 0, 0), new Vector3(1, 1, 1));
            Assert.That(testFrustum.Contains(bbox1), Is.EqualTo(ContainmentType.Contains));
            Assert.That(testFrustum.Intersects(bbox1), Is.True);

            var bbox2 = new BoundingBox(new Vector3(-1000, -1000, -1000), new Vector3(1000, 1000, 1000));
            Assert.That(testFrustum.Contains(bbox2), Is.EqualTo(ContainmentType.Intersects));
            Assert.That(testFrustum.Intersects(bbox2), Is.True);

            var bbox3 = new BoundingBox(new Vector3(-1000, -1000, -1000), new Vector3(0, 0, 0));
            Assert.That(testFrustum.Contains(bbox3), Is.EqualTo(ContainmentType.Intersects));
            Assert.That(testFrustum.Intersects(bbox3), Is.True);

            var bbox4 = new BoundingBox(new Vector3(-1000, -1000, -1000), new Vector3(-500, -500, -500));
            Assert.That(testFrustum.Contains(bbox4), Is.EqualTo(ContainmentType.Disjoint));
            Assert.That(testFrustum.Intersects(bbox4), Is.False);
        }
예제 #13
0
 public override void Update(GameTime gameTime)
 {
     base.Update(gameTime);
     if (!Visible)
     {
         BoundingFrustum bf          = new BoundingFrustum(((Renderer3D)Renderer).Cam.View * ((Renderer3D)Renderer).Cam.Projection);
         ContainmentType containment = bf.Contains(BoundingBox);
         if (containment != ContainmentType.Disjoint)
         {
             Visible = true;
         }
     }
 }
예제 #14
0
        private TraverseOptions FindAllBoundingFrustum(QuadTreeNode <QuadTreeSceneManagerNodeData <ISpatialQueryable> > node)
        {
            if (!node.value.Initialized)
            {
                return(TraverseOptions.Skip);
            }

            var nodeContainment = ContainmentType.Intersects;
            var nodeBounds      = new BoundingBox(new Vector3(node.bounds.X, node.bounds.Y, node.value.MinHeight),
                                                  new Vector3(node.bounds.X + node.bounds.Width, node.bounds.Y + node.bounds.Height, node.value.MaxHeight));

            boundingFrustum.Contains(ref boundingBox, out nodeContainment);

            if (nodeContainment == ContainmentType.Disjoint)
            {
                return(TraverseOptions.Skip);
            }

            if (nodeContainment == ContainmentType.Contains)
            {
                AddAllDesedents(node);
                return(TraverseOptions.Skip);
            }

            if (node.value.List != null)
            {
                var count = node.value.List.Count;
                for (int i = 0; i < count; ++i)
                {
                    var val = node.value.List[i];
                    if (boundingFrustum.Contains(val.BoundingBox) != ContainmentType.Disjoint)
                    {
                        result.Add(val);
                    }
                }
            }
            return(TraverseOptions.Continue);
        }
예제 #15
0
        public void Render(GraphicsDevice graphicsDevice, GameTime gameTime)
        {
            RegenerateDirtyVertexLists();

            graphicsDevice.BlendState        = BlendState.Opaque;
            graphicsDevice.DepthStencilState = DepthStencilState.Default;

            for (BlockTexture blockTexture = BlockTexture.None + 1; blockTexture < BlockTexture.MAXIMUM; blockTexture++)
            {
                for (uint r = 0; r < NUMREGIONS; r++)
                {
                    // Figure out if we should be rendering translucently.
                    bool renderTranslucent = false;
                    if (blockTexture == BlockTexture.TransRed || blockTexture == BlockTexture.TransBlue)
                    {
                        renderTranslucent = true;
                    }

                    // If this is empty, don't render it.
                    DynamicVertexBuffer regionBuffer = vertexBuffers[(byte)blockTexture, r];
                    if (regionBuffer == null)
                    {
                        continue;
                    }

                    // If this isn't in our view frustum, don't render it.
                    BoundingSphere  regionBounds    = new BoundingSphere(GetRegionCenter(r), REGIONSIZE);
                    BoundingFrustum boundingFrustum = new BoundingFrustum(gameInstance.propertyBag.playerCamera.ViewMatrix * gameInstance.propertyBag.playerCamera.ProjectionMatrix);
                    if (boundingFrustum.Contains(regionBounds) == ContainmentType.Disjoint)
                    {
                        continue;
                    }

                    // Make sure our vertex buffer is clean.
                    if (vertexListDirty[(byte)blockTexture, r])
                    {
                        continue;
                    }

                    // Actually render.
                    RenderVertexList(graphicsDevice, regionBuffer, blockTextures[(byte)blockTexture].Texture, blockTextures[(byte)blockTexture].LODColor, renderTranslucent, blockTexture == BlockTexture.Lava, (float)gameTime.TotalGameTime.TotalSeconds);
                }
            }

            // Apply posteffects.
            if (bloomPosteffect != null)
            {
                bloomPosteffect.Draw(graphicsDevice);
            }
        }
예제 #16
0
        public void GetVisibleEntities(PerspectiveCamera camera, IList <Pose> outVisible)
        {
            var frustum = new BoundingFrustum(camera.ViewProjection);

            for (var i = 0; i < this.Entries.Count; i++)
            {
                var entry  = this.Entries[i];
                var bounds = entry.Bounds.Transform(entry.Transform.Matrix);
                if (frustum.Contains(bounds) != ContainmentType.Disjoint)
                {
                    outVisible.Add(entry);
                }
            }
        }
예제 #17
0
        /// <summary>
        /// Provides the behavior for the Arrange pass of Silverlight layout.
        /// </summary>
        /// <param name="finalSize">The final area within the parent that this
        /// object should use to arrange itself and its children.</param>
        /// <returns>
        /// The actual size that is used after the element is arranged in layout.
        /// </returns>
        protected override Size ArrangeOverride(Size finalSize)
        {
            if (ActualWidth > 0 && ActualHeight > 0 && (motion != null && motion.IsDataValid || IsDesignMode))
            {
                this.FirsVectorInView = null;

                BoundingFrustum viewFrustum = new BoundingFrustum(Attitude * view * CameraProjection);
                foreach (var child in Children)
                {
                    object posObj = child.GetValue(DirectionProperty);
                    if (posObj is Point && !double.IsNaN(((Point)posObj).X))
                    {
                        Point   p         = (Point)posObj;
                        Vector3 direction = PolarToVector(p.X, p.Y, 10);
                        var     size      = child.DesiredSize;
                        //Create a bounding sphere around the element for hittesting against the current frustum
                        //This size is not entirely right... size we have is screen size but we use the world size.
                        //*.008 seems to roughly fit as conversion factor for now
                        var box = new BoundingSphere(direction, (float)Math.Max(size.Width, size.Height) * .008f);
                        if (viewFrustum.Contains(box) != ContainmentType.Disjoint) //partially or fully inside camera frustum
                        {
                            Vector3 projected = Project(direction);

                            if (this.FirsVectorInView == null)
                            {
                                this.FirsVectorInView = projected;
                            }

                            if (!float.IsNaN(projected.X) && !float.IsNaN(projected.Y))
                            {
                                //Arrange element centered on projected coordinate
                                double x = projected.X - size.Width * .5;
                                double y = projected.Y - size.Height * .5;
                                child.Arrange(new Rect(x, y, size.Width, size.Height));
                                continue;
                            }
                        }
                    }
                    //if we fall through to here, it's because the element is outside the view,
                    //or placement can't be calculated
                    child.Arrange(new Rect(0, 0, 0, 0));
                }
                return(finalSize);
            }
            else
            {
                return(base.ArrangeOverride(finalSize));
            }
        }
예제 #18
0
        public override void StartFrame(ref Matrix view, ref Matrix projection, BoundingFrustum frustrum)
        {
            forward.Clear();
            deferred.Clear();

            foreach (var item in world.Objects)
            {
                if (item.Material.MaterialType == MaterialType.DEFERRED)
                {
                    if ((item.PhysicObject.PhysicObjectTypes == PhysicObjectTypes.GHOST && item.PhysicObject.BoundingBox.HasValue == false) || item.PhysicObject.PhysicObjectTypes == PhysicObjectTypes.NONE)
                    {
                        deferred.Add(item);
                        continue;
                    }

                    if (frustrum.Contains(item.PhysicObject.BoundingBox.Value) != Microsoft.Xna.Framework.ContainmentType.Disjoint)
                    {
                        deferred.Add(item);
                    }
                }
                else
                {
                    if ((item.PhysicObject.PhysicObjectTypes == PhysicObjectTypes.GHOST && item.PhysicObject.BoundingBox.HasValue == false) || item.PhysicObject.PhysicObjectTypes == PhysicObjectTypes.NONE)
                    {
                        forward.Add(item);
                        continue;
                    }

                    if (frustrum.Contains(item.PhysicObject.BoundingBox.Value) != Microsoft.Xna.Framework.ContainmentType.Disjoint)
                    {
                        forward.Add(item);
                    }
                }
            }
            num = forward.Count + deferred.Count;
        }
        public void Render(GraphicsDevice gd, BasicEffect be)
        {
            BoundingFrustum frustum = new BoundingFrustum(be.View * be.Projection);

            ComponentManager cm = ComponentManager.GetInstance();

            foreach (var(_, mic, box) in cm.GetComponentsOfType <ModelInstanceComponent, BoundingBoxComponent>())
            {
                ModelComponent mc = cm.GetComponentForEntity <ModelComponent>(mic.ModelEntityId);
                if (frustum.Contains(box.BoundingBox) != ContainmentType.Disjoint)
                {
                    ModelHelper.Render(be, mc, mic.Instance);
                }
            }
        }
예제 #20
0
        public override void StartFrame(ref Matrix view, ref Matrix projection, BoundingFrustum frustrum)
        {
            forward.Clear();
            deferred.Clear();
            
            foreach (var item in world.Objects)
            {
                if (item.Material.MaterialType == MaterialType.DEFERRED)
                {
                    if ( (item.PhysicObject.PhysicObjectTypes == PhysicObjectTypes.GHOST && item.PhysicObject.BoundingBox.HasValue == false ) || item.PhysicObject.PhysicObjectTypes == PhysicObjectTypes.NONE)
                    {
                        deferred.Add(item);
                        continue;
                    }

                    if (frustrum.Contains(item.PhysicObject.BoundingBox.Value) != Microsoft.Xna.Framework.ContainmentType.Disjoint)
                    {
                        deferred.Add(item);
                    }
                }
                else
                {
                    if ( (item.PhysicObject.PhysicObjectTypes == PhysicObjectTypes.GHOST && item.PhysicObject.BoundingBox.HasValue == false ) || item.PhysicObject.PhysicObjectTypes == PhysicObjectTypes.NONE)
                    {
                        forward.Add(item);
                        continue;
                    }

                    if (frustrum.Contains(item.PhysicObject.BoundingBox.Value) != Microsoft.Xna.Framework.ContainmentType.Disjoint)
                    {
                        forward.Add(item);
                    }    
                }
            }
            num = forward.Count + deferred.Count;
        }
        //IF a submesh belongs to an entity that has moved we need to update the BoundingBoxWorld Position!
        //returns the mean distance of all objects iwth that material
        public float?UpdatePositionAndCheckRender(bool cameraHasChanged, BoundingFrustum viewFrustum, Vector3 cameraPosition, BoundingSphere sphere)
        {
            float?distance = null;

            bool hasAnythingChanged = false;

            for (var i = 0; i < Index; i++)
            {
                TransformMatrix trafoMatrix = _worldMatrices[i];


                if (trafoMatrix.HasChanged)
                {
                    _worldBoundingCenters[i] = trafoMatrix.TransformMatrixSubModel(MeshBoundingSphere.Center);
                }

                //If either the trafomatrix or the camera has changed we need to check visibility
                if (trafoMatrix.HasChanged || cameraHasChanged)
                {
                    sphere.Center = _worldBoundingCenters[i];
                    sphere.Radius = MeshBoundingSphere.Radius * trafoMatrix.Scale.X;
                    if (viewFrustum.Contains(sphere) == ContainmentType.Disjoint)
                    {
                        Rendered[i] = false;
                    }
                    else
                    {
                        Rendered[i] = true;
                    }

                    //we just register that something has changed
                    hasAnythingChanged = true;
                }
            }

            //We need to calcualte a new average distance
            if (hasAnythingChanged && GameSettings.g_CPU_Sort)
            {
                distance = 0;

                for (var i = 0; i < Index; i++)
                {
                    distance += Vector3.DistanceSquared(cameraPosition, _worldBoundingCenters[i]);
                }
            }

            return(distance);
        }
예제 #22
0
        public void EnumerateItems(BoundingFrustum SearchBounds, HashSet <Body> Into)
        {
            lock (this)
            {
                switch (SearchBounds.Contains(Bounds))
                {
                case ContainmentType.Disjoint:
                    return;

                case ContainmentType.Intersects:
                    if (Children == null)
                    {
                        for (var i = 0; i < Items.Count; ++i)
                        {
                            if (Items[i].BoundingBox.Intersects(SearchBounds))
                            {
                                Into.Add(Items[i].Body);
                            }
                        }
                    }
                    else
                    {
                        for (var i = 0; i < 8; ++i)
                        {
                            Children[i].EnumerateItems(SearchBounds, Into);
                        }
                    }
                    break;

                case ContainmentType.Contains:
                    if (Children == null)
                    {
                        for (var i = 0; i < Items.Count; ++i)
                        {
                            Into.Add(Items[i].Body);
                        }
                    }
                    else
                    {
                        for (var i = 0; i < 8; ++i)
                        {
                            Children[i].EnumerateItems(Into);
                        }
                    }
                    break;
                }
            }
        }
예제 #23
0
        /// <summary>
        /// Draw the current state of the <c>GameLayer3D</c>.
        /// </summary>
        /// <param name="gameTime">Global time of the game.</param>
        /// <param name="customEffect">Custom effect to be applied in the <c>GameLayer3D</c>.</param>
        public void Draw(GameTime gameTime, Effect customEffect)
        {
            Dictionary <string, Matrix> dictionary      = new Dictionary <string, Matrix>();
            BoundingFrustum             boundingFrustum = new BoundingFrustum(
                CameraManager.ActiveCamera.View * CameraManager.ActiveCamera.Projection);

            foreach (DrawableModel model in _modelList)
            {
                ContainmentType cameraNodeContainment = boundingFrustum.Contains(model.BSphere);//boundingFrustum.Contains(model.GetBoundingBox());
                if (!_checkFrustum || (_checkFrustum && cameraNodeContainment != ContainmentType.Disjoint))
                {
                    model.Draw(CameraManager.ActiveCamera.View, CameraManager.ActiveCamera.Projection,
                               DrawingMethod.HardwareInstancing, dictionary, customEffect);
                }
            }
        }
예제 #24
0
 public void addLeavesInsideFrustum(BoundingFrustum frustum)
 {
     if (frustum.Contains(boundingBox) != ContainmentType.Disjoint)
     {
         if (topLeft == null)
         {
             leavesInsideBound.Add(this);
         }
         else
         {
             topLeft.addLeavesInsideFrustum(frustum);
             topRight.addLeavesInsideFrustum(frustum);
             bottomLeft.addLeavesInsideFrustum(frustum);
             bottomRight.addLeavesInsideFrustum(frustum);
         }
     }
 }
예제 #25
0
        public void Process(BoundingFrustum frustum, ref List <GameObject3D> foundObjects)
        {
            if (foundObjects == null)
            {
                foundObjects = new List <GameObject3D>();
            }

            if (frustum.Contains(Bounds) != ContainmentType.Disjoint)
            {
                foundObjects.AddRange(Objects);

                foreach (Octree node in Nodes)
                {
                    node.Process(frustum, ref foundObjects);
                }
            }
        }
    public override void Do()
    {
        Mesh            mesh            = Instantiate(meshFilter.sharedMesh);
        BoundingFrustum boundingFrustum = new BoundingFrustum();

        boundingFrustum.Update(camera, camera.GetComponent <Transform>());
        Color[] meshColors = mesh.colors;
        if (meshColors == null || meshColors.Length != mesh.vertexCount)
        {
            meshColors = new Color[mesh.vertexCount];
            for (int i = 0; i < mesh.vertexCount; i++)
            {
                meshColors[i] = defaultColor;
            }
        }
        for (int i = 0; i < mesh.vertexCount; i++)
        {
            MeshExtensions.MeshVertex meshVertex = new MeshExtensions.MeshVertex(mesh, trs, i, null);
            if (boundingFrustum.Contains(ref meshVertex.point))
            {
                if (paintType == PaintType.Both || paintType == PaintType.Inside)
                {
                    meshColors[i] = insideFrustumColor;
                }
            }
            else if (paintType == PaintType.Both || paintType == PaintType.Outside)
            {
                meshColors[i] = outsideFrustumColor;
            }
        }
        mesh.colors           = meshColors;
        meshFilter.sharedMesh = mesh;
        if (makeAsset)
        {
            if (autoNameAssetPath)
            {
                string newAssetPath = saveAssetAtPath;
                while (File.Exists(newAssetPath))
                {
                    newAssetPath = newAssetPath.Replace(".asset", "1.asset");
                }
            }
            AssetDatabase.CreateAsset(meshFilter.sharedMesh, saveAssetAtPath);
            AssetDatabase.SaveAssets();
        }
    }
예제 #27
0
        //TODO: Actually use raytracing...
        private void Raytrace()
        {
            BoundingFrustum frustum = new BoundingFrustum(_effect.View * _effect.Projection);

            List <Group> renderable      = new List <Group>();
            List <Group> renderableAlpha = new List <Group>();

            foreach (var g in Groups)
            {
                bool hasRenderable = false;
                bool transparent   = false;
                foreach (var area in g.Areas)
                {
                    if (frustum.Contains(area.Box.Transform(_effect.World)) == ContainmentType.Disjoint)
                    {
                        area.Render = false;
                    }
                    else
                    {
                        area.Render   = true;
                        hasRenderable = true;
                    }

                    if (area.HasTransparency || area.Material.TextureMapAlpha != null)
                    {
                        transparent = true;
                    }
                }

                if (hasRenderable)
                {
                    if (transparent)
                    {
                        renderableAlpha.Add(g);
                    }
                    else
                    {
                        renderable.Add(g);
                    }
                }
            }

            _renderedGroups      = renderable;
            _renderedAlphaGroups = renderableAlpha;
        }
        public void Process(BoundingFrustum frustum, ref List <GameObject3D> passedObjects)
        {
            if (passedObjects == null)
            {
                passedObjects = new List <GameObject3D>();
            }

            if (frustum.Contains(Bounds) != ContainmentType.Disjoint)
            {
                passedObjects.AddRange(Objects);

                foreach (QuadTree node in Nodes)
                {
                    //Process(frustum, ref passedObjects);
                    node.Process(frustum, ref passedObjects);
                }
            }
        }
예제 #29
0
 public void CullRenderables(BoundingFrustum frustum)
 {
     for (int i = 0; i < SYSTEM_SIZE; i++)
     {
         if (!cVisible[i]._valid)
         {
             continue;
         }
         var intersect = frustum.Contains(ref cBounds[i]);
         if (intersect == ContainmentType.Contains || intersect == ContainmentType.Intersects)
         {
             cCulled[i] = !cVisible[i]._valid || !cVisible[i]._visible;
         }
         else
         {
             cCulled[i] = true;
         }
     }
 }
예제 #30
0
        public static bool BoundingFrustumIntersection(AEntity e1)
        {
            //var tempCamera = new Camera(Global.GraphicsManager.GraphicsDevice.DisplayMode.AspectRatio, 10000f, MathHelper.ToRadians(45), 1f, new Vector3(0, 250, 250), new Vector3(0, 0, 0), Vector3.Up);
            //BoundingFrustum boundingFrustum = new BoundingFrustum(tempCamera.ViewMatrix * tempCamera.ProjectionMatrix);

            BoundingFrustum boundingFrustum = new BoundingFrustum(Global.Camera.ViewMatrix * Global.Camera.ProjectionMatrix);

            for (var i = 0; i < e1.Model.Meshes.Count; i++)
            {
                var e1BoundingSphere = e1.Model.Meshes[i].BoundingSphere;
                e1BoundingSphere.Center += e1.Position;

                if (boundingFrustum.Contains(e1BoundingSphere) != ContainmentType.Disjoint)
                {
                    return(true);
                }
            }
            return(false);
        }
예제 #31
0
        public PolygonDrawCommand(List <Vector3> points, bool isClosed, Color lineColor, int lineWidth)
        {
            Points = new List <Vector2>();

            BoundingFrustum cameraFrustrum = PlayState.Camera.GetFrustrum();

            foreach (Vector3 point in points)
            {
                if (cameraFrustrum.Contains(point) == ContainmentType.Contains)
                {
                    Vector3 screenVec = GameState.Game.GraphicsDevice.Viewport.Project(point, PlayState.Camera.ProjectionMatrix, PlayState.Camera.ViewMatrix, Matrix.Identity);
                    Points.Add(new Vector2(screenVec.X, screenVec.Y));
                }
            }

            IsClosed  = isClosed;
            LineColor = lineColor;
            LineWidth = lineWidth;
        }
예제 #32
0
        public PolygonDrawCommand(Camera camera, IEnumerable <Vector3> points, bool isClosed, Color lineColor, int lineWidth, Viewport viewport)
        {
            Points = new List <Vector2>();

            BoundingFrustum cameraFrustrum = camera.GetFrustum();

            foreach (Vector3 point in points)
            {
                if (cameraFrustrum.Contains(point) == ContainmentType.Contains)
                {
                    Vector3 screenVec = viewport.Project(point, camera.ProjectionMatrix, camera.ViewMatrix, Matrix.Identity);
                    Points.Add(new Vector2(screenVec.X, screenVec.Y));
                }
            }

            IsClosed  = isClosed;
            LineColor = lineColor;
            LineWidth = lineWidth;
        }
예제 #33
0
파일: QTNode.cs 프로젝트: patrykos91/Laikos
 public void Draw(Effect GBuffer, BoundingFrustum cameraFrustrum)
 {
     BoundingBox transformedBox = XNAUtils.TransformBoundingBox(nodeBoundingBox, Matrix.Identity);
     ContainmentType cameraNodeContainment = cameraFrustrum.Contains(transformedBox);
     if (cameraNodeContainment != ContainmentType.Disjoint)
     {
         if (isEndNode)
         {
             DrawCurrentNode(Matrix.Identity, Camera.viewMatrix, Camera.projectionMatrix, GBuffer);
         }
         else
         {
             nodeUL.Draw(GBuffer, cameraFrustrum);
             nodeUR.Draw(GBuffer, cameraFrustrum);
             nodeLL.Draw(GBuffer, cameraFrustrum);
             nodeLR.Draw(GBuffer, cameraFrustrum);
         }
     }
 }
        protected override void Draw(GameTime gameTime)
        {
            device.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, Color.CornflowerBlue, 1, 0);

            int             modelsDrawn = 0;
            BoundingFrustum cameraSight = new BoundingFrustum(fpsCam.ViewMatrix * fpsCam.ProjectionMatrix);

            for (int x = 0; x < 5; x++)
            {
                for (int z = 0; z < 5; z++)
                {
                    Matrix         worldMatrix = Matrix.CreateScale(0.001f) * Matrix.CreateTranslation(x * 5 - 10, 0, z * 5 - 10);
                    BoundingSphere origSphere  = (BoundingSphere)myModel.Tag;
                    BoundingSphere transSphere = origSphere.Transform(worldMatrix);

                    ContainmentType containmentType = cameraSight.Contains(transSphere);

                    if (containmentType != ContainmentType.Disjoint)
                    {
                        modelsDrawn++;
                        //draw model
                        myModel.CopyAbsoluteBoneTransformsTo(modelTransforms);
                        foreach (ModelMesh mesh in myModel.Meshes)
                        {
                            foreach (BasicEffect effect in mesh.Effects)
                            {
                                effect.EnableDefaultLighting();
                                effect.World      = modelTransforms[mesh.ParentBone.Index] * worldMatrix;
                                effect.View       = fpsCam.ViewMatrix;
                                effect.Projection = fpsCam.ProjectionMatrix;
                            }
                            mesh.Draw();
                        }
                    }
                }
            }
            Window.Title = string.Format("Models actually drawn: {0}", modelsDrawn);

            //draw coordcross
            cCross.Draw(fpsCam.ViewMatrix, fpsCam.ProjectionMatrix);

            base.Draw(gameTime);
        }
예제 #35
0
 public bool Contains(BoundingBox bbox)
 {
     var frustum = new BoundingFrustum(_View * _Projection);
     return frustum.Contains(bbox) != ContainmentType.Disjoint;
 }
예제 #36
0
        public void DrawText(Matrix viewMatrix, Matrix projectionMatrix, Vector3 drawPosition, string hoverText, Color color)
        {
            // Don't draw text if it's not within our frustum.
            BoundingSphere regionBounds = new BoundingSphere(drawPosition, 0.1f);
            BoundingFrustum boundingFrustum = new BoundingFrustum(viewMatrix * projectionMatrix);
            if (boundingFrustum.Contains(regionBounds) == ContainmentType.Disjoint)
                return;

            // Draw our text over the player.
            SpriteBatch spriteBatch = new SpriteBatch(graphicsDevice);
            spriteBatch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Immediate, SaveStateMode.SaveState);
            Vector3 screenSpace = graphicsDevice.Viewport.Project(Vector3.Zero,
                                                                  projectionMatrix,
                                                                  viewMatrix,
                                                                  Matrix.CreateTranslation(drawPosition + new Vector3(0, 1.7f, 0)));
            Vector2 textPosition = new Vector2(screenSpace.X, screenSpace.Y) - nameFont.MeasureString(hoverText) * 0.5f;
            textPosition.X = (int)textPosition.X;
            textPosition.Y = (int)textPosition.Y;
            spriteBatch.DrawString(nameFont, hoverText, textPosition, Color.Black);
            textPosition.X -= 2;
            textPosition.Y -= 2;
            spriteBatch.DrawString(nameFont, hoverText, textPosition, color);//Color.White);
            spriteBatch.End();
        }
예제 #37
0
        public void Render(GraphicsDevice graphicsDevice, GameTime gameTime)
        {
            RegenerateDirtyVertexLists();

            for (BlockTexture blockTexture = BlockTexture.None+1; blockTexture < BlockTexture.MAXIMUM; blockTexture++)
                for (uint r = 0; r < NUMREGIONS; r++)
                {
                    // Figure out if we should be rendering translucently.
                    bool renderTranslucent = false;
                    if (blockTexture == BlockTexture.TransRed || blockTexture == BlockTexture.TransBlue)
                        renderTranslucent = true;

                    // If this is empty, don't render it.
                    DynamicVertexBuffer regionBuffer = vertexBuffers[(byte)blockTexture, r];
                    if (regionBuffer == null)
                        continue;

                    // If this isn't in our view frustum, don't render it.
                    BoundingSphere regionBounds = new BoundingSphere(GetRegionCenter(r), REGIONSIZE);
                    BoundingFrustum boundingFrustum = new BoundingFrustum(gameInstance.propertyBag.playerCamera.ViewMatrix * gameInstance.propertyBag.playerCamera.ProjectionMatrix);
                    if (boundingFrustum.Contains(regionBounds) == ContainmentType.Disjoint)
                        continue;

                    // Make sure our vertex buffer is clean.
                    if (vertexListDirty[(byte)blockTexture, r])
                        continue;

                    // Actually render.
                    RenderVertexList(graphicsDevice, regionBuffer, blockTextures[(byte)blockTexture].Texture, blockTextures[(byte)blockTexture].LODColor, renderTranslucent, blockTexture == BlockTexture.Lava, (float)gameTime.TotalRealTime.TotalSeconds);
                }

            // Apply posteffects.
            if (bloomPosteffect != null)
                bloomPosteffect.Draw(graphicsDevice);
        }
예제 #38
0
 private int TestFrustum(BoundingBox BB, BoundingFrustum BF)
 {
     ContainmentType CT = BF.Contains(BB);
     if (CT == ContainmentType.Contains) return 2;
     if (CT == ContainmentType.Intersects) return 1;
     return 0;
     //0 - нет
     //1 - частично
     //2 - полностью
 }
예제 #39
0
 public List<SimpleModel> Process(BoundingFrustum frustum)
 {
     List<SimpleModel> drawnObjects = new List<SimpleModel>();
     if (frustum.Contains(BoundingBox) != ContainmentType.Disjoint)
     {
         drawnObjects.AddRange(Objects);
         foreach (var node in childNodes)
         {
             drawnObjects.AddRange(node.Process(frustum));
         }
     }
     return drawnObjects;
 }
예제 #40
0
        public void Render(BoundingFrustum frustum)
        {
            int vertices = 0;
            uint cx = x;
            uint cy = y; //cache = anti-earthquake
            uint cz = z;
            Matrix world = Matrix.Identity;
            Vector3 middle = new Vector3(8, 8, 8);
            foreach (var node in vertexBuffers.AsEnumerable)
            {
                if (node.Value == null)
                    continue;
                world.Translation = new Vector3((int)(node.Key.X - cx), (int)(node.Key.Y - cy), (int)(node.Key.Z - cz));
                bs.Center = middle + world.Translation;

                if (ContainmentType.Disjoint == frustum.Contains(bs))
                    continue;
                effect.WMatrix = world;

                effect.BeginPass3D();
                device.Indices = Static.Indices;
                device.Vertices[0].SetSource(node.Value.VertexBuffer, 0, VertexAwesome.SizeInBytes);
                Action<int> draw =
                    i =>
                    {
                        if (node.Value.Count[i] != 0)
                        {
                            device.DrawIndexedPrimitives(PrimitiveType.TriangleList, node.Value.Offset[i], 0, node.Value.Count[i], 0, node.Value.Count[i] / 2);
                            vertices += node.Value.Count[i];
                        }
                    };
                if (node.Key.Z - cz - 1 > 0x80000000) draw(0);
                if (node.Key.Z - cz + 16 < 0x80000000) draw(1);
                if (node.Key.X - cx - 1 > 0x80000000) draw(2);
                if (node.Key.X - cx + 16 < 0x80000000) draw(3);
                if (node.Key.Y - cy - 1 > 0x80000000) draw(4);
                if (node.Key.Y - cy + 16 < 0x80000000) draw(5);
                if (node.Value.Count[6] != 0)
                {
                    device.DrawPrimitives(PrimitiveType.TriangleList, node.Value.Offset[6], node.Value.Count[6] / 3);
                    vertices += node.Value.Count[6];
                }
                effect.EndPass3D();
            }
            this.Vertices = vertices;
        }
예제 #41
0
 public bool CheckFrustumIntersection(BoundingFrustum boundingFrustum)
 {
     ContainmentType con = boundingFrustum.Contains(model.BoundingSphere);
         if (con == ContainmentType.Contains || con == ContainmentType.Intersects) return true;
         return false;
 }
예제 #42
0
        public void Render(Camera camera)
        {
            // If this node should be split, then render the four children instead

            if (splitIntoChildren)
            {
                foreach (TerrainChunk child in children)
                {
                    child.Render(camera);
                }
            }
            else
            {
                IGraphicsDeviceService igs = (IGraphicsDeviceService)quadTree.Game.Services.GetService(typeof(IGraphicsDeviceService));
                GraphicsDevice graphicsDevice = igs.GraphicsDevice;

                // Do frustum culling

                BoundingFrustum frustum = new BoundingFrustum(camera.ViewMatrix * camera.ProjMatrix);

                ContainmentType containment;
                frustum.Contains(ref boundingBox, out containment);

                if (containment == ContainmentType.Disjoint)
                    return;

                // Prepare the effect

                quadTree.TerrainShader.Parameters["world"].SetValue(worldTransform);
                quadTree.TerrainShader.Parameters["view"].SetValue(camera.ViewMatrix);
                quadTree.TerrainShader.Parameters["proj"].SetValue(camera.ProjMatrix);

                quadTree.TerrainShader.Parameters["maxHeight"].SetValue(quadTree.Parameters.MaxHeight);
                quadTree.TerrainShader.Parameters["textureSize"].SetValue(quadTree.HeightMap.Width);

                quadTree.TerrainShader.Parameters["heightMap"].SetValue(quadTree.HeightMap);
                quadTree.TerrainShader.Parameters["grassMap"].SetValue(quadTree.LayerMap0);
                quadTree.TerrainShader.Parameters["rockMap"].SetValue(quadTree.LayerMap1);
                quadTree.TerrainShader.Parameters["snowMap"].SetValue(quadTree.LayerMap2);
                quadTree.TerrainShader.Parameters["normalMap"].SetValue(quadTree.NormalMap);

                quadTree.TerrainShader.Parameters["uStart"].SetValue(textureCoordinates.UStart);
                quadTree.TerrainShader.Parameters["uEnd"].SetValue(textureCoordinates.UEnd);
                quadTree.TerrainShader.Parameters["vStart"].SetValue(textureCoordinates.VStart);
                quadTree.TerrainShader.Parameters["vEnd"].SetValue(textureCoordinates.VEnd);

                // Render it!

                quadTree.TerrainShader.CurrentTechnique = quadTree.TerrainShader.Techniques["TerrainDraw"];
                quadTree.TerrainShader.Begin();

                foreach (EffectPass pass in quadTree.TerrainShader.CurrentTechnique.Passes)
                {
                    pass.Begin();

                    quadTree.CommonGrid.Draw();

                    pass.End();
                }

                quadTree.TerrainShader.End();
            }
        }
예제 #43
0
        public void Draw(Layer layer)
        {
            if (activeItem != null)
            {
                switch (activeItem.NextItem)
                {
                    case TriggerType.MessageClose :
                        break;

                    default :
                        SpriteBatch spriteBatch = GameState.spriteBatch;
                        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, null, null, null, null, Settings.spriteScale);
                        foreach (TutorialPair pair in activeItem.PairList)
                        {
                            if (pair.Kind == PositionKind.POS_2D && layer == Layer.Layer3)
                            {
                                TextWrapping.DrawStringOnScreen(pair.Text, font, Settings.colorMainText, pair.Position.X, pair.Position.Y, spriteBatch, 50f);
                            }
                            else if (pair.Kind == PositionKind.POS_3D && layer == Layer.Layer1)
                            {
                                BoundingFrustum frustum = new BoundingFrustum(GameState.view * GameState.projection);
                                ContainmentType containmentType = frustum.Contains(Vector3.Transform(new Vector3(0.0f, 0.0f, 0.0f), pair.World));
                                if (containmentType != ContainmentType.Disjoint)
                                {
                                    Vector3 point3D = GameState.game.GraphicsDevice.Viewport.Project(new Vector3(0.0f, 0.0f, 0.0f), GameState.projection, GameState.view, pair.World);
                                    TextWrapping.DrawStringOnScreen(pair.Text, font, Settings.colorMainText, Settings.UnScaleW(point3D.X) + pair.Position.X, Settings.UnScaleH(point3D.Y) + pair.Position.Y, spriteBatch, 50f);
                                }
                            }
                        }
                        spriteBatch.End();
                        break;
                }
            }
        }
예제 #44
0
        internal static void PrepareEntitiesForDraw(ref BoundingFrustum frustum, Vector3 cameraPosition, float cameraZoomDivider, MyOcclusionQueryID queryID, List<MyElement> renderObjectListForDraw, List<MyElement> cullObjectListForDraw, List<MyOcclusionQueryIssue> renderOcclusionQueries, ref int occludedItemsStats)
        {
            m_renderProfiler.StartProfilingBlock("PrepareEntitiesForDrawFr()");
                 
            if (queryID != MyOcclusionQueryID.MAIN_RENDER)
            {
                m_shadowPrunningStructure.OverlapAllFrustum(ref frustum, renderObjectListForDraw);
                m_renderProfiler.EndProfilingBlock();
                return;
            }      

            m_renderProfiler.StartProfilingBlock("m_cullingStructure.OverlapAllFrustum");
            m_cullingStructure.OverlapAllFrustum(ref frustum, cullObjectListForDraw);
            m_renderProfiler.EndProfilingBlock();

            if (renderOcclusionQueries != null)
            {
                //Process only big cull object for queries
                renderOcclusionQueries.Clear();

                m_renderProfiler.StartProfilingBlock("PrepareObjectQueries");
                PrepareObjectQueries(queryID, cullObjectListForDraw, renderOcclusionQueries, ref occludedItemsStats);
                m_renderProfiler.EndProfilingBlock();
            }

            renderObjectListForDraw.Clear();

            m_renderProfiler.StartProfilingBlock("m_prunningStructure.OverlapAllFrustum");
            m_prunningStructure.OverlapAllFrustum(ref frustum, renderObjectListForDraw);
            //AssertRenderObjects(renderObjectListForDraw);
            m_renderProfiler.EndProfilingBlock();


            m_renderProfiler.StartProfilingBlock("Get from cullobjects - part 1");

            //int i = 1;

            if (queryID == MyOcclusionQueryID.MAIN_RENDER)
            {
                foreach (MyCullableRenderObject cullableObject in cullObjectListForDraw)
                {
                    if (frustum.Contains(cullableObject.GetWorldSpaceAABB()) == MinerWarsMath.ContainmentType.Contains)
                    {
                        cullableObject.CulledObjects.GetAll(renderObjectListForDraw, false);
                    }
                    else
                    {
                        cullableObject.CulledObjects.OverlapAllFrustum(ref frustum, renderObjectListForDraw, false);
                      //  i++;
                    } 




                    //AssertRenderObjects(renderObjectListForDraw);
                    //BoundingBox aabb = new BoundingBox(new Vector3(float.MinValue), new Vector3(float.MaxValue));
                    //cullableObject.CulledObjects.OverlapAllBoundingBox(ref aabb, renderObjectListForDraw, false);
                    //cullableObject.CulledObjects.GetAll(renderObjectListForDraw, false);                
                }
            }
            else
            {
                foreach (MyCullableRenderObject cullableObject in cullObjectListForDraw)
                {
                    if (frustum.Contains(cullableObject.GetWorldSpaceAABB()) == MinerWarsMath.ContainmentType.Contains)
                    {
                        cullableObject.CulledObjects.GetAll(renderObjectListForDraw, false);
                    }
                    else
                    {
                        cullableObject.CulledObjects.OverlapAllFrustum(ref frustum, renderObjectListForDraw, false);
                    }

                    //cullableObject.CulledObjects.OverlapAllFrustum(ref frustum, renderObjectListForDraw, false);
                    //cullableObject.CulledObjects.GetAll(renderObjectListForDraw, false);                
                }
            }

            m_renderProfiler.EndProfilingBlock();

            m_renderProfiler.StartProfilingBlock("Get from cullobjects - part 2");
                
            int c = 0;

            if (queryID == MyOcclusionQueryID.MAIN_RENDER)
            {
                //int ii = 0;
                while (c < renderObjectListForDraw.Count)
                {
                    MyRenderObject ro = renderObjectListForDraw[c] as MyRenderObject;
                    if (!ro.SkipIfTooSmall)
                    {
                        c++;
                        continue;
                    }
                          
                    Vector3 entityPosition = ro.Entity.GetPosition();
                    
                    Vector3.Distance(ref cameraPosition, ref entityPosition, out ro.Distance);
                    ro.Distance = MyCamera.GetDistanceWithFOV(ro.Distance);

                    float cullRatio = ro.Entity is MyStaticAsteroid ? 75 : MyRenderConstants.DISTANCE_CULL_RATIO;

                    if (ro.Entity is MinerWars.AppCode.Game.Entities.SubObjects.MyPrefabLargeWeapon ||
                        ro.Entity is MinerWars.AppCode.Game.Entities.Weapons.MyLargeShipBarrelBase ||
                        ro.Entity is MinerWars.AppCode.Game.Entities.Weapons.MyLargeShipGunBase)
                    {
                        cullRatio = 250;
                    }

                    if (ro.Entity.WorldVolume.Radius < ro.Distance / cullRatio)
                    {
                        renderObjectListForDraw.RemoveAtFast(c);
                        continue;
                    } 


                                      
                    //float f = ro.Distance / (2 * (float)Math.Tan(Math.PI * MyCamera.FieldOfView));

                    //if (f > ro.Entity.LocalVolume.Radius * 100)
                    //{
                    //    renderObjectListForDraw.RemoveAtFast(c);
                    //    continue;
                    //}

                    c++;
                }
            }

            m_renderProfiler.EndProfilingBlock();

            m_renderProfiler.EndProfilingBlock();
        }
예제 #45
0
        public void DrawObjects()
        {
            try
            {
                lock (gameObjects)
                {

                    ObjectsDrawn = 0;
                    foreach (Gobject go in gameObjects.Values)
                    {
                        BoundingFrustum frustum = new BoundingFrustum(view * proj);
                        if (frustum.Contains(go.Skin.WorldBoundingBox) != ContainmentType.Disjoint)
                        {
                            ObjectsDrawn++;
                            if (DrawingEnabled)
                            {
                                if (go is Terrain)
                                {
                                    (go as Terrain).Draw(GraphicsDevice, view, proj);
                                }
                                else if (go is Planet)
                                {
                                    (go as Planet).Draw(GraphicsDevice, view, proj);
                                }
                                else
                                    go.Draw(ref view, ref proj);
                            }
                            if (game.DebugPhysics)
                                go.DrawWireframe(GraphicsDevice, view, proj);
                        }
                    }
                }
            }
            catch (Exception E)
            {
                System.Diagnostics.Debug.WriteLine(E.StackTrace);
            }
        }
예제 #46
0
        /// <summary>
        /// Provides the behavior for the Arrange pass of Silverlight layout.
        /// </summary>
        /// <param name="finalSize">The final area within the parent that this
        /// object should use to arrange itself and its children.</param>
        /// <returns>
        /// The actual size that is used after the element is arranged in layout.
        /// </returns>
        protected override Size ArrangeOverride(Size finalSize)
        {
            if (ActualWidth > 0 && ActualHeight > 0 && (motion != null && motion.IsDataValid || IsDesignMode))
            {
                this.FirsVectorInView = null;

                BoundingFrustum viewFrustum = new BoundingFrustum(Attitude * view * CameraProjection);
                foreach (var child in Children)
                {
                    object posObj = child.GetValue(DirectionProperty);
                    if (posObj is Point && !double.IsNaN(((Point)posObj).X))
                    {
                        Point p = (Point)posObj;
                        Vector3 direction = PolarToVector(p.X, p.Y, 10);
                        var size = child.DesiredSize;
                        //Create a bounding sphere around the element for hittesting against the current frustum
                        //This size is not entirely right... size we have is screen size but we use the world size.
                        //*.008 seems to roughly fit as conversion factor for now
                        var box = new BoundingSphere(direction, (float)Math.Max(size.Width, size.Height) * .008f);
                        if (viewFrustum.Contains(box) != ContainmentType.Disjoint) //partially or fully inside camera frustum
                        {
                            Vector3 projected = Project(direction);

                            if (this.FirsVectorInView == null)
                            {
                                this.FirsVectorInView = projected;
                            }

                            if (!float.IsNaN(projected.X) && !float.IsNaN(projected.Y))
                            {
                                //Arrange element centered on projected coordinate
                                double x = projected.X - size.Width * .5;
                                double y = projected.Y - size.Height * .5;
                                child.Arrange(new Rect(x, y, size.Width, size.Height));
                                continue;
                            }
                        }
                    }
                    //if we fall through to here, it's because the element is outside the view,
                    //or placement can't be calculated
                    child.Arrange(new Rect(0, 0, 0, 0));
                }
                return finalSize;
            }
            else
                return base.ArrangeOverride(finalSize);
        }
예제 #47
0
        public bool IsInView(Point directionPoint)
        {
            BoundingFrustum viewFrustum = new BoundingFrustum(Attitude * view * CameraProjection);
            object posObj = directionPoint;
            if (posObj is Point && !double.IsNaN(((Point)posObj).X))
            {
                Point p = (Point)posObj;
                Vector3 direction = PolarToVector(p.X, p.Y, 10);
                //Create a bounding sphere around the element for hittesting against the current frustum
                //This size is not entirely right... size we have is screen size but we use the world size.
                //*.008 seems to roughly fit as conversion factor for now
                var box = new BoundingSphere(direction, 10 * .008f);
                if (viewFrustum.Contains(box) != ContainmentType.Disjoint) //partially or fully inside camera frustum
                {
                    return true;
                }
            }

            return false;
        }
예제 #48
0
        public static void Intersects(ref Ray ray, ref BoundingFrustum boundingFrustum, out float? result)
        {
            // TODO: Make test case of this
            if (boundingFrustum.Contains(ray.Position) == ContainmentType.Contains)
            {
                // the ray is inside the frustum
                result = 0.0f;
            }
            else
            {
                result = null;

                var corners = boundingFrustum.GetCorners();
                for (int i = 0; i < (BoundingFrustum.PlaneCount * 2); i++)
                {
                    var v1 = corners[Geometry.TriangleIndices[i + 0]];
                    var v2 = corners[Geometry.TriangleIndices[i + 1]];
                    var v3 = corners[Geometry.TriangleIndices[i + 2]];

                    Intersects(ref ray, ref v1, ref v2, ref v3, out result);

                    if (result.HasValue)
                        break;
                }
            }
        }
예제 #49
0
        public void Render(BoundingFrustum frustum)
        {
            int vertices = 0;
            BoundingSphere bs = new BoundingSphere();
            uint cx = x;
            uint cy = y; //cache = anti-earthquake
            uint cz = z;
            foreach (var node in vertexBuffers.AsEnumerable)
            {
                if (node.Value == null)
                    continue;
                var world = Matrix.CreateTranslation((int)(node.Key.X - cx), (int)(node.Key.Y - cy), (int)(node.Key.Z - cz));
                bs.Radius = 16;
                bs.Center = Vector3.Transform(new Vector3(8, 8, 8), world);

                if (ContainmentType.Disjoint == frustum.Contains(bs))
                    continue;
                effect.WMatrix = world;

                effect.BeginPass3D();
                if (node.Value[0] != null && node.Key.Z - cz - 1 > 0x80000000)
                {
                    device.Vertices[0].SetSource(node.Value[0], 0, VertexAwesome.SizeInBytes);
                    device.DrawPrimitives(PrimitiveType.TriangleList, 0, node.Value[0].SizeInBytes / VertexAwesome.SizeInBytes / 3);
                    vertices += node.Value[0].SizeInBytes / VertexAwesome.SizeInBytes;
                }
                if (node.Value[1] != null && node.Key.Z - cz + 16 < 0x80000000)
                {
                    device.Vertices[0].SetSource(node.Value[1], 0, VertexAwesome.SizeInBytes);
                    device.DrawPrimitives(PrimitiveType.TriangleList, 0, node.Value[1].SizeInBytes / VertexAwesome.SizeInBytes / 3);
                    vertices += node.Value[1].SizeInBytes / VertexAwesome.SizeInBytes;
                }
                if (node.Value[2] != null && node.Key.X - cx - 1 > 0x80000000)
                {
                    device.Vertices[0].SetSource(node.Value[2], 0, VertexAwesome.SizeInBytes);
                    device.DrawPrimitives(PrimitiveType.TriangleList, 0, node.Value[2].SizeInBytes / VertexAwesome.SizeInBytes / 3);
                    vertices += node.Value[2].SizeInBytes / VertexAwesome.SizeInBytes;
                }
                if (node.Value[3] != null && node.Key.X - cx + 16 < 0x80000000)
                {
                    device.Vertices[0].SetSource(node.Value[3], 0, VertexAwesome.SizeInBytes);
                    device.DrawPrimitives(PrimitiveType.TriangleList, 0, node.Value[3].SizeInBytes / VertexAwesome.SizeInBytes / 3);
                    vertices += node.Value[3].SizeInBytes / VertexAwesome.SizeInBytes;
                }
                if (node.Value[4] != null && node.Key.Y - cy - 1 > 0x80000000)
                {
                    device.Vertices[0].SetSource(node.Value[4], 0, VertexAwesome.SizeInBytes);
                    device.DrawPrimitives(PrimitiveType.TriangleList, 0, node.Value[4].SizeInBytes / VertexAwesome.SizeInBytes / 3);
                    vertices += node.Value[4].SizeInBytes / VertexAwesome.SizeInBytes;
                }
                if (node.Value[5] != null && node.Key.Y - cy + 16 < 0x80000000)
                {
                    device.Vertices[0].SetSource(node.Value[5], 0, VertexAwesome.SizeInBytes);
                    device.DrawPrimitives(PrimitiveType.TriangleList, 0, node.Value[5].SizeInBytes / VertexAwesome.SizeInBytes / 3);
                    vertices += node.Value[5].SizeInBytes / VertexAwesome.SizeInBytes;
                }
                if (node.Value[6] != null)
                {
                    device.Vertices[0].SetSource(node.Value[6], 0, VertexAwesome.SizeInBytes);
                    device.DrawPrimitives(PrimitiveType.TriangleList, 0, node.Value[6].SizeInBytes / VertexAwesome.SizeInBytes / 3);
                    vertices += node.Value[6].SizeInBytes / VertexAwesome.SizeInBytes;
                }
                effect.EndPass3D();
            }
            this.Vertices = vertices;
        }
예제 #50
0
파일: QTNode.cs 프로젝트: patrykos91/Laikos
 public void DrawShadows(Effect depthWriter, BoundingFrustum cameraFrustrum)
 {
     BoundingBox transformedBox = XNAUtils.TransformBoundingBox(nodeBoundingBox, Matrix.Identity);
     ContainmentType cameraNodeContainment = cameraFrustrum.Contains(transformedBox);
     if (cameraNodeContainment != ContainmentType.Disjoint)
     {
         if (isEndNode)
         {
             DrawShadow(depthWriter);
         }
         else
         {
             nodeUL.DrawShadows(depthWriter, cameraFrustrum);
             nodeUR.DrawShadows(depthWriter, cameraFrustrum);
             nodeLL.DrawShadows(depthWriter, cameraFrustrum);
             nodeLR.DrawShadows(depthWriter, cameraFrustrum);
         }
     }
 }
예제 #51
0
 /// <summary>
 /// Randomly calculates a few Bodies' distances to the Focus
 /// Then sorts the resulting list
 /// Then calculates the screen size of the closest items
 /// In the Process, a list of active Bodies and their containers is made
 /// </summary>
 /// <param name="Focus">Unprojection of the middle of the screen into a ray</param>
 /// <param name="Bodies">Will be rearranged</param>
 /// <param name="VisibleBodies">Should be cleared before input from Manager</param>
 /// <param name="ContainingBodies">Should be cleared before input from Manager</param>
 public static void PartiallySortBodies(Ray Focus, BoundingFrustum VisibleArea, ref List<Body> Bodies
     , ref List<Body> VisibleBodies, ref List<Body> ContainingBodies)
 {
     List<Body> CalculatorBodies = new List<Body>();
     int calculators = (int)Math.Sqrt(Bodies.Count);
     for (int i = 0; i < calculators && Bodies.Count > 0; i++)
     {
         int index = MyGame.random.Next(Bodies.Count);
         CalculatorBodies.Add(Bodies[index]);
         Bodies.RemoveAt(index);
         Vector3 FocusToBody = CalculatorBodies[i].Transforms.Position - Focus.Position;
         CalculatorBodies[i].DistanceToCenter = (FocusToBody
             - Focus.Direction * Vector3.Dot(FocusToBody, Focus.Direction)).Length();
     }
     Bodies.AddRange(CalculatorBodies);
     CalculatorBodies.Clear();
     //Merge Sort with two lists
     List<List<Body>> MergeBodies = new List<List<Body>>();
     for (int i = 0; i < Bodies.Count; i++)
     {
         MergeBodies.Add(new List<Body>());
         MergeBodies[i].Add(Bodies[i]);
     }
     while (MergeBodies.Count > 1)
     {
         for (int i = 0; i < MergeBodies.Count - 1; i++)
         {
             for (int a = 0; a < MergeBodies[i].Count; a++)
             {
                 for (int b = 0; b < MergeBodies[i + 1].Count; b++)
                 {
                     if (MergeBodies[i + 1][b].DistanceToCenter < MergeBodies[i][a].DistanceToCenter)
                     {
                         MergeBodies[i].Insert(a++, MergeBodies[i + 1][b]);
                         MergeBodies[i + 1].RemoveAt(b--);
                     }
                 }
             }
             MergeBodies[i].AddRange(MergeBodies[i + 1]);
             MergeBodies.RemoveAt(i + 1);
         }
     }
     Bodies = MergeBodies[0];
     //Screen size calculation
     for (int i = 0; i < Bodies.Count; i++)
     {
         Bodies[i].ScreenPosition = Cursor.Project(VisibleArea
             , Bodies[i].Bounds.Center);
         Bodies[i].ScreenScale =
             (float)Math.Atan2(
                 Bodies[i].Bounds.Radius
                 , (Bodies[i].Bounds.Center - Manager.CameraFocus - Manager.CameraLocation).Length())
             * Manager.GameWindow.Width / 2.0f;
         if (VisibleArea.Contains(Bodies[i].Bounds) != ContainmentType.Disjoint)
         {
             if (Bodies[i].ScreenScale / 10 > 1.0f)
             {
                 Bodies[i].InitializeNestedBodies();
             }
             else
             {
                 Bodies[i].DisposeNextedBodies();
             }
             if (Bodies[i].ScreenScale > Manager.GameWindow.Width / 10.0f)
             {
                 if (Bodies[i].NestedBodies.Count > 0)
                 {
                     PartiallySortBodies(Focus, VisibleArea, ref Bodies[i].NestedBodies, ref VisibleBodies, ref ContainingBodies);
                     float DisplayOpacity = Bodies[i].ScreenScale / Manager.GameWindow.Width * 10.0f - 1.0f;
                     if (DisplayOpacity > 1.0f)
                     {
                         DisplayOpacity = 1.0f;
                     }
                     for (int j = 0; j < Bodies[i].NestedBodies.Count; j++)
                     {
                         Bodies[i].NestedBodies[j].DisplayOpacity = DisplayOpacity;
                     }
                     Bodies[i].DisplayOpacity = 1.0f - DisplayOpacity;
                     ContainingBodies.Add(Bodies[i]);
                 }
                 else
                 {
                     VisibleBodies.Add(Bodies[i]);
                 }
             }
             else
             {
                 VisibleBodies.Add(Bodies[i]);
             }
         }
     }
 }
예제 #52
0
파일: Island.cs 프로젝트: Frib/LD24
 internal IEnumerable<Entity> GetEntitiesInView(BoundingFrustum bf)
 {
     return entities.Where(x => bf.Contains(x.Box) == ContainmentType.Contains).Except(new[]{player});
 }
예제 #53
0
        public void Render(BoundingFrustum frustum, WorldPosition hoverBox)
        {
            int vertices = 0;
            uint cx = x;
            uint cy = y; //cache = anti-earthquake
            uint cz = z;
            Matrix world = Matrix.Identity;
            Vector3 middle = new Vector3(8, 8, 8);
            foreach (var node in vertexBuffers.AsEnumerable)
            {
                if (node.Value == null)
                    continue;
                world.Translation = new Vector3((int)(node.Key.X - cx), (int)(node.Key.Y - cy), (int)(node.Key.Z - cz));
                bs.Center = middle + world.Translation;

                if (ContainmentType.Disjoint == frustum.Contains(bs))
                    continue;
                effect.WMatrix = world;

                effect.BeginPass3D();
                device.Indices = Static.Indices;
                VBuffer7 vbuffer = node.Value;
                device.Vertices[0].SetSource(vbuffer.VertexBuffer, 0, VertexAwesome.SizeInBytes);
                Action<int> draw =
                    i =>
                    {
                        if (vbuffer.Count[i] != 0)
                        {
                            device.DrawIndexedPrimitives(PrimitiveType.TriangleList, vbuffer.Offset[i], 0, vbuffer.Count[i], 0, vbuffer.Count[i] / 2);
                            vertices += vbuffer.Count[i];
                        }
                    };
                if (node.Key.Z - cz - 1 > 0x80000000) draw(0);
                if (node.Key.Z - cz + 16 < 0x80000000) draw(1);
                if (node.Key.X - cx - 1 > 0x80000000) draw(2);
                if (node.Key.X - cx + 16 < 0x80000000) draw(3);
                if (node.Key.Y - cy - 1 > 0x80000000) draw(4);
                if (node.Key.Y - cy + 16 < 0x80000000) draw(5);
                draw(6);
                effect.EndPass3D();
            }
            this.Vertices = vertices;

            //hovered box:
            if (hoverBox != null)
            {
                Static.Effect.LightDirection = Vector3.Backward;
                Static.Effect.AmbientLightColor = Color.LightGreen.ToVector4();
                hoverBoxMesh.Draw(Matrix.CreateTranslation((int)(hoverBox.X - cx), (int)(hoverBox.Y - cy), (int)(hoverBox.Z - cz)));
            }
        }
예제 #54
0
        public void BoundingFrustumToBoundingFrustumTests()
        {
            var view = Matrix.CreateLookAt(new Vector3(0, 0, 5), Vector3.Zero, Vector3.Up);
            var projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4, 1, 1, 100);
            var testFrustum = new BoundingFrustum(view * projection);

            // Same frustum.
            Assert.That(testFrustum.Contains(testFrustum), Is.EqualTo(ContainmentType.Contains));
            Assert.That(testFrustum.Intersects(testFrustum), Is.True);

            var otherFrustum = new BoundingFrustum(Matrix.Identity);

            // Smaller frustum contained entirely inside.
            var view2 = Matrix.CreateLookAt(new Vector3(0, 0, 4), Vector3.Zero, Vector3.Up);
            var projection2 = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4, 1, 1, 50);
            otherFrustum.Matrix = view2 * projection2;

            Assert.That(testFrustum.Contains(otherFrustum), Is.EqualTo(ContainmentType.Contains));
            Assert.That(testFrustum.Intersects(otherFrustum), Is.True);

            // Same size frustum, pointing in the same direction and offset by a small amount.
            otherFrustum.Matrix = view2 * projection;

            Assert.That(testFrustum.Contains(otherFrustum), Is.EqualTo(ContainmentType.Intersects));
            Assert.That(testFrustum.Intersects(otherFrustum), Is.True);

            // Same size frustum, pointing in the opposite direction and not overlapping.
            var view3 = Matrix.CreateLookAt(new Vector3(0, 0, 6), new Vector3(0, 0, 7), Vector3.Up);
            otherFrustum.Matrix = view3 * projection;

            Assert.That(testFrustum.Contains(otherFrustum), Is.EqualTo(ContainmentType.Disjoint));
            Assert.That(testFrustum.Intersects(otherFrustum), Is.False);

            // Larger frustum, entirely containing test frustum.
            var view4 = Matrix.CreateLookAt(new Vector3(0, 0, 10), Vector3.Zero, Vector3.Up);
            var projection4 = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4, 1, 1, 1000);
            otherFrustum.Matrix = view4 * projection4;

            Assert.That(testFrustum.Contains(otherFrustum), Is.EqualTo(ContainmentType.Intersects));
            Assert.That(testFrustum.Intersects(otherFrustum), Is.True);
        }
예제 #55
0
파일: Octree.cs 프로젝트: rushTENm/Bounding
        /// 
        /// Draws the octree.
        /// 
        /// The viewing matrix.
        /// The projection matrix.
        /// The objects in the octree.
        /// The number of octrees drawn.
        public int Draw(Matrix view, Matrix projection, List objects)
        {
            BoundingFrustum frustum = new BoundingFrustum(view * projection);
            ContainmentType containment = frustum.Contains(this.bounds);

            return this.Draw(frustum, view, projection, containment, objects);
        }
예제 #56
0
파일: Octree.cs 프로젝트: rushTENm/Bounding
        /// 
        /// Draws the octree.
        /// 
        /// The viewing frustum used to determine if the octree is in view.
        /// The viewing matrix.
        /// The projection matrix.
        /// Determines how much of the octree is visible.
        /// The objects in the octree.
        /// The number of octrees drawn.
        private int Draw(BoundingFrustum frustum, Matrix view, Matrix projection,
            ContainmentType containment, List objects)
        {
            int count = 0;

            if (containment != ContainmentType.Contains)
            {
                containment = frustum.Contains(this.bounds);
            }

            // Draw the octree only if it is atleast partially in view.
            if (containment != ContainmentType.Disjoint)
            {
                // Draw the octree's bounds if there are objects in the octree.
                if (this.objects.Count > 0)
                {
                    if (DebugDraw != null)
                        DebugDraw.AddShape(new DebugBox(this.bounds, Color.White));
                    objects.AddRange(this.objects);
                    count++;
                }

                // Draw the octree's children.
                if (this.children != null)
                {
                    foreach (Octree child in this.children)
                    {
                        count += child.Draw(frustum, view, projection, containment, objects);
                    }
                }
            }

            return count;
        }
예제 #57
0
        public void Draw2D()
        {
            BoundingFrustum frustum = new BoundingFrustum(GameState.view * GameState.projection);
            ContainmentType containmentType = frustum.Contains(Vector3.Transform(new Vector3(0.0f, 0.0f, 0.0f), world));

            centerOnScreen = containmentType != ContainmentType.Disjoint;

            if (kind == HexaKind.Water)
            {
                return;
            }

            if (containmentType != ContainmentType.Disjoint)
            {
                Vector3 point3D = GameState.game.GraphicsDevice.Viewport.Project(new Vector3(0.0f, 0.0f, 0.0f), GameState.projection, GameState.view, world);
                Vector2 point2D = new Vector2();
                Vector2 posHexaIcon = new Vector2();
                point2D.X = point3D.X;
                point2D.Y = point3D.Y;
                posHexaIcon = point2D;

                Texture2D playerIcon = GameResources.Inst().GetHudTexture(HUDTexture.PlayerColor);
                Rectangle playerIconRect = new Rectangle((int)point2D.X - playerIcon.Width / 2, (int)point2D.Y - playerIcon.Height / 2, playerIcon.Width, playerIcon.Height);

                SpriteBatch spriteBatch = GameState.spriteBatch;

                Vector2 stringCenter = GameResources.Inst().GetFont(EFont.MedievalMedium).MeasureString(model.GetCurrentSource() + "") * 0.5f;

                /* x, y coord
                Vector2 stringCenter = GameResources.Inst().GetFont(EFont.MedievalMedium).MeasureString("[" + x + ";" + y + "]") * 0.5f;
                */

                // now subtract the string center from the text position to find correct position
                point2D.X = (int)(point2D.X - stringCenter.X);
                point2D.Y = (int)(point2D.Y - stringCenter.Y);

                spriteBatch.Begin();

                /* x, y coord
                if (kind == HexaKind.Water)
                {
                    DrawHexaNumber(spriteBatch, point2D);
                    spriteBatch.End();
                    return;
                }*/

                bool drawNumber = true;
                TownModel tempTown = null;
                if (GameMaster.Inst().GetFortState() == EFortState.Normal)
                {
                    foreach (TownView town in townView)
                    {
                        if (town.getIsMarked())
                        {
                            tempTown = town.getTownModel();
                            if (tempTown.GetBuildingKind(hexaID) != BuildingKind.NoBuilding ||
                                tempTown.GetOwner() == GameMaster.Inst().GetActivePlayer())
                                drawNumber = false;
                            break;
                        }
                    }

                    if (drawNumber && pickVars.pickActive)
                    {
                        HUDTexture texture = HUDTexture.HUDCount;
                        switch (kind)
                        {
                            case HexaKind.Cornfield: texture = HUDTexture.SmallCorn; break;
                            case HexaKind.Forest: texture = HUDTexture.SmallWood; break;
                            case HexaKind.Mountains: texture = HUDTexture.SmallOre; break;
                            case HexaKind.Pasture: texture = HUDTexture.SmallMeat; break;
                            case HexaKind.Stone: texture = HUDTexture.SmallStone; break;
                        }
                        if(texture != HUDTexture.HUDCount)
                          DrawHexaIcon(spriteBatch, posHexaIcon, texture, texture);
                    }
                }
                else
                {
                    if (!IsInFortRadius())// || (GameMaster.Inst().GetFortState() == EFortState.DestroyingHexa && model.GetDestroyed()))
                        drawNumber = false;
                }

                if (GameMaster.Inst().GetFortState() != EFortState.Normal)// &&
                    //(GameMaster.Inst().GetFortState() != EFortState.DestroyingHexa || !model.GetDestroyed()))
                {
                    HUDTexture textPassive = HUDTexture.DestroyPassive, textActive = HUDTexture.DestroyActive;
                    if (IsInFortRadius())
                    {
                        switch(GameMaster.Inst().GetFortState())
                        {
                            case EFortState.CapturingHexa:
                                textPassive = HUDTexture.SwordsPassive;
                                textActive = HUDTexture.SwordsActive;
                                break;
                            case EFortState.DestroyingHexa:
                                textPassive = HUDTexture.DestroyPassive;
                                textActive = HUDTexture.DestroyActive;
                                break;
                        }
                        DrawHexaIcon(spriteBatch, posHexaIcon, textPassive, textActive);
                    }
                }

                if (model.GetCaptured())
                {
                    spriteBatch.Draw(playerIcon, playerIconRect, model.GetCapturedPlayer().GetColor());
                }

                if (drawNumber)
                {
                    DrawHexaNumber(spriteBatch, point2D);
                }
                else if(GameMaster.Inst().GetFortState() == EFortState.Normal)
                {
                    if (tempTown.GetBuildingKind(hexaID) == BuildingKind.NoBuilding && tempTown.GetOwner() == GameMaster.Inst().GetActivePlayer())
                    {
                        DrawHexaIcon(spriteBatch, posHexaIcon, HUDTexture.HammersPassive, HUDTexture.HammersActive);
                        DrawHexaNumber(spriteBatch, point2D);
                    }
                    else
                    {
                            DrawHexaIcon(spriteBatch, posHexaIcon, tempTown.GetSpecialBuilding(hexaID).GetIconPassive(), tempTown.GetSpecialBuilding(hexaID).GetIconActive());
                            if (model.GetCaptured())
                            {
                                spriteBatch.Draw(playerIcon, playerIconRect, model.GetCapturedPlayer().GetColor());
                            }
                            if(tempTown.GetBuildingKind(hexaID) == BuildingKind.SourceBuilding)
                                DrawHexaNumber(spriteBatch, point2D);
                    }
                }
                spriteBatch.End();
            }
        }
예제 #58
0
        /// <summary>
        /// Draws every mesh within the model using ScalePositionRotation properties
        /// Draws all Nested Bodies with an Offset of Position
        /// </summary>
        public virtual void Draw(BoundingFrustum VisibleArea, Vector3 Position)
        {
            if (VisibleArea.Contains(Bounds) != ContainmentType.Disjoint)
            {
                if (ModelVertices != null)
                {
                    Matrix transform = transforms.Rotation
                        * Matrix.CreateScale(transforms.Scale)
                        * Matrix.CreateTranslation(transforms.Position + Position);
                    effect.Parameters["World"].SetValue(transform);
                    MyGame.graphics.GraphicsDevice.VertexDeclaration = DefaultDeclaration;

                    effect.Begin();
                    effect.CurrentTechnique.Passes.First<EffectPass>().Begin();
                    MyGame.graphics.GraphicsDevice.DrawUserIndexedPrimitives<VertexPositionTexture>(
                        PrimitiveType.TriangleList
                        , ModelVertices
                        , 0
                        , ModelVertices.Length
                        , ModelIndices
                        , 0
                        , ModelIndices.Length / 3);
                    effect.CurrentTechnique.Passes.First<EffectPass>().End();
                    effect.End();
                }
                for (int i = 0; i < NestedBodies.Count; i++)
                {
                    NestedBodies[i].Draw(VisibleArea, transforms.Position + Position);
                }
            }
        }
예제 #59
0
        /// <summary>
        /// Helper Draw function. Determines what objects are fully visible and what objects are transparent.
        /// </summary>
        private void FindVisible()
        {
            currentFrustum = new BoundingFrustum(CurrentCamera.View * CurrentCamera.Projection);
            Matrix transView = Matrix.CreateLookAt(CurrentCamera.Position, CurrentCamera.TargetPosition - Vector3.UnitZ * 30, Vector3.UnitZ);
            Matrix trans1Proj = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4  / 15,
                (float)GraphicOptions.graphics.GraphicsDevice.Viewport.Width /
                        (float)GraphicOptions.graphics.GraphicsDevice.Viewport.Height,
                        10f,
                        475f);
            transparent1Frustum = new BoundingFrustum(transView * trans1Proj);

            //this section updates each entity and then determines if they are within the bounding frustum
            drawableEntities.Clear();
            transparentEntities.Clear();
            int i = 0;
            foreach (SceneLayer layer in layers)
            {
                drawableEntities.Add(new SceneLayer());
                transparentEntities.Add(new SceneLayer());
                drawableEntities[i].DrawLayer = layer.DrawLayer;
                transparentEntities[i].DrawLayer = layer.DrawLayer;

                foreach (KeyValuePair<int, Object3> ent in layer.entityDictionary3D)
                {
                    if (currentFrustum.Contains(ent.Value.BoundingSphere) != ContainmentType.Disjoint)
                    {
                        if (transparent1Frustum.Contains(ent.Value.BoundingSphere) != ContainmentType.Disjoint
                            && ent.Value.TransparencyEnabled && GraphicOptions.TransparentWalls)
                        {
                            transparentEntities[i].Add(ent);
                        }
                        if (transparent1Frustum.Contains(ent.Value.BoundingSphere) != ContainmentType.Contains
                            || !ent.Value.TransparencyEnabled || !GraphicOptions.TransparentWalls)
                        {
                            drawableEntities[i].Add(ent);
                        }

                    }
                }
                foreach (KeyValuePair<int, VertexGroup> ent in layer.entityDictionaryVertex)
                {
                  drawableEntities[i].Add(ent);
                }
                foreach (KeyValuePair<int, ParticleEmitter> ent in layer.entityDictionaryEmitter)
                {
                    if (currentFrustum.Contains(ent.Value.BoundingSphere) != ContainmentType.Disjoint)
                    {
                        drawableEntities[i].Add(ent);
                    }
                    else
                    {
                        ent.Value.OutOfFrustumDraw();
                    }
                }

                foreach (KeyValuePair<int, VertexColorGroup> ent in layer.entityDictionaryVertexColor)
                {
                    // if (currentFrustum.Contains(ent.Value.BoundingSphere) != ContainmentType.Disjoint)
                    // {
                    drawableEntities[i].Add(ent);
                    // }
                }
                foreach (KeyValuePair<int, VertexPositionColorTextureGroup> ent in layer.entityDictionaryVPCT)
                {
                    // if (currentFrustum.Contains(ent.Value.BoundingSphere) != ContainmentType.Disjoint)
                    // {
                    drawableEntities[i].Add(ent);
                    // }
                }
                i++;
            }
        }
예제 #60
0
        public void GetChunksIntersecting(BoundingFrustum frustum, HashSet<VoxelChunk> chunks)
        {
            chunks.Clear();
            BoundingBox frustumBox = MathFunctions.GetBoundingBox(frustum.GetCorners());
            GetChunksIntersecting(frustumBox, chunks);

            chunks.RemoveWhere(chunk => frustum.Contains(chunk.GetBoundingBox()) == ContainmentType.Disjoint);
        }