public void RunMainLoop(Panel Panel, MainForm.MainForm mainForm)
        {
            RenderLoop.Run(Panel, () =>
            {
                if (dontRender)
                {
                    return;
                }

                //Resizing
                if (Device.MustResize)
                {
                    Device.Resize();
                    Camera.ProjectionMatrix.AspectRatio = (float)Panel.Width / Panel.Height;
                }

                mainForm.KeyboardController();
                mainForm.SetToolStripStatusLabel(Camera + " FPS: " + $"{SharpFps.StatFPS:0.0000}");

                //clear color
                Device.Clear(backgroundColor);

                //Set matrices
                viewProjection = Camera.ViewMatrix.GetViewMatrix() * Camera.ProjectionMatrix.GetProjectionMatrix();
                frustum        = new BoundingFrustum(viewProjection);

                mainForm.TexturePatternEditor.Animate();

                if (ShowCollision)
                {
                    foreach (var c in mainForm.CollisionEditorDict.Values)
                    {
                        c.RenderCollisionModel(this);
                    }
                    mainForm.LevelEditor.RenderShadowCollisionModel(this);
                }
                else
                {
                    mainForm.LevelEditor.RenderLevelModel(this);
                }

                if (ShowChunkBoxes)
                {
                    mainForm.LevelEditor.visibilityFunctions.RenderChunkModels(this);
                }

                if (ShowObjects == CheckState.Checked)
                {
                    foreach (var l in mainForm.LayoutEditorDict.Values)
                    {
                        l.RenderSetObjects(this, true);
                    }
                }
                else if (ShowObjects == CheckState.Indeterminate)
                {
                    foreach (var l in mainForm.LayoutEditorDict.Values)
                    {
                        l.RenderSetObjects(this, false);
                    }
                }

                if (ShowCameras)
                {
                    mainForm.CameraEditor.RenderCameras(this);
                }

                if (ShowStartPositions)
                {
                    mainForm.ConfigEditor.RenderStartPositions(this);
                }

                if (ShowSplines)
                {
                    mainForm.ConfigEditor.SplineEditor.RenderSplines(this);
                    mainForm.LevelEditor.shadowSplineEditor.RenderSplines(this);
                }

                if (ShowQuadtree)
                {
                    foreach (var c in mainForm.CollisionEditorDict.Values)
                    {
                        c.RenderQuadtree(this);
                    }
                }

                //present
                Device.Present();
                SharpFps.EndFrame();
            });

            //release resources

            whiteDefault.Dispose();
            mainForm.LevelEditor.bspRenderer.Dispose();
            TextureManager.DisposeTextures();
            dffRenderer.Dispose();
            foreach (var c in mainForm.CollisionEditors)
            {
                c.DisposeRenderStuff();
            }
            mainForm.ConfigEditor.SplineEditor.DisposeSplines();

            Cube.Dispose();
            Pyramid.Dispose();
            Cylinder.Dispose();
            Sphere.Dispose();

            basicBuffer.Dispose();
            basicShader.Dispose();

            defaultBuffer.Dispose();
            defaultShader.Dispose();

            collisionBuffer.Dispose();
            collisionShader.Dispose();

            tintedBuffer.Dispose();
            tintedShader.Dispose();

            Device.Dispose();
        }
Exemple #2
0
        public static void RunMainLoop(Panel Panel)
        {
            RenderLoop.Run(Panel, () =>
            {
                if (dontRender)
                {
                    return;
                }

                //Resizing
                if (device.MustResize)
                {
                    device.Resize();
                    aspectRatio = (float)Panel.Width / Panel.Height;
                }

                Program.mainForm.KeyboardController();

                sharpFPS.Update();

                Program.mainForm.SetToolStripStatusLabel(Camera.GetInformation() + " FPS: " + sharpFPS.FPS.ToString());

                //clear color
                device.Clear(backgroundColor);

                //Set matrices
                viewProjection = Camera.GenerateLookAtRH() * Matrix.PerspectiveFovRH(fovAngle, aspectRatio, near, far);
                frustum        = new BoundingFrustum(viewProjection);

                if (showCollision)
                {
                    CollisionRendering.RenderCollisionModel(viewProjection, -Camera.GetForward(), Camera.GetUp());
                    BSPRenderer.RenderShadowCollisionModel(viewProjection);
                }
                else
                {
                    BSPRenderer.RenderLevelModel(viewProjection);
                }

                if (showChunkBoxes)
                {
                    VisibilityFunctions.RenderChunkModels(viewProjection);
                }

                if (showObjects == CheckState.Checked)
                {
                    Program.layoutEditor.layoutSystem.RenderAllSetObjects(true);
                }
                else if (showObjects == CheckState.Indeterminate)
                {
                    Program.layoutEditor.layoutSystem.RenderAllSetObjects(false);
                }

                if (showCameras)
                {
                    Program.cameraEditor.RenderAllCameras();
                }

                if (showStartPositions)
                {
                    Program.configEditor.RenderStartPositions();
                }

                if (showSplines)
                {
                    Program.splineEditor.RenderSplines();
                }

                if (showQuadtree)
                {
                    CollisionRendering.RenderQuadTree();
                }

                //present
                device.Present();
            });

            //release resources
            foreach (RenderWareModelFile r in BSPRenderer.BSPStream)
            {
                foreach (SharpMesh mesh in r.meshList)
                {
                    mesh.Dispose();
                }
            }

            foreach (RenderWareModelFile r in BSPRenderer.ShadowCollisionBSPStream)
            {
                foreach (SharpMesh mesh in r.meshList)
                {
                    mesh.Dispose();
                }
            }

            foreach (RenderWareModelFile r in DFFRenderer.DFFStream.Values)
            {
                foreach (SharpMesh mesh in r.meshList)
                {
                    mesh.Dispose();
                }
            }

            CollisionRendering.Dispose();

            if (BSPRenderer.whiteDefault != null)
            {
                BSPRenderer.whiteDefault.Dispose();
            }

            foreach (ShaderResourceView texture in BSPRenderer.TextureStream.Values)
            {
                texture.Dispose();
            }

            Cube.Dispose();
            Pyramid.Dispose();
            Cylinder.Dispose();

            basicBuffer.Dispose();
            basicShader.Dispose();

            defaultBuffer.Dispose();
            defaultShader.Dispose();

            collisionBuffer.Dispose();
            collisionShader.Dispose();

            device.Dispose();
        }