Radegast.Rendering.SceneWindow.Render C# (CSharp) Method

        private void Render(bool picking)
        {
            // If we have more than one active GL control on the screen, make this one active
            glControl.MakeCurrent();

            SortCullInterpolate();

            if (picking)
            {
                GL.ClearColor(1f, 1f, 1f, 1f);
            }
            else
            {
                if (RenderSettings.WaterReflections)
                {
                    framesSinceReflection++;
                    timeSinceReflection += lastFrameTime;

                    if (Camera.Modified || (framesSinceReflection > 4 && timeSinceReflection > 0.1f))
                    {
                        GL.ClearColor(0, 0, 0, 0);
                        CreateReflectionTexture(Client.Network.CurrentSim.WaterHeight, 512);
                        CreateRefractionDepthTexture(Client.Network.CurrentSim.WaterHeight, 512);
                        glControl_Resize(null, null);
                        framesSinceReflection = 0;
                        timeSinceReflection = 0f;
                    }
                }
                GL.ClearColor(0.39f, 0.58f, 0.93f, 1.0f);
            }

            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit | ClearBufferMask.StencilBufferBit);
            GL.LoadIdentity();

            // Setup wireframe or solid fill drawing mode
            if (Wireframe && !picking)
            {
                GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line);
            }
            else
            {
                GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
            }

            Camera.LookAt();

            GL.Light(LightName.Light0, LightParameter.Position, sunPos);

            // Push the world matrix
            GL.PushMatrix();

            if (!Camera.Manual && trackedObject != null)
            {
                // If camera is locked onto our avatar, follow us
                if (trackedObject == myself)
                {
                    Vector3 camPos = myself.RenderPosition + new Vector3(-4, 0, 1) * Client.Self.Movement.BodyRotation;
                    Camera.Position = camPos;
                    Camera.FocalPoint = myself.RenderPosition + new Vector3(5, 0, 0) * Client.Self.Movement.BodyRotation;
                }
                else
                {
                    if (lastTrackedObjectPos == RHelp.InvalidPosition)
                    {
                        lastTrackedObjectPos = trackedObject.RenderPosition;
                    }
                    else if (lastTrackedObjectPos != trackedObject.RenderPosition)
                    {
                        Vector3 diffPos = (trackedObject.RenderPosition - lastTrackedObjectPos);
                        Camera.Position += diffPos;
                        Camera.FocalPoint += diffPos;
                        lastTrackedObjectPos = trackedObject.RenderPosition;
                    }
                }
            }

            if (Camera.Modified)
            {
                GL.GetFloat(GetPName.ProjectionMatrix, out ProjectionMatrix);
                GL.GetFloat(GetPName.ModelviewMatrix, out ModelMatrix);
                GL.GetInteger(GetPName.Viewport, Viewport);
                Frustum.CalculateFrustum(ProjectionMatrix, ModelMatrix);
                UpdateCamera();
                Camera.Modified = false;
                Camera.Step(lastFrameTime);
            }

            if (picking)
            {
                GL.Disable(EnableCap.Lighting);
                terrain.Render(RenderPass.Picking, 0, this, lastFrameTime);
                RenderObjects(RenderPass.Picking);
                RenderAvatars(RenderPass.Picking);
                GLHUDBegin();
                RenderText(RenderPass.Picking);
                GLHUDEnd();
                GL.Enable(EnableCap.Lighting);
            }
            else
            {
                texturesRequestedThisFrame = 0;
                meshingsRequestedLastFrame = meshingsRequestedThisFrame;
                meshingsRequestedThisFrame = 0;

                CheckKeyboard(lastFrameTime);

                terrain.Render(RenderPass.Simple, 0, this, lastFrameTime);

                // Alpha mask elements, no blending, alpha test for A > 0.5
                GL.Enable(EnableCap.AlphaTest);
                RenderObjects(RenderPass.Simple);
                RenderAvatarsSkeleton(RenderPass.Simple);
                RenderObjects(RenderPass.Invisible);
                RenderAvatars(RenderPass.Simple);
                GL.Disable(EnableCap.AlphaTest);

                GL.DepthMask(false);
                RenderOccludedObjects();

                // Alpha blending elements, disable writing to depth buffer
                GL.Enable(EnableCap.Blend);
                RenderWater();
                RenderObjects(RenderPass.Alpha);
                GL.DepthMask(true);

                GLHUDBegin();
                RenderText(RenderPass.Simple);
                RenderStats();
                chatOverlay.RenderChat(lastFrameTime, RenderPass.Simple);
                GLHUDEnd();
                GL.Disable(EnableCap.Blend);
            }

            // Pop the world matrix
            GL.PopMatrix();
        }