分类： tech

tech

OpenGL 03 Data between shader stages

文章作者 jxaa121678_o5e103fh
发布日期 1月 16, 2021

Description

使用 interface block 在 shader 的不同 stage 之间传递数据

Notes

vertex fetching

在 vertex shader 运行之前的一个 fixed-function stage
它会向 vertex shader 提供输入参数
这些变量就是 vertex attributes

storage qualifiers

在 OpenGL 中，我们使用 in 和 out 关键字，在声明变量时修饰存储类型
shader 中所有用 out 声明的变量，就会被发送到下一个 stage 中用 in 声明的同样变量名的变量中

Interface Bolocks

当需要在 shader stage 间传递的变量很多的时候，我们可以用 interface block 来打组，写法和 c 的 struct 很类似

// vertex shader
out VS_OUT
{
  vec4 color;
} vs_out;

// fragment shader
in VS_OUT
{
  vec4 color;
} fs_in;

// vertex shader

out VS_OUT

{

vec4 color;

} vs_out;

// fragment shader

in VS_OUT

{

vec4 color;

} fs_in;

glVertexAttrib

void glVertexAttrib4fv(GLuint index,
                       const GLfloat *v)

1 2	void glVertexAttrib4fv(GLuint index, const GLfloat *v)

第 1 个参数 index 用于指定 attribute 的编号
第 2 个参数 v 是属性数据本身
每一次调用该函数，它都会向 OpenGL 更新 vertex attribute 数据

layout qualifier

用于在 vertex shader 中给 in 变量指定 vertex attribute 的编号

Application：glVertexAttrib4fv(0, data);
Vertex Shader：layout (location = 0 ) in vec4 offset;

这里后者的 location 就是前者的第1个参数 index

Project structure

Project Root
================
│   03_data-between-shader-stages.cpp
│   makefile
├───include
│   ├───GL
│   │       eglew.h
│   │       glew.h
│   │       glxew.h
│   │       wglew.h
│   └───GLFW
│           glfw3.h
│           glfw3native.h
├───lib
│       glew32d.dll
│       glfw3.dll
└───shaders
        03_data-between-shader-stages.frag
        03_data-between-shader-stages.vert

Project Root

================

│ 03_data-between-shader-stages.cpp

│ makefile

├───include

│ ├───GL

│ │ eglew.h

│ │ glew.h

│ │ glxew.h

│ │ wglew.h

│ └───GLFW

│ glfw3.h

│ glfw3native.h

├───lib

│ glew32d.dll

│ glfw3.dll

└───shaders

03_data-between-shader-stages.frag

03_data-between-shader-stages.vert

Codes

makefile

CC            = g++
INCFLAGS    = -I include
LDFLAGS     = -L lib -lglfw3 -lglew32d -lopengl32

all:
    $(CC) 03_data-between-shader-stages.cpp -o 03_data-between-shader-stages $(INCFLAGS) $(LDFLAGS)

clean:
    @del *.o *.exe

CC = g++

INCFLAGS = -I include

LDFLAGS = -L lib -lglfw3 -lglew32d -lopengl32

all:

$(CC) 03_data-between-shader-stages.cpp -o 03_data-between-shader-stages $(INCFLAGS) $(LDFLAGS)

clean:

@del *.o *.exe

03_data-between-shader-stages.cpp

// 03_data-between-shader-stages.cpp
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <math.h>
#include <iostream>

GLuint rendering_program;
GLuint vertex_array_object;

static const GLchar*
load_shader( const char* filename )
{
    FILE* infile = fopen( filename, "rb" );

    if(!infile) return NULL;

    fseek( infile, 0, SEEK_END );
    int size = ftell( infile );
    rewind( infile );

    GLchar* src = new GLchar[size+1];

    fread( src, sizeof(GLchar), size, infile );
    fclose( infile );

    src[size] = 0;
    return const_cast<const GLchar*>(src);
}

void display(){
    double curTime = glfwGetTime();
    const GLfloat color[] = { (float)sin(curTime)*0.5f + 0.5f,
                              (float)cos(curTime)*0.5f + 0.5f,
                              0.0f, 1.0f };
    glClearBufferfv(GL_COLOR, 0, color);
    // Use the program object we created earlier for rendering
    glUseProgram(rendering_program);
    GLfloat vattr_offset[] =
    { (float)sin(curTime) * 0.5f,
      (float)cos(curTime) * 0.5f, 0.0f, 0.0f };
    // Update the value of input attribute 0
    glVertexAttrib4fv(0, vattr_offset);

    GLfloat vattr_color[] =
    { 0.023f, 0.75f, 0.652f, 1.0f };
    glVertexAttrib4fv(1, vattr_color);

    glDrawArrays(GL_TRIANGLES, 0, 3);
}

void compile_shaders()
{
    GLuint vertex_shader;
    GLuint fragment_shader;

    // Source code for vertex shader
    static const GLchar * vertex_shader_source =
    load_shader("shaders/03_data-between-shader-stages.vert");

    // Source code for fragment shader
    static const GLchar * fragment_shader_source =
    load_shader("shaders/03_data-between-shader-stages.frag");

    // Create and compile vertex shader
    vertex_shader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertex_shader, 1, &vertex_shader_source, NULL);
    glCompileShader(vertex_shader);

    // Create and compile fragment shader
    fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragment_shader, 1, &fragment_shader_source, NULL);
    glCompileShader(fragment_shader);

    // Create program, attach shaders to it, and link it
    rendering_program = glCreateProgram();
    glAttachShader(rendering_program, vertex_shader);
    glAttachShader(rendering_program, fragment_shader);
    glLinkProgram(rendering_program);

    // Delete the shaders as the program has them now
    glDeleteShader(vertex_shader);
    glDeleteShader(fragment_shader);

    glCreateVertexArrays(1, &vertex_array_object);
    glBindVertexArray(vertex_array_object);
}

void shutdown()
{
    glDeleteVertexArrays(1, &vertex_array_object);
    glDeleteProgram(rendering_program);
    glDeleteVertexArrays(1, &vertex_array_object);
}

int main()
{
    GLFWwindow* window;
    glfwInit();
    window = glfwCreateWindow(800, 600, "Hello, World!", NULL, NULL);
    glfwMakeContextCurrent(window);

    glewInit();

    // startup
    compile_shaders();

    while (!glfwWindowShouldClose(window))
    {
        display();
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    shutdown();

    glfwTerminate();

    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

// 03_data-between-shader-stages.cpp

#include <GL/glew.h>

#include <GLFW/glfw3.h>

#include <math.h>

#include <iostream>

GLuint rendering_program;

GLuint vertex_array_object;

static const GLchar*

load_shader( const char* filename )

{

FILE* infile = fopen( filename, "rb" );

if(!infile) return NULL;

fseek( infile, 0, SEEK_END );

int size = ftell( infile );

rewind( infile );

GLchar* src = new GLchar[size+1];

fread( src, sizeof(GLchar), size, infile );

fclose( infile );

src[size] = 0;

return const_cast<const GLchar*>(src);

}

void display(){

double curTime = glfwGetTime();

const GLfloat color[] = { (float)sin(curTime)*0.5f + 0.5f,

(float)cos(curTime)*0.5f + 0.5f,

0.0f, 1.0f };

glClearBufferfv(GL_COLOR, 0, color);

// Use the program object we created earlier for rendering

glUseProgram(rendering_program);

GLfloat vattr_offset[] =

{ (float)sin(curTime) * 0.5f,

(float)cos(curTime) * 0.5f, 0.0f, 0.0f };

// Update the value of input attribute 0

glVertexAttrib4fv(0, vattr_offset);

GLfloat vattr_color[] =

{ 0.023f, 0.75f, 0.652f, 1.0f };

glVertexAttrib4fv(1, vattr_color);

glDrawArrays(GL_TRIANGLES, 0, 3);

}

void compile_shaders()

{

GLuint vertex_shader;

GLuint fragment_shader;

// Source code for vertex shader

static const GLchar * vertex_shader_source =

load_shader("shaders/03_data-between-shader-stages.vert");

// Source code for fragment shader

static const GLchar * fragment_shader_source =

load_shader("shaders/03_data-between-shader-stages.frag");

// Create and compile vertex shader

vertex_shader = glCreateShader(GL_VERTEX_SHADER);

glShaderSource(vertex_shader, 1, &vertex_shader_source, NULL);

glCompileShader(vertex_shader);

// Create and compile fragment shader

fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);

glShaderSource(fragment_shader, 1, &fragment_shader_source, NULL);

glCompileShader(fragment_shader);

// Create program, attach shaders to it, and link it

rendering_program = glCreateProgram();

glAttachShader(rendering_program, vertex_shader);

glAttachShader(rendering_program, fragment_shader);

glLinkProgram(rendering_program);

// Delete the shaders as the program has them now

glDeleteShader(vertex_shader);

glDeleteShader(fragment_shader);

glCreateVertexArrays(1, &vertex_array_object);

glBindVertexArray(vertex_array_object);

}

void shutdown()

{

glDeleteVertexArrays(1, &vertex_array_object);

glDeleteProgram(rendering_program);

glDeleteVertexArrays(1, &vertex_array_object);

}

int main()

{

GLFWwindow* window;

glfwInit();

window = glfwCreateWindow(800, 600, "Hello, World!", NULL, NULL);

glfwMakeContextCurrent(window);

glewInit();

// startup

compile_shaders();

while (!glfwWindowShouldClose(window))

{

display();

glfwSwapBuffers(window);

glfwPollEvents();

}

shutdown();

glfwTerminate();

return 0;

}

03_data-between-shader-stages.vert

// 03_data-between-shader-stages.vert
#version 450 core

// 'offset' and 'color' are input vertex attribute
layout (location = 0) in vec4 offset;
layout (location = 1) in vec4 color;

// Declare VS_OUT as an output interface block
out VS_OUT
{
    vec4 color;
} vs_out;

void main(void)
{
    // Declare a hard-coded array of positions
    const vec4 vertices[3] = vec4[3](
        vec4(0.25, -0.25, 0.5, 1.0),
        vec4(-0.25, -0.25, 0.5, 1.0),
        vec4(0.25, 0.25, 0.5, 1.0) );

    // Add 'offset' to our hard-coded vertex position
    gl_Position = vertices[gl_VertexID] + offset;

    // Output a fixed value for vs_color
    vs_out.color = color;
}

// 03_data-between-shader-stages.vert

#version 450 core

// 'offset' and 'color' are input vertex attribute

layout (location = 0) in vec4 offset;

layout (location = 1) in vec4 color;

// Declare VS_OUT as an output interface block

out VS_OUT

{

vec4 color;

} vs_out;

void main(void)

{

// Declare a hard-coded array of positions

const vec4 vertices[3] = vec4[3](

vec4(0.25, -0.25, 0.5, 1.0),

vec4(-0.25, -0.25, 0.5, 1.0),

vec4(0.25, 0.25, 0.5, 1.0) );

// Add 'offset' to our hard-coded vertex position

gl_Position = vertices[gl_VertexID] + offset;

// Output a fixed value for vs_color

vs_out.color = color;

}

03_data-between-shader-stages.frag

// 03_data-between-shader-stages.frag
#version 450 core

// Declare VS_OUT as an input interface block
in VS_OUT
{
    vec4 color; // Send color to the next stage
} fs_in;

// Output to the framebuffer
out vec4 color;

void main(void)
{
    // Simply assign the color we were given by the vertex shader to our output
    color = fs_in.color;
}

// 03_data-between-shader-stages.frag

#version 450 core

// Declare VS_OUT as an input interface block

in VS_OUT

{

vec4 color; // Send color to the next stage

} fs_in;

// Output to the framebuffer

out vec4 color;

void main(void)

{

// Simply assign the color we were given by the vertex shader to our output

color = fs_in.color;

}

tech

OpenGL 02 Shader file loading

文章作者 jxaa121678_o5e103fh
发布日期 1月 16, 2021

Description

从外部文件加载 shader，绘制 1 个 triangle

Project structure

Project Root
================
│   02_load-simple-shaders.cpp
│   makefile
├───include
│   ├───GL
│   │       eglew.h
│   │       glew.h
│   │       glxew.h
│   │       wglew.h
│   └───GLFW
│           glfw3.h
│           glfw3native.h
├───lib
│       glew32d.dll
│       glfw3.dll
└───shaders
        02_load-simple-shaders.frag
        02_load-simple-shaders.vert

Project Root

================

│ 02_load-simple-shaders.cpp

│ makefile

├───include

│ ├───GL

│ │ eglew.h

│ │ glew.h

│ │ glxew.h

│ │ wglew.h

│ └───GLFW

│ glfw3.h

│ glfw3native.h

├───lib

│ glew32d.dll

│ glfw3.dll

└───shaders

02_load-simple-shaders.frag

02_load-simple-shaders.vert

Codes

makefile

CC           = g++
INCFLAGS    = -I include
LDFLAGS     = -L lib -lglfw3 -lglew32d -lopengl32

all:
    $(CC) 02_load-simple-shaders.cpp -o 02_load-simple-shaders $(INCFLAGS) $(LDFLAGS)

clean:
    @del *.o *.exe

CC = g++

INCFLAGS = -I include

LDFLAGS = -L lib -lglfw3 -lglew32d -lopengl32

all:

$(CC) 02_load-simple-shaders.cpp -o 02_load-simple-shaders $(INCFLAGS) $(LDFLAGS)

clean:

@del *.o *.exe

02_load-simple-shaders.cpp

#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <math.h>
#include <iostream>

GLuint rendering_program;
GLuint vertex_array_object;

static const GLchar*
load_shader( const char* filename )
{
    FILE* infile = fopen( filename, "rb" );

    if(!infile) return NULL;

    fseek( infile, 0, SEEK_END );
    int size = ftell( infile );
    rewind( infile );

    GLchar* src = new GLchar[size+1];

    fread( src, sizeof(GLchar), size, infile );
    fclose( infile );

    src[size] = 0;
    return const_cast<const GLchar*>(src);
}

void display(){
    double curTime = glfwGetTime();
    const GLfloat color[] = { (float)sin(curTime)*0.5f + 0.5f,
                              (float)cos(curTime)*0.5f + 0.5f,
                              0.0f, 1.0f };
    glClearBufferfv(GL_COLOR, 0, color);
    // Use the program object we created earlier for rendering
    glUseProgram(rendering_program);
    glDrawArrays(GL_TRIANGLES, 0, 3);
}

void compile_shaders()
{
    GLuint vertex_shader;
    GLuint fragment_shader;

    // Source code for vertex shader
    static const GLchar * vertex_shader_source =
    load_shader("shaders/05_draw-triangle.vert");

    // Source code for fragment shader
    static const GLchar * fragment_shader_source =
    load_shader("shaders/05_draw-triangle.frag");

    // Create and compile vertex shader
    vertex_shader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertex_shader, 1, &vertex_shader_source, NULL);
    glCompileShader(vertex_shader);

    // Create and compile fragment shader
    fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragment_shader, 1, &fragment_shader_source, NULL);
    glCompileShader(fragment_shader);

    // Create program, attach shaders to it, and link it
    rendering_program = glCreateProgram();
    glAttachShader(rendering_program, vertex_shader);
    glAttachShader(rendering_program, fragment_shader);
    glLinkProgram(rendering_program);

    // Delete the shaders as the program has them now
    glDeleteShader(vertex_shader);
    glDeleteShader(fragment_shader);

    glCreateVertexArrays(1, &vertex_array_object);
    glBindVertexArray(vertex_array_object);
}

void shutdown()
{
    glDeleteVertexArrays(1, &vertex_array_object);
    glDeleteProgram(rendering_program);
    glDeleteVertexArrays(1, &vertex_array_object);
}

int main()
{
    GLFWwindow* window;
    glfwInit();
    window = glfwCreateWindow(800, 600, "Hello, World!", NULL, NULL);
    glfwMakeContextCurrent(window);

    glewInit();

    // startup
    compile_shaders();

    while (!glfwWindowShouldClose(window))
    {
        display();
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    shutdown();

    glfwTerminate();

    return 0;
}

100

101

102

103

104

105

106

107

108

#include <GL/glew.h>

#include <GLFW/glfw3.h>

#include <math.h>

#include <iostream>

GLuint rendering_program;

GLuint vertex_array_object;

static const GLchar*

load_shader( const char* filename )

{

FILE* infile = fopen( filename, "rb" );

if(!infile) return NULL;

fseek( infile, 0, SEEK_END );

int size = ftell( infile );

rewind( infile );

GLchar* src = new GLchar[size+1];

fread( src, sizeof(GLchar), size, infile );

fclose( infile );

src[size] = 0;

return const_cast<const GLchar*>(src);

}

void display(){

double curTime = glfwGetTime();

const GLfloat color[] = { (float)sin(curTime)*0.5f + 0.5f,

(float)cos(curTime)*0.5f + 0.5f,

0.0f, 1.0f };

glClearBufferfv(GL_COLOR, 0, color);

// Use the program object we created earlier for rendering

glUseProgram(rendering_program);

glDrawArrays(GL_TRIANGLES, 0, 3);

}

void compile_shaders()

{

GLuint vertex_shader;

GLuint fragment_shader;

// Source code for vertex shader

static const GLchar * vertex_shader_source =

load_shader("shaders/05_draw-triangle.vert");

// Source code for fragment shader

static const GLchar * fragment_shader_source =

load_shader("shaders/05_draw-triangle.frag");

// Create and compile vertex shader

vertex_shader = glCreateShader(GL_VERTEX_SHADER);

glShaderSource(vertex_shader, 1, &vertex_shader_source, NULL);

glCompileShader(vertex_shader);

// Create and compile fragment shader

fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);

glShaderSource(fragment_shader, 1, &fragment_shader_source, NULL);

glCompileShader(fragment_shader);

// Create program, attach shaders to it, and link it

rendering_program = glCreateProgram();

glAttachShader(rendering_program, vertex_shader);

glAttachShader(rendering_program, fragment_shader);

glLinkProgram(rendering_program);

// Delete the shaders as the program has them now

glDeleteShader(vertex_shader);

glDeleteShader(fragment_shader);

glCreateVertexArrays(1, &vertex_array_object);

glBindVertexArray(vertex_array_object);

}

void shutdown()

{

glDeleteVertexArrays(1, &vertex_array_object);

glDeleteProgram(rendering_program);

glDeleteVertexArrays(1, &vertex_array_object);

}

int main()

{

GLFWwindow* window;

glfwInit();

window = glfwCreateWindow(800, 600, "Hello, World!", NULL, NULL);

glfwMakeContextCurrent(window);

glewInit();

// startup

compile_shaders();

while (!glfwWindowShouldClose(window))

{

display();

glfwSwapBuffers(window);

glfwPollEvents();

}

shutdown();

glfwTerminate();

return 0;

}

02_load-simple-shaders.vert

#version 450 core

void main(void)
{
    // Declare a hard-coded array of positions
    const vec4 vertices[3] = vec4[3](
        vec4(0.25, -0.25, 0.5, 1.0),
        vec4(-0.25, -0.25, 0.5, 1.0),
        vec4(0.25, 0.25, 0.5, 1.0) );

    // Index into our array using gl_VertexID
    gl_Position = vertices[gl_VertexID];
}

#version 450 core

void main(void)

{

// Declare a hard-coded array of positions

const vec4 vertices[3] = vec4[3](

vec4(0.25, -0.25, 0.5, 1.0),

vec4(-0.25, -0.25, 0.5, 1.0),

vec4(0.25, 0.25, 0.5, 1.0) );

// Index into our array using gl_VertexID

gl_Position = vertices[gl_VertexID];

}

02_load-simple-shaders.frag

#version 450 core

out vec4 color;

void main(void)
{
    color = vec4(0.2, 0.2, 1.0, 1.0);
}

#version 450 core

out vec4 color;

void main(void)

{

color = vec4(0.2, 0.2, 1.0, 1.0);

}

tech

OpenGL 01 Basic frame

文章作者 jxaa121678_o5e103fh
发布日期 1月 16, 2021

Description

基本的 OpenGL 程序框架，包括1个 vertex shader 和 1 个 fragment shader，创建背景颜色动画，并绘制 1 个 point

Project structure

Project Root
================
│   01_basic-frame.cpp
│   makefile
├───include
│   ├───GL
│   │       eglew.h
│   │       glew.h
│   │       glxew.h
│   │       wglew.h
│   └───GLFW
│           glfw3.h
│           glfw3native.h
└───lib
        glew32d.dll
        glfw3.dll

Project Root

================

│ 01_basic-frame.cpp

│ makefile

├───include

│ ├───GL

│ │ eglew.h

│ │ glew.h

│ │ glxew.h

│ │ wglew.h

│ └───GLFW

│ glfw3.h

│ glfw3native.h

└───lib

glew32d.dll

glfw3.dll

Codes

makefile

CC           = g++
INCFLAGS    = -I include
LDFLAGS     = -L lib -lglfw3 -lglew32d -lopengl32

all:
    $(CC) 01_basic-frame.cpp -o 01_basic-frame.cpp $(INCFLAGS) $(LDFLAGS)

clean:
    @del *.o *.exe

CC = g++

INCFLAGS = -I include

LDFLAGS = -L lib -lglfw3 -lglew32d -lopengl32

all:

$(CC) 01_basic-frame.cpp -o 01_basic-frame.cpp $(INCFLAGS) $(LDFLAGS)

clean:

@del *.o *.exe

01_basic-frame.cpp

// 01_basic-frame.cpp
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <math.h>

GLuint rendering_program;
GLuint vertex_array_object;

void display(){
    double curTime = glfwGetTime();
    const GLfloat color[] = { (float)sin(curTime)*0.5f + 0.5f,
                              (float)cos(curTime)*0.5f + 0.5f,
                              0.0f, 1.0f };
    glClearBufferfv(GL_COLOR, 0, color);
    // Use the program object we created earlier for rendering
    glUseProgram(rendering_program);
    // Draw one point
    glPointSize(20.f);
    glDrawArrays(GL_POINTS, 0, 1);
}

void compile_shaders()
{
    GLuint vertex_shader;
    GLuint fragment_shader;

    // Source code for vertex shader
    static const GLchar * vertex_shader_source[] =
    {
        "#version 450 core                          \n"
        "                                           \n"
        "void main(void)                            \n"
        "{                                          \n"
        "   gl_Position = vec4(0.0, 0.0, 0.5, 1.0); \n"
        "}                                          \n"
    };

    // Source code for fragment shader
    static const GLchar * fragment_shader_source[] =
    {
        "#version 450 core                          \n"
        "                                           \n"
        "out vec4 color;                            \n"
        "                                           \n"
        "void main(void)                            \n"
        "{                                          \n"
        "   color = vec4(0.2, 0.2, 1.0, 1.0);       \n"
        "}                                          \n"
    };

    // Create and compile vertex shader
    vertex_shader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertex_shader, 1, vertex_shader_source, NULL);
    glCompileShader(vertex_shader);

    // Create and compile fragment shader
    fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragment_shader, 1, fragment_shader_source, NULL);
    glCompileShader(fragment_shader);

    // Create program, attach shaders to it, and link it
    rendering_program = glCreateProgram();
    glAttachShader(rendering_program, vertex_shader);
    glAttachShader(rendering_program, fragment_shader);
    glLinkProgram(rendering_program);

    // Delete the shaders as the program has them now
    glDeleteShader(vertex_shader);
    glDeleteShader(fragment_shader);

    glCreateVertexArrays(1, &vertex_array_object);
    glBindVertexArray(vertex_array_object);
}

void shutdown()
{
    glDeleteVertexArrays(1, &vertex_array_object);
    glDeleteProgram(rendering_program);
    glDeleteVertexArrays(1, &vertex_array_object);
}

int main()
{
    GLFWwindow* window;
    glfwInit();
    window = glfwCreateWindow(800, 600, "Hello, World!", NULL, NULL);
    glfwMakeContextCurrent(window);

    glewInit();

    // startup
    compile_shaders();

    while (!glfwWindowShouldClose(window))
    {
        display();
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    shutdown();

    glfwTerminate();

    return 0;
}

100

101

102

103

104

105

106

// 01_basic-frame.cpp

#include <GL/glew.h>

#include <GLFW/glfw3.h>

#include <math.h>

GLuint rendering_program;

GLuint vertex_array_object;

void display(){

double curTime = glfwGetTime();

const GLfloat color[] = { (float)sin(curTime)*0.5f + 0.5f,

(float)cos(curTime)*0.5f + 0.5f,

0.0f, 1.0f };

glClearBufferfv(GL_COLOR, 0, color);

// Use the program object we created earlier for rendering

glUseProgram(rendering_program);

// Draw one point

glPointSize(20.f);

glDrawArrays(GL_POINTS, 0, 1);

}

void compile_shaders()

{

GLuint vertex_shader;

GLuint fragment_shader;

// Source code for vertex shader

static const GLchar * vertex_shader_source[] =

{

"#version 450 core \n"

" \n"

"void main(void) \n"

"{ \n"

" gl_Position = vec4(0.0, 0.0, 0.5, 1.0); \n"

"} \n"

};

// Source code for fragment shader

static const GLchar * fragment_shader_source[] =

{

"#version 450 core \n"

" \n"

"out vec4 color; \n"

" \n"

"void main(void) \n"

"{ \n"

" color = vec4(0.2, 0.2, 1.0, 1.0); \n"

"} \n"

};

// Create and compile vertex shader

vertex_shader = glCreateShader(GL_VERTEX_SHADER);

glShaderSource(vertex_shader, 1, vertex_shader_source, NULL);

glCompileShader(vertex_shader);

// Create and compile fragment shader

fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);

glShaderSource(fragment_shader, 1, fragment_shader_source, NULL);

glCompileShader(fragment_shader);

// Create program, attach shaders to it, and link it

rendering_program = glCreateProgram();

glAttachShader(rendering_program, vertex_shader);

glAttachShader(rendering_program, fragment_shader);

glLinkProgram(rendering_program);

// Delete the shaders as the program has them now

glDeleteShader(vertex_shader);

glDeleteShader(fragment_shader);

glCreateVertexArrays(1, &vertex_array_object);

glBindVertexArray(vertex_array_object);

}

void shutdown()

{

glDeleteVertexArrays(1, &vertex_array_object);

glDeleteProgram(rendering_program);

glDeleteVertexArrays(1, &vertex_array_object);

}

int main()

{

GLFWwindow* window;

glfwInit();

window = glfwCreateWindow(800, 600, "Hello, World!", NULL, NULL);

glfwMakeContextCurrent(window);

glewInit();

// startup

compile_shaders();

while (!glfwWindowShouldClose(window))

{

display();

glfwSwapBuffers(window);

glfwPollEvents();

}

shutdown();

glfwTerminate();

return 0;

}

tech

OpenGL 00 Env Setup

文章作者 jxaa121678_o5e103fh
发布日期 1月 16, 2021

Description

简单搭建 & 测试下环境和 tool chain，OpenGL + GLFW + GLEW

Project structure

Project Root
================
│   main.cpp
│   makefile
├───include
│   ├───GL
│   │       eglew.h
│   │       glew.h
│   │       glxew.h
│   │       wglew.h
│   │       
│   └───GLFW
│           glfw3.h
│           glfw3native.h
│           
└───lib
        glew32d.dll
        glfw3.dll

Project Root

================

│ main.cpp

│ makefile

├───include

│ ├───GL

│ │ eglew.h

│ │ glew.h

│ │ glxew.h

│ │ wglew.h

│ │

│ └───GLFW

│ glfw3.h

│ glfw3native.h

│

└───lib

glew32d.dll

glfw3.dll

Codes

makefile

CC            = g++
INCFLAGS    = -I include
LDFLAGS     = -L lib -lglfw3 -lglew32d -lopengl32

all:
    $(CC) 00_env-setup.cpp -o 00_env-setup $(INCFLAGS) $(LDFLAGS)

clean:
    @del *.o *.exe

CC = g++

INCFLAGS = -I include

LDFLAGS = -L lib -lglfw3 -lglew32d -lopengl32

all:

$(CC) 00_env-setup.cpp -o 00_env-setup $(INCFLAGS) $(LDFLAGS)

clean:

@del *.o *.exe

00_env-setup.cpp

// 00_env-setup.cpp
#include <GL/glew.h>
#include <GLFW/glfw3.h>

void display(){
    static const GLfloat red[] = {1.0f, 0.0f, 0.0f, 1.0f};
    glClearBufferfv(GL_COLOR, 0, red);
}

int main(void)
{
    GLFWwindow* window;
    glfwInit();
    window = glfwCreateWindow(800, 600, "Hello, World!", NULL, NULL);
    glfwMakeContextCurrent(window);

    glewInit();

    while (!glfwWindowShouldClose(window))
    {
        display();
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    glfwTerminate();

    return 0;
}

// 00_env-setup.cpp

#include <GL/glew.h>

#include <GLFW/glfw3.h>

void display(){

static const GLfloat red[] = {1.0f, 0.0f, 0.0f, 1.0f};

glClearBufferfv(GL_COLOR, 0, red);

}

int main(void)

{

GLFWwindow* window;

glfwInit();

window = glfwCreateWindow(800, 600, "Hello, World!", NULL, NULL);

glfwMakeContextCurrent(window);

glewInit();

while (!glfwWindowShouldClose(window))

{

display();

glfwSwapBuffers(window);

glfwPollEvents();

}

glfwTerminate();

return 0;

}

tech

关于浮点数（2）half2float

文章作者 jxaa121678_o5e103fh
发布日期 1月 16, 2021

闲来无事（真的吗）分析一下 half2float() 的实现（好吧其实是有人问，然后看到这个函数就觉得挺有意思的）

多翻翻 GLM 果然是一个非常涨姿势的活动。。。

// https://github.com/g-truc/glm/blob/master/glm/gtc/packing.inl

GLM_FUNC_QUALIFIER glm::uint16 float2half(glm::uint32 f)
{
    // 10 bits    =>                         EE EEEFFFFF
    // 11 bits    =>                        EEE EEFFFFFF
    // Half bits  =>                   SEEEEEFF FFFFFFFF
    // Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF

    // 0x00007c00 => 00000000 00000000 01111100 00000000
    // 0x000003ff => 00000000 00000000 00000011 11111111
    // 0x38000000 => 00111000 00000000 00000000 00000000
    // 0x7f800000 => 01111111 10000000 00000000 00000000
    // 0x00008000 => 00000000 00000000 10000000 00000000
    return
        ((f >> 16) & 0x8000) | // sign
        ((((f & 0x7f800000) - 0x38000000) >> 13) & 0x7c00) | // exponential
        ((f >> 13) & 0x03ff); // Mantissa
}

GLM_FUNC_QUALIFIER glm::uint half2float(glm::uint h)
{
    return ((h & 0x8000) << 16) | ((( h & 0x7c00) + 0x1C000) << 13) | ((h & 0x03FF) << 13);
}

// https://github.com/g-truc/glm/blob/master/glm/gtc/packing.inl

GLM_FUNC_QUALIFIER glm::uint16 float2half(glm::uint32 f)

{

// 10 bits => EE EEEFFFFF

// 11 bits => EEE EEFFFFFF

// Half bits => SEEEEEFF FFFFFFFF

// Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF

// 0x00007c00 => 00000000 00000000 01111100 00000000

// 0x000003ff => 00000000 00000000 00000011 11111111

// 0x38000000 => 00111000 00000000 00000000 00000000

// 0x7f800000 => 01111111 10000000 00000000 00000000

// 0x00008000 => 00000000 00000000 10000000 00000000

return

((f >> 16) & 0x8000) | // sign

((((f & 0x7f800000) - 0x38000000) >> 13) & 0x7c00) | // exponential

((f >> 13) & 0x03ff); // Mantissa

}

GLM_FUNC_QUALIFIER glm::uint half2float(glm::uint h)

{

return ((h & 0x8000) << 16) | ((( h & 0x7c00) + 0x1C000) << 13) | ((h & 0x03FF) << 13);

}

Half 和 float 的规格

首先当然是看定义，half 和 float32 的不同位数的含义 IEEE-754 是这么规定的：

Difference Between Single-, Double-, Multi-, Mixed-Precision | NVIDIA Blog

区别就在于，指数 E 和尾数 M 所使用的位数不同

对于指数 E，half 用 5bit 表示，float 用 8bit
对于尾数 M，half 用 10bit，float 用 23bit

那么转换思路当然就是：分别对符号位 S、指数 E、尾数 M进行位移，并且注意要先给指数 E 进行合适的 offset，最后组合一下即可

0.5 as an example

首先需要用具体的例子代入，热身一下，看看 0.5 用 half 和 float 分别是怎么表示的：

首先 0.5 是十进制的表示，转换成二进制就是 0.1，再用科学计数法表示就是 1.0 * 2^(-1)

用 IEEE 754 标准来看，也就是：

符号位 s = 0，指数位 E = -1，尾数位 M = 0 （因为科学计数法第一位肯定是1，就不用表示了）

指数 E 的 offset

这里还有一点需要注意，由于指数 E 有可能为正或者为负（代表原数绝对值大于1或小于1），所以浮点数的指数表示正负数的位数各占一半，例如 half 用 5bit 表示指数，即一共可以表示 2^5 = 32 的范围（0~31），于是它采用前半部分表示负数（[0, 15]，即 00000-01111），后部分表示正数（[16, 31]，即 10000-11111）。

因此，我们计算 half 的指数位 E 的时候，需要给它加上 15 作为 offset，同理，对于 8bit 表示指数的 float，offset 为 127。

所以，对于 0.5，其指数部分 E：

用 half 表示的时候，指数为 E = -1 = -1+15 = 14 = [0 1110]

用 float 表示的时候，指数为 E = -1 = -1+127 = 126 = [0111 1110]

用 half 表示 0.5

用 float 表示 0.5

所以，当我们谈论 half2float 的时候，对 0.5 来说，实际上发生的事情就是：

函数 half2float

half2float 只有一行：

((h & 0x8000) << 16) | ((( h & 0x7c00) + 0x1C000) << 13) | ((h & 0x03FF) << 13)

1	((h & 0x8000) << 16) \| ((( h & 0x7c00) + 0x1C000) << 13) \| ((h & 0x03FF) << 13)

把它拆开来分析一下就很简单了：

step1: 取符号位左移 16 位

((half & 0x8000) << 16)

0x8000 = [1000 0000 0000 0000‬]

这是一个只有最左侧（最高位）为 1 的数，任何数和它做与运算，都只会保留最高位

half & 0x8000 得到的结果，就是最高位（最左侧）的符号位，然后 << 16 就是向左移动 16 bit

（得到的就是 0 ，因为我们的目的就是只保留符号位0）

再把结果向左移动 16 位（从 16bit 补齐为 32bit）得到

step2: 取指数部分+offset，再左移 13 位

((half & 0x7c00) + 0x1C000)

0x7c00 = [0111 1100 0000 0000]

这是一个只有第 2-6 位为 1 的数，通过和它做与运算，用 0x7c00 就可以把 half 的指数位（从左开始第 2 位到第 6 位取出来）

取出了 half 的指数部分，再来就是给它加上 127-15 = 112 的 offset

二进制表示的 112 = [0111 0000]，由于对于 half 来说，指数位是从第2-6位，也就是右侧有 10 个位数是用于表示尾数的，那么为了给 half 的指数位 + 112，也需要给它右侧补 10 个0，即

[0111 0000] => [01 1100 0000 0000 0000] => 十六进制的 0x1C000

用刚刚的结果，加上 0x1C000，就是

再把结果向左移动 13 位（补齐为 32bit）即

step3: 取尾数部分左移 13 位

(half & 0x03FF) << 13

0x03ff = [0000 0011 1111 1111]

它标记为 1 的，就是 half 里用来表示尾数 M 的最后 10 bit

再把结果向左移动 13 位（补齐为 32bit）即

step4: 最终把 3 次结果用或运算组合一下

实现了 half 2 float 的转换

tech

关于浮点数（1）EncodeFloatRGBA & DecodeFloatRGBA

文章作者 jxaa121678_o5e103fh
发布日期 1月 16, 2021

分析一下 EncodeFloatRGBA() & DecodeFloatRGBA() 的实现

翻翻 Unity Built in Shaders 是一个涨姿势的活动。。。

// from UnityCG.cginc

inline float4 EncodeFloatRGBA( float v )
{
float4 kEncodeMul = float4(1.0, 256.0, 65536.0, 16777216.0);
float kEncodeBit = 1.0/256.0;
float4 enc = kEncodeMul * v;
enc = frac (enc);
enc -= enc.yzww * kEncodeBit;
return enc;
}

inline float DecodeFloatRGBA( float4 enc )
{
float4 kDecodeDot = float4(1.0, 1/256.0, 1/65536.0, 1/16777216.0);
return dot( enc, kDecodeDot );
}

// from UnityCG.cginc

inline float4 EncodeFloatRGBA( float v )

{

float4 kEncodeMul = float4(1.0, 256.0, 65536.0, 16777216.0);

float kEncodeBit = 1.0/256.0;

float4 enc = kEncodeMul * v;

enc = frac (enc);

enc -= enc.yzww * kEncodeBit;

return enc;

}

inline float DecodeFloatRGBA( float4 enc )

{

float4 kDecodeDot = float4(1.0, 1/256.0, 1/65536.0, 1/16777216.0);

return dot( enc, kDecodeDot );

}

其中，EncodeFloatRGBA 函数将1个32bit的float数据(取值范围0~1之间)转换为float4类型。因此 EncodeFloatRGBA 相当于把一个32bit的float拆成了4份。 DecodeFloatRGBA 函数则将float4还原为float。

十进制浮点数与二进制浮点数

十进制

每位代表10的幂，因此有：

其中，每一位的范围为 0~9, 例如

二进制

每位代表2的幂，因此有：

其中，每一位的范围为 0~1, 例如

Float32 的表示规格

符号位s: 代表此Float的正负，1为负，0为正。

指数位e: 代表此Float的指数范围，8bit可表示的数值范围为0~255，由于指数有正负符号，因此国际标准IEEE 754规定，指数需要减去127，由此将0~255映射到了-127~128的范围内。

底数位m: 代表此Float的底数，也就是Float内真正存储的数值，由于科学记数法的底数形式，得出Float小数点前的第一位总是为1(在二进制中)，因此省去最高位的1不存储，例如1.00101、1.11010等等会被保存为00101、11010，因此23-bit的底数实际可以表示24-bit位的数据。

1234.5678 as an example

将十进制数 1234.5678 用 float32 来表示：

将十进制浮点数1234.5678 转换为二进制浮点数为10011010010.1001000101011

用科学计数法表示，挪动小数点得到最高位的1的右侧，并记录挪动位数

10011010010.1001000101011 = 1.00110100101001000101011 * 2¹⁰

由此，可以计算出符号位s，指数位e，底数m

符号位s = 0，(正数s=0)

指数位e = 10001001，(挪动了小数点10次，10 + 127 = 137，再转换为二进制)

底数位m = 00110100101001000101011，(省略最前面的1)

最终计算出的32-bit Float 为

0100 0100 1001 1010 0101 0010 0010 1011

EncodeFloatRGBA 分析

EncodeFloatRGBA函数输入参数为float v, 返回参数为float4 enc，其中的内部数据变化可以图解如下:

下面以 float v = 0.123456789 为例，追踪这个函数内部的数据变化

首先将v = 0.123456789转换为二进制，则v = 0.000111111001101011011101010

根据代码

float4 kEncodeMul = float4(1.0, 256.0, 65536.0, 16777216.0);
float4 enc = kEncodeMul * v;

1 2	float4 kEncodeMul = float4(1.0, 256.0, 65536.0, 16777216.0); float4 enc = kEncodeMul * v;

这个点乘的意义，从二进制的角度来看是移位，256 = 2⁸ , 65536 = 2¹⁶ , 16777216 = 2²⁴

从十进制的角度来理解，12.34 * 10¹ = 123.4，就是将小数点右移一位，指数代表移动位数

对二进制同样，1101.1011 * 2² = 110110.11，小数点右移两位，指数为负则左移小数点

因此，对v* float4(2⁰, 2⁸, 2¹⁶, 2²⁴)，意味着将v的小数点分别右移0、8、16、24位

结果为:

enc.r = 0 . 000111111001101011011101010
enc.g = 000011111 . 1001101011011101010
enc.b = 00001111110011010 . 11011101010
enc.a = 0000111111001101011011101 . 010

enc.r = 0 . 000111111001101011011101010

enc.g = 000011111 . 1001101011011101010

enc.b = 00001111110011010 . 11011101010

enc.a = 0000111111001101011011101 . 010

下一步代码

enc = frac (enc);

frac() 函数代表舍去整数部分，只保留分数

enc.r = 0. 000111111001101011011101010
enc.g = 0. 1001101011011101010 
enc.b = 0. 11011101010 
enc.a = 0. 010

enc.r = 0. 000111111001101011011101010

enc.g = 0. 1001101011011101010

enc.b = 0. 11011101010

enc.a = 0. 010

下一步代码

float kEncodeBit = 1.0/256.0;
// (为了方便解释，在这里增加一个临时变量)
float4 tmp = enc.yzww * kEncodeBit; 
enc -= tmp;

float kEncodeBit = 1.0/256.0;

// (为了方便解释，在这里增加一个临时变量)

float4 tmp = enc.yzww * kEncodeBit;

enc -= tmp;

与前面同理，1/256 = 2^-8，意味着将二进制数的小数点左移8位

tmp.r = 0. 000000001001101011011101010 // (将enc.g 的小数点左移8位得到)
tmp.g = 0. 0000000011011101010         // (将enc.b 的小数点左移8位得到)
tmp.b = 0. 00000000010                 // (将enc.a 的小数点左移8位得到)
tmp.a = 0. 00000000010                 // (将enc.a 的小数点左移8位得到)