Attachment 124383 Details for Bug 96420 – gl_PointSize = 2.0 draws 1.0 size point

gl_PointSize = 2.0 draws 1.0 size point

cpp-tutorial-4-gles3-pointcloud.cpp (text/x-c++src), 7.16 KB, created by Dongseong Hwang on 2016-06-07 08:39:48 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Dongseong Hwang

Created: 2016-06-07 08:39:48 UTC

Size: 7.16 KB

patch

obsolete

>// License: Apache 2.0. See LICENSE file in root directory.
>// Copyright(c) 2016 Intel Corporation. All Rights Reserved.
>
>//////////////////////////////////////////////////////////////////
>// librealsense tutorial #4 - OpenGL ES3 Point cloud generation //
>//////////////////////////////////////////////////////////////////
>
>// First include the librealsense C++ header file
>#include <cassert>
>#include <cmath>
>#include <memory>
>
>// Also include GLFW to allow for graphical display
>#define GLFW_INCLUDE_ES3
>#include <GLFW/glfw3.h>
>
>#define SHADER(x) #x
>
>namespace examples
>{
>    class point_cloud
>    {
>    public:
>        point_cloud() {}
>        ~point_cloud()
>        {
>            glDeleteProgram(program_);
>        }
>        point_cloud(const point_cloud &) = delete;
>        void operator=(const point_cloud &) = delete;
>
>        bool initialize()
>        {
>            // Open a GLFW window to display our output
>            glfwInit();
>            win_ = glfwCreateWindow(display_size_.width, display_size_.height,
>                "librealsense tutorial #4", nullptr, nullptr);
>            glfwSetCursorPosCallback(win_, on_cursor_pos);
>            glfwSetMouseButtonCallback(win_, on_mouse_button);
>            glfwMakeContextCurrent(win_);
>
>            // Need to do the first mode setting before page flip.
>            if(!initialize_gl()) return false;
>            return true;
>        }
>
>        void run()
>        {
>            while(!glfwWindowShouldClose(win_))
>            {
>                // Wait for new frame data
>                glfwPollEvents();
>                draw();
>                glfwSwapBuffers(win_);
>            }
>        }
>
>    private:
>        bool initialize_gl()
>        {
>            if(!initialize_gl_program()) return false;
>
>            glViewport(0, 0, display_size_.width, display_size_.height);
>            glClearColor(0.0, 0.0, 0.0, 1.0);
>            glClear(GL_COLOR_BUFFER_BIT);
>
>            GLenum error = glGetError();
>            if(error == GL_NO_ERROR) return true;
>
>            printf("Fail to initialize GL resources. code:%x \n", error);
>            return false;
>        }
>
>        bool initialize_gl_program()
>        {
>            // clang-format off
>            static const char* vertex_shader_source =
>              "#version 300 es\n"
>              SHADER(
>                  uniform vec2 u_rect_size;
>                  out vec2 v_color;
>                  void main()
>                  {
>                      vec2 rect_pixel;
>                      // generate lattice pos; (0, 0) (1, 0) (2, 0) ... (w-1, h-1)
>                      rect_pixel.x = mod(float(gl_VertexID), u_rect_size.x);
>                      rect_pixel.y = floor(float(gl_VertexID) / u_rect_size.y);
>
>                      // map [0, w) to [-1, 1]
>                      vec2 pos = (2.0 * rect_pixel / u_rect_size) - 1.0;
>                      // map [-1, 1] to [-0.5, 0.5]
>                      pos = pos * 0.5;
>
>                      v_color.x = pos.y + 0.5;
>                      v_color.y = 0.0;
>                      if (pos.y > 0.5) {
>                          v_color = vec2(0.0, 1.0);
>                      }
>                      gl_Position = vec4(pos * 2.0, 1.0, 1.0);
>                      gl_PointSize = 2.0;
>                  }
>              );
>
>            static const char* fragment_shader_source =
>              "#version 300 es\n"
>              SHADER(
>                  precision highp float;
>                  in vec2 v_color;
>                  layout(location = 0) out vec4 fragColor;
>                  void main()
>                  {
>                      fragColor = vec4(v_color, 0.0, 1.0);
>                  }
>              );
>            // clang-format on
>
>            GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER);
>
>            glShaderSource(vertex_shader, 1, &vertex_shader_source, NULL);
>            glCompileShader(vertex_shader);
>
>            GLint ret = 0;
>            glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &ret);
>            if(!ret)
>            {
>                printf("vertex shader compilation failed!:\n");
>                glGetShaderiv(vertex_shader, GL_INFO_LOG_LENGTH, &ret);
>                if(ret > 1)
>                {
>                    char * log = static_cast<char *>(malloc(ret));
>                    glGetShaderInfoLog(vertex_shader, ret, NULL, log);
>                    printf("%s\n", log);
>                    free(log);
>                }
>                return false;
>            }
>
>            GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
>
>            glShaderSource(fragment_shader, 1, &fragment_shader_source, NULL);
>            glCompileShader(fragment_shader);
>
>            glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &ret);
>            if(!ret)
>            {
>                printf("fragment shader compilation failed!:\n");
>                glGetShaderiv(fragment_shader, GL_INFO_LOG_LENGTH, &ret);
>                if(ret > 1)
>                {
>                    char * log = static_cast<char *>(malloc(ret));
>                    glGetShaderInfoLog(fragment_shader, ret, NULL, log);
>                    printf("%s\n", log);
>                    free(log);
>                }
>                return false;
>            }
>
>            program_ = glCreateProgram();
>
>            glAttachShader(program_, vertex_shader);
>            glAttachShader(program_, fragment_shader);
>
>            glBindAttribLocation(program_, 0, "in_position");
>
>            glLinkProgram(program_);
>
>            glGetProgramiv(program_, GL_LINK_STATUS, &ret);
>            if(!ret)
>            {
>                printf("program linking failed!:\n");
>                glGetProgramiv(program_, GL_INFO_LOG_LENGTH, &ret);
>                if(ret > 1)
>                {
>                    char * log = static_cast<char *>(malloc(ret));
>                    glGetProgramInfoLog(program_, ret, NULL, log);
>                    printf("%s\n", log);
>                    free(log);
>                }
>                return false;
>            }
>
>            glDeleteShader(vertex_shader);
>            glDeleteShader(fragment_shader);
>            glUseProgram(program_);
>
>            GLint u_rect_size = glGetUniformLocation(program_, "u_rect_size");
>            glUniform2f(u_rect_size, (float)points_rect_size_.width, (float)points_rect_size_.height);
>
>            return true;
>        }
>
>        static void on_mouse_button(GLFWwindow * win, int button, int action, int mods)
>        {
>        }
>        static void on_cursor_pos(GLFWwindow * win, double x, double y)
>        {
>        }
>
>        void draw()
>        {
>            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
>            glDrawArrays(GL_POINTS, 0, points_rect_size_.width * points_rect_size_.height);
>        }
>
>        GLFWwindow * win_ = nullptr;
>        struct size
>        {
>            int width;
>            int height;
>        };
>        size display_size_ = {1280, 960};
>        size points_rect_size_ = {640, 480};
>        GLuint program_ = 0;
>    };
>
>} // namespace examples
>
>int main()
>{
>    std::unique_ptr<examples::point_cloud> point_cloud(new examples::point_cloud());
>    if(!point_cloud->initialize())
>    {
>        fprintf(stderr, "failed to initialize point_cloud.\n");
>        return -1;
>    }
>
>    point_cloud->run();
>
>    return EXIT_SUCCESS;
>}

Actions: View

Attachments on bug 96420: 124383 | 124399 | 124400 | 124401

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.