Beispiel #1
0
        /// <summary>
        /// copies the backcound to the foreground.
        /// </summary>
        public void CopyFromBackGround()
        {
            // Draw the Texture from Backbuffer by a Polygon Rectangle for the full screen

            xyArray    FP = new xyArray(); FP.data = new xy[] { new xy(0, 0), new xy(0, 1), new xy(1, 1), new xy(1, 0) };
            Matrix     P  = ProjectionMatrix;
            GLShader   S  = Shader;
            RenderKind K  = RenderKind;

            RenderKind = RenderKind.Render;
            Shader     = BackGroundShader;
            Texture T = texture;

            texture = BackBuffer.Texture;
            PushMatrix();
            ModelMatrix = Matrix.Translation(new xyz(0, 0, 1));
            PolygonMode PM = PolygonMode;

            PolygonMode      = PolygonMode.Fill;
            ProjectionMatrix = Bias;

            drawPolyLine(FP);
            ProjectionMatrix = P;
            PopMatrix();

            // Save Back
            RenderKind  = K;
            texture     = T;
            this.Shader = S;
            PolygonMode = PM;
        }
Beispiel #2
0
        /// <summary>
        /// refreshes the back ground for <see cref="ForeGroundDraw"/>.
        /// </summary>
        public void RefreshBackGround()
        {
            Texture  Savet = texture;
            GLShader S     = Shader;

            BackBuffer.BackGround = BackColor;
            if (BackBuffer.FboHandle <= 0)
            {
                BackBuffer.Init((int)ViewPort.Width, (int)ViewPort.Height);
            }

            RenderKind K = RenderKind;

            RenderKind = RenderKind.Render;
            Matrix P = ProjectionMatrix;

            ProjectionMatrix = Matrix.scale(new xyz(1, -1, 1)) * P;

            //--------- Draw scene to Backbuffer
            BackBuffer.EnableWriting();

            OnPaint();

            BackBuffer.DisableWriting();
            texture          = Savet;
            ProjectionMatrix = P;
            RenderKind       = K;
            Shader           = S;
        }
Beispiel #3
0
        /// <summary>
        /// calculates a new shadow.
        /// </summary>
        public void ResetShadow()
        {
            ShadowDirty = false;
            if (!Shadow)
            {
                return;
            }
            GLShader SaveShader = this.Shader;

            RenderKind = RenderKind.Render;
            Matrix  SaveP       = ProjectionMatrix;
            Texture SaveTexture = texture;

            GL.Enable(EnableCap.PolygonOffsetFill);
            GL.PolygonOffset(1, 0);
            Shader           = ShadowDepthShader;
            ProjectionMatrix = GetLightProjectionMatrix();
            ShadowFBO.EnableWriting();
            OnPaint();
            ShadowFBO.DisableWriting();
            GL.ActiveTexture(TextureUnit.Texture1);
            GL.BindTexture(TextureTarget.Texture2D, ShadowFBO.FboTexture);
            ProjectionMatrix = SaveP;
            Shader           = SaveShader;
            GL.ActiveTexture(TextureUnit.Texture0);
        }
Beispiel #4
0
        /// <summary>
        /// is called from <see cref="OpenGlDevice.setTexture(Texture)"/> to set the values to the current <see cref="OpenGlDevice.Shader"/>.
        /// </summary>
        /// <param name="Shader">the current <see cref="OpenGlDevice.Shader"/>.</param>
        public void SetAttributes(GLShader Shader)
        {
            Matrix M             = Matrix.Scale(new xyz(1 / WorldWidth, -1 / WorldHeight, 1 / WorldWidth));
            Matrix TextureMatrix = Matrix.identity;

            if (SoBigAsPossible != Texture.BigAsPosible.None)
            {
                TextureMatrix = Matrix.Scale(new xyz(1, -1, 1));
            }
            else
            {
                TextureMatrix = M * Matrix.Translation(new xyz(-Translation.x, -Translation.y, 0)) * Matrix.Rotation(new xyz(0, 0, 1), -Rotation);
            }

            GL.ActiveTexture(TextureUnit.Texture0 + Index);
            GL.BindTexture(TextureTarget.Texture2D, Handle);
            OpenGlDevice.CheckError();
            Field T = Shader.getvar("Texture" + Index.ToString() + "Enabled");

            if (T != null)
            {
                T.SetValue(1);
            }

            T = Shader.getvar("Texture" + Index.ToString() + "_");
            if (T != null)
            {
                T.SetValue(Index);
            }
            T = Shader.getvar("Texture" + Index.ToString() + "Matrix");
            if (T != null)
            {
                T.SetMatrix(TextureMatrix);
            }
            if (NormalMap)
            {
                T = Shader.getvar("NormalMap");
                if (T != null)
                {
                    T.SetValue(true);
                }
            }
            if (Tesselation)
            {
                T = Shader.getvar("Tesselation");
                if (T != null)
                {
                    T.SetValue(true);
                }
            }
        }
Beispiel #5
0
 void ActivateShader()
 {
     ShadowDepthShader = new GLShader(OpenGlDevice.DepthFragment, OpenGlDevice.DepthVertex, this);
     BackGroundShader  = new GLShader(BackGroundFragment, BackGroundVertex, this);
     PickingShader     = new GLShader(Selector.PickingFragmentShader, Selector.PickingVertexShader, this);
 }
Beispiel #6
0
        /// <summary>
        /// overrides the draw method .
        /// </summary>
        /// <param name="Device"></param>
        protected override void OnDraw(OpenGlDevice Device)
        {
            int StoredObject = -1;

            if (Selector.WriteToSnap)
            {
                CompiledMesh C = this as CompiledMesh;
                if (C != null)
                {
                    StoredObject = C.SnapObject;
                }
                Device.Selector.SetObjectNumber(StoredObject);
            }
            Entity.CurrentEntity = this;


            if (Compiling)
            {
                MeshCreator.AddProg(this);
                return;
            }
            float     PW   = Device.PenWidth;
            PenStyles PS   = Device.PenStyle;
            Material  Save = Device.Material;

            if (Mode == PolygonMode.Line)
            {
                Device.PenWidth = PenWidth;
                Device.PenStyle = PenStyle;
                Device.Emission = PenColor;
            }
            else
            {
                Device.Material = Material;
            }
            PolygonMode SavePolygonMode = Device.PolygonMode;

            Device.PolygonMode = Mode;
            if ((VAO >= 0) && (Device.RenderKind == RenderKind.Render))
            {
                OpenGlDevice.CheckError();
                Field C = null;
                if (Colors != null)
                {
                    C = Device.Shader.getvar("ColorEnabled");
                    if (C != null)
                    {
                        C.SetValue(1);
                    }
                }
                GL.BindVertexArray(VAO);
                if (!TesselateOn)
                {
                    GL.DrawElements(Primitives, VBOIndices.IndexArray.Length, DrawElementsType.UnsignedInt, 0);
                    OpenGlDevice.CheckError();
                }
                else
                {
                    GLShader SaveShader = Device.Shader;
                    Device.Shader = Device.TesselationtShader;
                    if (FieldResolutionFactor == null)
                    {
                        FieldResolutionFactor = Device.Shader.getvar("ResolutionFactor");
                    }
                    if (FieldDispFactor == null)
                    {
                        FieldDispFactor = Device.Shader.getvar("gDispFactor");
                    }
                    if (FieldEyePos == null)
                    {
                        FieldEyePos = Device.Shader.getvar("gEyeWorldPos");
                    }
                    if (FieldDispFactor != null)
                    {
                        FieldDispFactor.SetValue((float)TessDispFactor);
                    }
                    if (FieldEyePos != null)
                    {
                        FieldEyePos.SetValue(Device.Camera.Position);
                    }
                    Device.texture = TessDisplacementMap;
                    //GL.ActiveTexture(TextureUnit.Texture0 + 1);
                    //GL.BindTexture(TextureTarget.Texture2D, TessDisplacementMap.Handle);
                    if (Texture != null)
                    {
                        Device.texture = Texture;
                    }

                    if (FieldResolutionFactor != null)
                    {
                        FieldResolutionFactor.SetValue((float)TessResolutionFactor);
                    }

                    GL.DrawElements(BeginMode.Patches, VBOIndices.IndexArray.Length, DrawElementsType.UnsignedInt, 0);
                    TessDisplacementMap.Hide();
                    Device.Shader  = SaveShader;
                    Device.texture = null;
                }

                GL.BindVertexArray(0);
                if (Colors != null)
                {
                    if (C != null)
                    {
                        C.SetValue(0);
                    }
                }
            }
            else
            {
                if (Primitives == BeginMode.Quads)
                {
                    DrawQuads(Device);
                }
                else
                {
                    Texture SaveTexture = Device.texture;
                    Device.texture = Texture;
                    Device.drawMesh(Indices, VBOPosition.xyzPoints, VBONormals.xyzPoints, VBOTexture.xyPoints, VBOColors.xyzPoints);
                    Device.texture = SaveTexture;
                }
            }
            Device.PolygonMode = SavePolygonMode;
            if (Mode == PolygonMode.Line)
            {
                Device.PenWidth = PW;
                Device.PenStyle = PS;
                Device.Emission = Color.Black;
            }
            Device.Material = Save;
        }