Jump to content
  • Advertisement
Sign in to follow this  
8Observer8

OpenGL gl_PointSize doesn't work

This topic is 572 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

Hello

I want to draw a point with custom size in C# OpenGL3.3 OpenTK like this: https://jsfiddle.net/8Observer8/cc72u1u5/

But I see the point with size 1 pixel

I attached the project. Everyone can run it in VS 2012 - VS 2015

using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using OpenTK;
using OpenTK.Graphics.OpenGL;
using Utils;

namespace HelloPoint1
{
    class MainWindow : GameWindow
    {
        string VSHADER_SOURCE = null;
        string FSHADER_SOURCE = null;

        bool canDraw = false;

        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);

            // Load shaders from files
            ShaderLoader.LoadShader("./Shaders/vShader.glsl", out VSHADER_SOURCE);
            ShaderLoader.LoadShader("./Shaders/fShader.glsl", out FSHADER_SOURCE);
            if (VSHADER_SOURCE == null || FSHADER_SOURCE == null)
            {
                Console.WriteLine("Failed to load shaders from files");
                return;
            }

            // Specify the color for clearing
            GL.ClearColor(Color.Black);

            GL.Enable(EnableCap.ProgramPointSize);

            canDraw = true;
        }

        protected override void OnRenderFrame(FrameEventArgs e)
        {
            base.OnRenderFrame(e);

            if (!canDraw) return;

            GL.Clear(ClearBufferMask.ColorBufferBit);

            // Draw a point
            GL.DrawArrays(PrimitiveType.Points, 0, 1);

            GL.Flush();

            SwapBuffers();
        }
    }
}

Edited by 8Observer8

Share this post


Link to post
Share on other sites
Advertisement

can you provide the source to base.OnLoad(); and base.OnRenderFrame(e);  otherwise i don't even see you setting up vertices, yet alone setting their sizes.

Edited by slicer4ever

Share this post


Link to post
Share on other sites
Now it works!
 
PointWithCustomSizeAndColour_512x512.png
 
I forgot to initialise the shaders.
 
 
vShader.glsl
#version 330
 
void main()
{
    gl_Position = vec4(0.8, 0.0, 0.0, 1.0);
    gl_PointSize = 10.0;
}
 
fShader.glsl
#version 330
 
out vec4 fragColor;
 
void main()
{
    fragColor = vec4(1.0, 0.0, 0.0, 1.0);
}
 
Program.cs
namespace PointWithCustomSizeAndColour
{
    class Program
    {
        static void Main(string[] args)
        {
            using (MainWindow mainWindow = new MainWindow())
            {
                mainWindow.Run(30);
            }
        }
    }
}
 
MainWindow.cs
using System;
using System.Drawing;
using OpenTK;
using OpenTK.Graphics.OpenGL;
using System.IO;

namespace PointWithCustomSizeAndColour
{
    class MainWindow : GameWindow
    {
        string vShaderSource = null;
        string fShaderSource = null;

        bool canDraw = false;

        string infoFileName = "info.txt";

        int program;

        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);

            Title = "Point With Custom Size And Colour";
            Width = 512;
            Height = 512;

            // Load shaders from files
            ShaderLoader.LoadShader(infoFileName, "./Shaders/vShader.glsl", out vShaderSource);
            ShaderLoader.LoadShader(infoFileName, "./Shaders/fShader.glsl", out fShaderSource);
            if (vShaderSource == null || fShaderSource == null)
            {
                File.AppendAllText(infoFileName, "Failed to load shaders from files" + Environment.NewLine);
                return;
            }

            // Initialize shaders
            if (!ShaderLoader.InitShaders(vShaderSource, fShaderSource, out program))
            {
                File.AppendAllText(infoFileName, "Failed to initialize the shaders" + Environment.NewLine);
                return;
            }

            // Specify the color for clearing
            GL.ClearColor(Color.Black);

            GL.Enable(EnableCap.ProgramPointSize);

            canDraw = true;
        }

        protected override void OnRenderFrame(FrameEventArgs e)
        {
            base.OnRenderFrame(e);
            GL.Viewport(0, 0, Width, Height);

            if (!canDraw) return;

            GL.Clear(ClearBufferMask.ColorBufferBit);

            // Draw a point
            GL.DrawArrays(PrimitiveType.Points, 0, 1);

            GL.Flush();
            SwapBuffers();
        }
    }
}

 
ShaderLoader.cs
using System.IO;
using OpenTK.Graphics.OpenGL;
using System;
 
namespace PointWithCustomSizeAndColour
{
    class ShaderLoader
    {
        private static string infoFileName = null;
 
        ///<summary>
        ///Create a program object and make current
        ///</summary>
       ///<param name="vShader">a vertex shader program</param>
        ///<param name="fShader">a fragment shader program</param>
        ///<param name="program">created program</param>
        ///<returns>
        ///return true, if the program object was created and successfully made current
        ///</returns>
        public static bool InitShaders(string vShader, string fShader, out int program)
        {
            program = CreateProgram(vShader, fShader);
            if (program == 0)
            {
                File.AppendAllText(infoFileName, "Failed to create program" + Environment.NewLine);
                return false;
            }
 
            GL.UseProgram(program);
 
            return true;
        }
 
        ///<summary>
        ///Load a shader from a file
        ///</summary>
        ///<param name="infoFileName">a file name for errors</param>
        ///<param name="fileName">a file name to a shader</param>
        ///<param name="shaderSource">a shader source string</param>
        public static void LoadShader(string infoFileName, string fileName, out string shaderSource)
        {
            ShaderLoader.infoFileName = infoFileName;
 
            if (File.Exists(infoFileName))
            {
                // Clear File
                File.WriteAllText(infoFileName, "");
            }
 
            shaderSource = null;
 
            using (StreamReader sr = new StreamReader(fileName))
            {
                shaderSource = sr.ReadToEnd();
            }
        }
 
        private static int CreateProgram(string vShader, string fShader)
        {
            // Create shader object
            int vertexShader = LoadShader(ShaderType.VertexShader, vShader);
            int fragmentShader = LoadShader(ShaderType.FragmentShader, fShader);
            if (vertexShader == 0 || fragmentShader == 0)
            {
                return 0;
            }
 
            // Create a program object
            int program = GL.CreateProgram();
            if (program == 0)
            {
                return 0;
            }
 
            // Attach the shader objects
            GL.AttachShader(program, vertexShader);
            GL.AttachShader(program, fragmentShader);
 
            // Link the program object
            GL.LinkProgram(program);
 
            // Check the result of linking
            int status;
            GL.GetProgram(program, GetProgramParameterName.LinkStatus, out status);
            if (status == 0)
            {
                string errorString = string.Format("Failed to link program: {0}" + Environment.NewLine, GL.GetProgramInfoLog(program));
                File.AppendAllText(infoFileName, errorString);
                GL.DeleteProgram(program);
                GL.DeleteShader(vertexShader);
                GL.DeleteShader(fragmentShader);
                return 0;
            }
 
            return program;
        }
 
        private static int LoadShader(ShaderType shaderType, string shaderSource)
        {
            // Create shader object
            int shader = GL.CreateShader(shaderType);
            if (shader == 0)
            {
                File.AppendAllText(infoFileName, "Unable to create shader" + Environment.NewLine);
                return 0;
            }
 
            // Set the shader program
            GL.ShaderSource(shader, shaderSource);
 
            // Compile the shader
            GL.CompileShader(shader);
 
            // Check the result of compilation
            int status;
            GL.GetShader(shader, ShaderParameter.CompileStatus, out status);
            if (status == 0)
            {
                string errorString = string.Format("Failed to compile {0} shader: {1}" + Environment.NewLine, shaderType.ToString(), GL.GetShaderInfoLog(shader));
                File.AppendAllText(infoFileName, errorString);
                GL.DeleteShader(shader);
                return 0;
            }
 
            return shader;
        }
    }
}
Edited by 8Observer8

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

We are the game development community.

Whether you are an indie, hobbyist, AAA developer, or just trying to learn, GameDev.net is the place for you to learn, share, and connect with the games industry. Learn more About Us or sign up!

Sign me up!