Posted on | In , ,

Instance

Extensions

1
2
3
4
5
6
7
uint32_t extensions_count = 0;
vkEnumerateInstanceExtensionProperties( nullptr,
&extensions_count, nullptr ).
std::vector<VkExtensionProperties> available_extensions(extensions_count);
vkEnumerateInstanceExtensionProperties( nullptr,
&extensions_count, &available_extensions[0]).
//check extensions

创建

1
2
3
4
5
6
VkApplicationInfo
VkInstanceCreateInfo
vkCreateInstance(
const VkInstanceCreateInfo*  pCreateInfo,
const VkAllocationCallbacks* pAllocator,//important，产品级都要使用内存管理器
VkInstance*                  pInstance);

重要属性 TODO

销毁

Posted on | In , ,

Lighting

说明

内容

  • Rendering a geometry with a vertex diffuse lighting
  • Rendering a geometry with a fragment specular lighting
  • Rendering a normal mapped geometry
  • Drawing a reflective and refractive geometry using cubemaps
  • Adding shadows to the scene

介绍

…

Rendering a geometry with a vertex diffuse lighting

vertex

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#version 450
layout( location = 0 ) in vec4 app_position;
layout( location = 1 ) in vec3 app_normal;
layout( set = 0, binding = 0 ) uniform UniformBuffer {
    mat4 ModelViewMatrix;
    mat4 ProjectionMatrix;
};
layout( location = 0 ) out float vert_color;
void main() {
    gl_Position = ProjectionMatrix * ModelViewMatrix *
        app_position;
    vec3 normal = mat3( ModelViewMatrix ) * app_normal;
    vert_color = max( 0.0, dot( normal, vec3( 0.58, 0.58, 0.58 ) )
                    ) + 0.1;
}

fragment

1
2
3
4
5
6
#version 450
layout( location = 0 ) in float vert_color;
layout( location = 0 ) out vec4 frag_color;
void main() {
    frag_color = vec4( vert_color );
}

…

Rendering a geometry with a fragment specular lighting

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#version 450
layout( location = 0 ) in vec3 vert_position;
layout( location = 1 ) in vec3 vert_normal;
layout( push_constant ) uniform LightParameters {
    vec4 Position;
} Light;
layout( location = 0 ) out vec4 frag_color;
void main() {
    vec3 normal_vector = normalize( vert_normal );
    vec3 light_vector = normalize( Light.Position.xyz -
                                  vert_position );
    float diffuse_term = max( 0.0, dot( normal_vector, light_vector
                                      ) );
    frag_color = vec4( diffuse_term + 0.1 );
    if( diffuse_term > 0.0 ) {
        vec3 view_vector = normalize( vec3( 0.0, 0.0, 0.0 ) -
                                     vert_position.xyz );
        vec3 half_vector = normalize( view_vector + light_vector );
        float shinniness = 60.0;
        float specular_term = pow( dot( half_vector, normal_vector ),
                                  shinniness );
        frag_color += vec4( specular_term );
    }
}

normal mapeed geometry

vertex

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#version 450
layout( location = 0 ) in vec4 app_position;
layout( location = 1 ) in vec3 app_normal;
layout( location = 2 ) in vec2 app_texcoord;
layout( location = 3 ) in vec3 app_tangent;
layout( location = 4 ) in vec3 app_bitangent;
layout( set = 0, binding = 0 ) uniform UniformBuffer {
    mat4 ModelViewMatrix;
    mat4 ProjectionMatrix;
};
layout( location = 0 ) out vec3 vert_position;
layout( location = 1 ) out vec2 vert_texcoord;
layout( location = 2 ) out vec3 vert_normal;
layout( location = 3 ) out vec3 vert_tanget;
layout( location = 4 ) out vec3 vert_bitanget;
void main() {
    vec4 position = ModelViewMatrix * app_position;
    gl_Position = ProjectionMatrix * position;
    vert_position = position.xyz;
    vert_texcoord = app_texcoord;
    vert_normal = mat3( ModelViewMatrix ) * app_normal;
    vert_tanget = mat3( ModelViewMatrix ) * app_tangent;
    vert_bitanget = mat3( ModelViewMatrix ) * app_bitangent;
}

fragment

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#version 450
layout( location = 0 ) in vec3 vert_position;
layout( location = 1 ) in vec2 vert_texcoord;
layout( location = 2 ) in vec3 vert_normal;
layout( location = 3 ) in vec3 vert_tanget;
layout( location = 4 ) in vec3 vert_bitanget;
layout( set = 0, binding = 1 ) uniform sampler2D ImageSampler;
layout( push_constant ) uniform LightParameters {
    vec4 Position;
} Light;
layout( location = 0 ) out vec4 frag_color;
void main() {
    vec3 normal = 2 * texture( ImageSampler, vert_texcoord ).rgb -
        1.0;
    vec3 normal_vector = normalize( mat3( vert_tanget,
                                         vert_bitanget, vert_normal) * normal );
    vec3 light_vector = normalize( Light.Position.xyz -
                                  vert_position );
    float diffuse_term = max( 0.0, dot( normal_vector, light_vector
                                      ) ) * max( 0.0, dot( vert_normal, light_vector ) );
    frag_color = vec4( diffuse_term + 0.1 );
    if( diffuse_term > 0.0 ) {
        vec3 half_vector = normalize(normalize( -vert_position.xyz )
                                     + light_vector);
        float specular_term = pow( dot( half_vector, normal_vector ),
                                  60.0 );
        frag_color += vec4( specular_term );
    }
}

Drawing a reflective and refractive geometry using cubemaps

order:+X,-X,+Y,-Y,+Z,-Z

vertex

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#version 450
layout( location = 0 ) in vec4 app_position;
layout( location = 1 ) in vec3 app_normal;
layout( set = 0, binding = 0 ) uniform UniformBuffer {
    mat4 ModelViewMatrix;
    mat4 ProjectionMatrix;
};
layout( location = 0 ) out vec3 vert_position;
layout( location = 1 ) out vec3 vert_normal;
void main() {
    vert_position = app_position.xyz;
    vert_normal = app_normal;
    gl_Position = ProjectionMatrix * ModelViewMatrix *
        app_position;
}

fragment

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#version 450
layout( location = 0 ) in vec3 vert_position;
layout( location = 1 ) in vec3 vert_normal;
layout( set = 0, binding = 1 ) uniform samplerCube Cubemap;
layout( push_constant ) uniform LightParameters {
    vec4 Position;
} Camera;
layout( location = 0 ) out vec4 frag_color;
void main() {
    vec3 view_vector = vert_position - Camera.Position.xyz;
    float angle = smoothstep( 0.3, 0.7, dot( normalize( -
                                                       view_vector ), vert_normal ) );
    vec3 reflect_vector = reflect( view_vector, vert_normal );
    vec4 reflect_color = texture( Cubemap, reflect_vector );
    vec3 refrac_vector = refract( view_vector, vert_normal, 0.3 );
    vec4 refract_color = texture( Cubemap, refrac_vector );
    frag_color = mix( reflect_color, refract_color, angle );
}

add shadow to the scene

Posted on | In , ,

Advanced Rendering Techniques

[TOC]

说明

内容

  • Drawing a skybox
  • Drawing billboards using geometry shaders
  • Drawing particles using compute and graphics pipelines
  • Rendering a tessellated terrain
  • Rendering a full-screen quad for post-processing
  • Using input attachments for a color correction post-process effect

介绍

order:right,left,up,down,backward,forward

vertex

1
2
3
4
5
6
7
8
9
10
11
12
#version 450
layout( location = 0 ) in vec4 app_position;
layout( set = 0, binding = 0 ) uniform UniformBuffer {
    mat4 ModelViewMatrix;
    mat4 ProjectionMatrix;
};
layout( location = 0 ) out vec3 vert_texcoord;
void main() {
    vec3 position = mat3(ModelViewMatrix) * app_position.xyz;
    gl_Position = (ProjectionMatrix * vec4( position, 0.0 )).xyzz;
    vert_texcoord = app_position.xyz;
}

fragment

1
2
3
4
5
6
7
#version 450
layout( location = 0 ) in vec3 vert_texcoord;
layout( set = 0, binding = 1 ) uniform samplerCube Cubemap;
layout( location = 0 ) out vec4 frag_color;
void main() {
    frag_color = texture( Cubemap, vert_texcoord );
}

Drawing billboards using geometry shaders

geometry shader

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#version 450
layout( points ) in;
layout( set = 0, binding = 0 ) uniform UniformBuffer {
    mat4 ModelViewMatrix;
    mat4 ProjectionMatrix;
};
layout( triangle_strip, max_vertices = 4 ) out;
layout( location = 0 ) out vec2 geom_texcoord;
const float SIZE = 0.1;
void main() {
    vec4 position = gl_in[0].gl_Position;
    gl_Position = ProjectionMatrix * (gl_in[0].gl_Position + vec4(
        -SIZE, SIZE, 0.0, 0.0 ));
    geom_texcoord = vec2( -1.0, 1.0 );
    EmitVertex();
    gl_Position = ProjectionMatrix * (gl_in[0].gl_Position + vec4(
        -SIZE, -SIZE, 0.0, 0.0 ));
    geom_texcoord = vec2( -1.0, -1.0 );
    EmitVertex();
    gl_Position = ProjectionMatrix * (gl_in[0].gl_Position + vec4(
        SIZE, SIZE, 0.0, 0.0 ));
    geom_texcoord = vec2( 1.0, 1.0 );
    EmitVertex();
    gl_Position = ProjectionMatrix * (gl_in[0].gl_Position + vec4(
        SIZE, -SIZE, 0.0, 0.0 ));
    geom_texcoord = vec2( 1.0, -1.0 );
    EmitVertex();
    EndPrimitive();
}

Drawing particles using compute and graphics pipelines

…

Rendering a tessellated terrain

vertex

1
2
3
4
5
6
7
8
#version 450
layout( location = 0 ) in vec4 app_position;
layout( location = 1 ) in vec2 app_texcoord;
layout( location = 0 ) out vec2 vert_texcoord;
void main() {
    gl_Position = app_position;
    vert_texcoord = app_texcoord;
}

tessellation control

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#version 450
layout( location = 0 ) in vec2 vert_texcoord[];
layout( set = 0, binding = 0 ) uniform UniformBuffer {
    mat4 ModelViewMatrix;
    mat4 ProjectionMatrix;
};
layout( set = 0, binding = 1 ) uniform sampler2D ImageSampler;
layout( vertices = 3 ) out;
layout( location = 0 ) out vec2 tesc_texcoord[];
void main() {
    if( 0 == gl_InvocationID ) {
        float distances[3];
        float factors[3];
        for( int i = 0; i < 3; ++i ) {
            float height = texture( ImageSampler, vert_texcoord[i]
                                  ).x;
            vec4 position = ModelViewMatrix * (gl_in[i].gl_Position +
                                               vec4( 0.0, height, 0.0, 0.0 ));
            distances[i] = dot( position, position );
        }
        factors[0] = min( distances[1], distances[2] );
        factors[1] = min( distances[2], distances[0] );
        factors[2] = min( distances[0], distances[1] );
        gl_TessLevelInner[0] = max( 1.0, 20.0 - factors[0] );
        gl_TessLevelOuter[0] = max( 1.0, 20.0 - factors[0] );
        gl_TessLevelOuter[1] = max( 1.0, 20.0 - factors[1] );
        gl_TessLevelOuter[2] = max( 1.0, 20.0 - factors[2] );
    }
    gl_out[gl_InvocationID].gl_Position =
        gl_in[gl_InvocationID].gl_Position;
    tesc_texcoord[gl_InvocationID] =
        vert_texcoord[gl_InvocationID];
}

tessellation evaluation shader

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#version 450
layout( triangles, fractional_even_spacing, cw ) in;
layout( location = 0 ) in vec2 tesc_texcoord[];
layout( set = 0, binding = 1 ) uniform sampler2D HeightMap;
layout( location = 0 ) out float tese_height;
void main() {
    vec4 position = gl_in[0].gl_Position * gl_TessCoord.x +
        gl_in[1].gl_Position * gl_TessCoord.y +
        gl_in[2].gl_Position * gl_TessCoord.z;
    vec2 texcoord = tesc_texcoord[0] * gl_TessCoord.x +
        tesc_texcoord[1] * gl_TessCoord.y +
        tesc_texcoord[2] * gl_TessCoord.z;
    float height = texture( HeightMap, texcoord ).x;
    position.y += height;
    gl_Position = position;
    tese_height = height;
}

geometry shader

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#version 450
layout( triangles ) in;
layout( location = 0 ) in float tese_height[];
layout( set = 0, binding = 0 ) uniform UniformBuffer {
    mat4 ModelViewMatrix;
    mat4 ProjectionMatrix;
};
layout( triangle_strip, max_vertices = 3 ) out;
layout( location = 0 ) out vec3 geom_normal;
layout( location = 1 ) out float geom_height;
void main() {
    vec3 v0v1 = gl_in[1].gl_Position.xyz -
        gl_in[0].gl_Position.xyz;
    vec3 v0v2 = gl_in[2].gl_Position.xyz -
        gl_in[0].gl_Position.xyz;
    vec3 normal = normalize( cross( v0v1, v0v2 ) );
    for( int vertex = 0; vertex < 3; ++vertex ) {
        gl_Position = ProjectionMatrix * ModelViewMatrix *
            gl_in[vertex].gl_Position;
        geom_height = tese_height[vertex];
        geom_normal = normal;
        EmitVertex();
    }
    EndPrimitive();
}

fragment

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#version 450
layout( location = 0 ) in vec3 geom_normal;
layout( location = 1 ) in float geom_height;
layout( location = 0 ) out vec4 frag_color;
void main() {
    const vec4 green = vec4( 0.2, 0.5, 0.1, 1.0 );
    const vec4 brown = vec4( 0.6, 0.5, 0.3, 1.0 );
    const vec4 white = vec4( 1.0 );
    vec4 color = mix( green, brown, smoothstep( 0.0, 0.4,
                                               geom_height ) );
    color = mix( color, white, smoothstep( 0.6, 0.9, geom_height )
               );
    float diffuse_light = max( 0.0, dot( geom_normal, vec3( 0.58,
                                                           0.58, 0.58 ) ) );
    frag_color = vec4( 0.05, 0.05, 0.0, 0.0 ) + diffuse_light *
        color;
}

full screen

input attachments for color correction post-process effect

Posted on | In , ,

10.Helper Recipes

[TOC]

介绍

内容

Preparing a translation matrix
Preparing a rotation matrix
Preparing a scaling matrix
Preparing a perspective projection matrix
Preparing an orthographic projection matrix
Loading texture data from a file
Loading a 3D model from an OBJ file

介绍

matrix

translation matrix

关于vulkan 坐标系x (lef/rightt), y (down/up), and z (near/far).右手坐标系

关于矩阵

1
2
3
4
5
6
7
std::array<float, 16> translation_matrix = {
    1.0f, 0.0f, 0.0f, 0.0f,
    0.0f, 1.0f, 0.0f, 0.0f,
    0.0f, 0.0f, 1.0f, 0.0f,
    x, y, z, 1.0f
};
return translation_matrix;

All elements initialize with a 0.0f value
0th, 5th, 10th, and 15th elements (main diagonal) with a 1.0f value
12th element with a value stored in the x variable
13th element with a value stored in the y variable
14th element with a value stored in the z variable

也就是列主序

rotation matrix

0th element with a x x (1.0f - c) + c
1st element with a y x (1.0f - c) - z s
2nd element with a z x (1.0f - c) + y s
4th element with a x y (1.0f - c) + z s
5th element with a y y (1.0f - c) + c
6th element with a z y (1.0f - c) - x s
8th element with a x z (1.0f - c) - y s
9th element with a y z (1.0f - c) + x s
10th element with a z z (1.0f - c) + c
The rest of the elements initialize with a 0.0f value
Except for the 15th element, which should contain a 1.0f value

Each column of such matrix defines the directions of x, y, and z axes respectively after the rotation is performed.

一个例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
if( normalize ) {
    std::array<float, 3> normalized = Normalize( x, y, z );
    x = normalized[0];
    y = normalized[1];
    z = normalized[2];
}
const float c = cos( Deg2Rad( angle ) );
const float _1_c = 1.0f - c;
const float s = sin( Deg2Rad( angle ) );
std::array<float, 16> rotation_matrix = {
    x * x * _1_c + c,
    y * x * _1_c - z * s,
    z * x * _1_c + y * s,
    0.0f,
    x * y * _1_c + z * s,
    y * y * _1_c + c,
    z * y * _1_c - x * s,
    0.0f,
    x * z * _1_c - y * s,
    y * z * _1_c + x * s,
    z * z * _1_c + c,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    1.0f
};
return rotation_matrix;

Preparing a scaling matrix

  • All elements initialize with a 0.0f value
  • 0th element with a value stored in the x variable
  • 5th element with a value stored in the y variable
  • 10th element with a value stored in the z variable
  • 15th element with a 1.0f value

..

1
2
3
4
5
6
7
std::array<float, 16> scaling_matrix = {
    x, 0.0f, 0.0f, 0.0f,
    0.0f, y, 0.0f, 0.0f,
    0.0f, 0.0f, z, 0.0f,
    0.0f, 0.0f, 0.0f, 1.0f
};
return scaling_matrix;

Preparing a perspective projection matrix

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
float aspect_ratio;//width/height
float field_of_view;//Initialize it with an angle (in radians) of a vertical field of view of a camera
float near_plane;
float far_plane;
float f = (1.0f / tan(Deg2Rad(0.5f * field_of_view)));
Matrix4x4 perspective_projection_matrix = {
    f / aspect_ratio,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    -f,
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    far_plane / (near_plane - far_plane),
    -1.0f,
    0.0f,
    0.0f,
    (near_plane * far_plane) / (near_plane - far_plane),
    0.0f
};
return perspective_projection_matrix;
  • 0th element with a f / aspect_ratio
  • 5th element with a -f
  • 10th element with a far_plane / (near_plane - far_plane)
  • 11th element with a -1.0f value
  • 14th element with a (near_plane * far_plane) / (near_plane -
    far_plane)
  • The rest of the elements initialize with a 0.0f value

Preparing an orthographic projection matrix

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Matrix4x4 orthographic_projection_matrix = {
    2.0f / (right_plane - left_plane),
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    2.0f / (bottom_plane - top_plane),
    0.0f,
    0.0f,
    0.0f,
    0.0f,
    1.0f / (near_plane - far_plane),
    0.0f,
    -(right_plane + left_plane) / (right_plane - left_plane),
    -(bottom_plane + top_plane) / (bottom_plane - top_plane),
    near_plane / (near_plane - far_plane),
    1.0f
};
return orthographic_projection_matrix;

Loading texture data

stb

1
2
3
4
5
6
7
8
9
10
11
12
13
int width = 0;
int height = 0;
int num_components = 0;
std::unique_ptr<unsigned char, void(*)(void*)> stbi_data( stbi_load(
    filename, &width, &height, &num_components, num_requested_components ),
                                                         stbi_image_free );
if( (!stbi_data) ||
   (0 >= width) ||
   (0 >= height) ||
   (0 >= num_components) ) {
    std::cout << "Could not read image!" << std::endl;
    return false;
}
1
2
3
4
5
6
std::vector<unsigned char> image_data;
int data_size = width * height * (0 < num_requested_components ?
                                  num_requested_components : num_components);
image_data.resize( data_size );
std::memcpy( image_data.data(), stbi_data.get(), data_size );
return true;

3D model obj file

https://github.com/syoyo/tinyobjloader.

1
2
3
4
5
6
7
8
9
10
11
12
13
#include ...
#define TINYOBJLOADER_IMPLEMENTATION
#include "tiny_obj_loader.h"


struct Mesh {
    std::vector<float> Data;
    struct Part {
        uint32_t VertexOffset;
        uint32_t VertexCount;
    };
    std::vector<Part> Parts;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
tinyobj::attrib_t attribs;
std::vectortinyobj::shape_t shapes;
std::vectortinyobj::material_t materials;
std::string error;
bool result = tinyobj::LoadObj( &attribs, &shapes, &materials, &error,
                               filename.c_str() );
if( !result ) {
    std::cout << "Could not open '" << filename << "' file.";
    if( 0 < error.size() ) {
        std::cout << " " << error;
    }
    std::cout << std::endl;
    return false;
}



Mesh mesh = {};
uint32_t offset = 0;
for( auto & shape : shapes ) {
    uint32_t part_offset = offset;
    for( auto & index : shape.mesh.indices ) {
        mesh.Data.emplace_back( attribs.vertices[3 * index.vertex_index + 0] );
        mesh.Data.emplace_back( attribs.vertices[3 * index.vertex_index + 1] );
        mesh.Data.emplace_back( attribs.vertices[3 * index.vertex_index + 2] );
        ++offset;
        if( (load_normals) &&
           (attribs.normals.size() > 0) ) {
            mesh.Data.emplace_back( attribs.normals[3index.normal_index+0]);
            mesh.Data.emplace_back( attribs.normals[3index.normal_index+1]);
            mesh.Data.emplace_back( attribs.normals[3*index.normal_index+2]);

        }
        if( (load_texcoords) &&
           (attribs.texcoords.size() > 0)) {
            mesh.Data.emplace_back( attribs.texcoords[2 * index.texcoord_index +
                                                      0] );
            mesh.Data.emplace_back( attribs.texcoords[2 * index.texcoord_index +
                                                      1] );
        }
    }
    uint32_t part_vertex_count = offset - part_offset;
    if( 0 < part_vertex_count ) {
        mesh.Parts.push_back( { part_offset, part_vertex_count } );
    }
}

Posted on | In , ,

validation layers

由https://github.com/LunarG提供

https://github.com/KhronosGroup/Vulkan-ValidationLayers

概念

​ Vulkan API设计时时刻考虑着性能.其中一个提升其性能的方式是减少驱动的状态和错误检查.这是Vulkan被称为”thin API”或”thin driver”，因为它硬件的最小抽象–这在多个硬件上跨平台是必须的(高性能的PC,移动手机,低性能的嵌入式设备等).

​ 这导致变现Vulkan API的app更困难.为了解决这个问题,Vulkan也被设计为一个分层的API,最底层和核心的曾是Vulkan API自己–与驱动交互.它的上策(app与Vulkan API之间),开发者可以激活额外的layers,简化debugging流程.

如何做

windows

  • 找到Vulkan SDK安装目录,找到./Config文件夹

  • 将其内的vk_layer_settings.txt拷贝执行程序所在文件夹内

  • 创建环境变量 VK_INSTANCE_LAYERS:

    打开控制台(cmd.exe),输入一下内容:

    setx VK_INSTANCE_LAYERS

    VK_LAYER_LUNARG_standard_validation

  • 重新打开控制台

  • 使用控制台执行要测试的程序,warnings或errors会显示到控制台里

linux类似

  • 同上

  • 同上

  • 输入命令变为

    export

    VK_INSTANCE_LAYERS=VK_LAYER_LUNARG_standard_validation

  • 同上

如何工作的

Vulkan validation layers包含了一组创建app时辅助找到潜在问题的库.他们的调试策略包括但不限于：参数检测,确认texture和RT的formats,追踪Vulkan objects的生命周期和使用,检查Vulkan API函数调用的潜在的内存泄漏和奔溃.这些功能通过激活不同的validation layers来启动,但其中大多数被集中到了一个叫VK_LAYER_LUNARG_standard_validation的层.其他layers包括:VK_LAYER_LUNARG_swapchain,VK_LAYER_LUNARG_object_tracker,VK_LAYER_GOOGLE_threading,VK_LAYER_LUNARG_api_dump等.多个layers可以同时激活,如果是windows这样做:

1
2
setx VK_INSTANCE_LAYERS
VK_LAYER_LUNARG_api_dump;VK_LAYER_LUNARG_core_validation

如果是linux:

1
export VK_INSTANCE_LAYERS=VK_LAYER_LUNARG_api_dump:VK_LAYER_LUNARG_core_validation

但是上述的方法都是全局的,事实上,实际编程时,我们根据是否时DEBUG模式动态决定是否使用Vulkan validation layers.

实际编程的做法

通过标准宏NDEBUG决定是否启用某些validation layers

通过vkEnumerateInstanceLayerProperties获得支持的validation layers

将支持且需要启用的validation layer绑定到VkInstanceCreateInfo

调用vkCreateInstance时启用

定义调试回调函数,PFN_vkDebugReportCallbackEXT

填充结构VkDebugReportCallbackCreateInfoEXT

调用vkCreateDebugReportCallbackEXT(扩展函数,需要使用vkGetInstanceprocAddr获得)创建

注意需要在清理Instance前调用vkDestroyDebugReportCallbackEXT清理callback

参考https://blog.csdn.net/lbknxy/article/details/52430599

其他调试技巧

RenderDoc

Posted on | In , ,

说明

在创建了Vulkan Instance 对象后，下一步就是枚举physical devices,选择其中一个,并根据它创建又给logical device,这些操作通过instance-level级函数进行执行.

Vulkan里几乎所有工作都是在logical device上执行的：在其上创建资源，管理他们的内存，记录由它们创建的command buffers,向他们的queues提交处理commands.

physical device

枚举所有可以使用的physical devices

1
2
3
4
5
6
uint32_t devices_count = 0;
vkEnumeratePhysicalDevices( instance, &devices_count,
nullptr ).
std::vector<VkPhysicalDevice> available_devices(devices_count);
vkEnumeratePhysicalDevices( instance, &devices_count,
&available_devices[0]).

extensions

1
2
3
4
uint32_t extensions_count = 0;
vkEnumerateDeviceExtensionProperties(physical_device,nullptr,&extensions_count,nullptr);
std::vector<VkExtensionProperties> available_extensions(extensions_count);
vkEnumerateDeviceExtensionProperties(physical_device,nullptr,&extensions_count,&available_extensions[0]);

获取pyhsical device的features和properties

1
2
3
4
5
vkEnumeratePhysicalDevices()
VkPhysicalDeviceFeatures device_features;//支持的特性,支持的shader类型(是否支持geometry,tessellation),depth clamp 和 bias,multiple viewports,或者wide lines.
VkPhysicalDeviceProperties device_properties;//物理设备的属性,名字,驱动版本,api支持版本,设备类型(可能是CPU),limits(texture大小,buffer数量)
vkGetPhysicalDeviceFeatures(physical_device, &device_features);
vkGetPhysicalDeviceProperties(physical_device,&device_properties);

logic device

检查可用的queue families和他们的properties

在vulkan里,对硬件的所有操作都是通过提交到queues里进行的.提交到同一个queue里的命令是一个接着一个执行的,提交到不同queue里的命令是独立的(需要同步他们)

不同的queues可能表示硬件的不同部分,因此会支持不同的操作,并非所有操作都可以在所有queue上执行.

有相同策略的queue被聚合在同样的family里,一个device可能暴露任意数量的queue families，每一个family可能包括一个或多个queues.要想检查硬件能执行什么操作,需要便利所有queue families的属性.

步骤

1
2
3
4
5
6
uint32_t queue_families_count = 0;
vkGetPhysicalDeviceQueueFamilyProperties( physical_device,
&queue_families_count, nullptr ).
std::vector<VkQueueFamilyProperties> queue_families(queue_families_count);
vkGetPhysicalDeviceQueueFamilyProperties(physical_device,
&queue_families_count, &queue_families[0]);

从properties中能获取到的最重要的信息是能在已给family的queues里进行的操作类型,操作类型被分为:

  • Graphics:创建graphics pipelines和drawing
  • Compute:创建compute pipelines和dispatching compute shaders
  • Transfer:用于非常快速的memory-copying操作
  • Sparse:允许附加的内存管理功能

family的queues可能支持不知一种操作,可能不同的queue families支持相同类型的操作.

family属性也告知了queues的数量,是否支持时间戳,图像传输操作的粒度(在copy/blit操作时能控制的图像的最小部分).

创建logic device需要的queue families数量,属性,每个family可用的queues数量准备好后,只在创建logical device时请求他们,需要制定需要多少queue以及来自哪些families，当创建好logic device后,对应的queue也自动被创建,我们只需要获得请求的queue的handles.

重要属性 TODO

选择期望的queue family

选择一个physical device

1
2
3
4
5
6
7
8
9
10
11
uint32_t queue_family_index = 0;
VkQueueFlags desired_capabilities;//将期望的操作类型存储到该flag
//VK_QUEUE_GRAPHICS_BIT,VK_QUEUE_COMPUTE_BIT,
//VK_QUEUE_TRANSFER_BIT or VK_QUEUE_SPARSE_BINDING_BIT
std::vector<VkQueueFamilyProperties> queue_families;
//将上文获取到的结果存储到queue_families
对queue_families所有元素进行判断
	检查其queues数量是否>0
	检查desired_capabilities变量和queueFlags逻辑与操作不为0
	如果二者都通过,则存储索引到queue_family_index并跳出循环
重复上述操作知道所有元素被检查

创建logical devcie

logical device是app里创建的最重要的object,它代表了真实硬件,包括所有的扩展和激活的特性,以及向它请求的所有队列.

logical device允许我们做渲染软件里的所有工作，比如创建images和buffers，设置pipeline state或者加载shaders.最终要的是记录commands(比如draw calls或者分发computational works)和提交它们到queues.

准备

1
2
3
4
struct QueueInfo {
uint32_t FamilyIndex;
std::vector<float> Priorities;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
std::vector<VkExtensionProperties> available_extensions;
if( !CheckAvailableDeviceExtensions( physical_device, available_extensions
) ) {
	return false;
}
for( auto & extension : desired_extensions ) {
    if( !IsExtensionSupported( available_extensions, extension ) ) {
    std::cout << "Extension named '" << extension << "' is not supported by
    a physical device." << std::endl;
    return false;
    }
}
std::vector<VkDeviceQueueCreateInfo> queue_create_infos;
for( auto & info : queue_infos ) {
queue_create_infos.push_back( {
VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
nullptr,
0,
info.FamilyIndex,
static_cast<uint32_t>(info.Priorities.size()),
info.Priorities.size() > 0 ? &info.Priorities[0] : nullptr
} );
};
//Layers和extensions为非必需的
//但如果想使用高级特性(geometry,tessellation shaders)需要激活他们，
//不需要的特性可以关闭它们（有一些特性可能会影响性能）
VkDeviceCreateInfo device_create_info = {
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
nullptr,
0,
static_cast<uint32_t>(queue_create_infos.size()),
queue_create_infos.size() > 0 ? &queue_create_infos[0] : nullptr,
0,
nullptr,
static_cast<uint32_t>(desired_extensions.size()),
desired_extensions.size() > 0 ? &desired_extensions[0] : nullptr,
desired_features
};

vkCreateDevice( physical_device, &device_create_info,
nullptr, &logical_device ).

获取device queue

device queue是硬件资源,只能获取已有数量的

前提

1
2
3
4
获取到VkDvice logical_dvice
选取了queueFamilyIndx
选择一个queue_indexx
准备变量VkQueue queue
1
2
3
调用
vkGetDeviceQueue(logical_device, queue_family_index,
queue_index, &queue);

重复上述操作可以获取到所有queue families里的所有queues

创建有geometry shaders,graphics和compute queues的logical device

现在现需要美剧所有physical device找到其中支持geometry shaders,graphics和compute queues的来创建logical device

前期准备

1
2
3
4
声明变量
VkDevice logical_device;
VkQueue graphics_queue;
VkQueue compute_queue;
1
2
std::vector<VkPhysicalDevice> physical_devices;
EnumerateAvailablePhysicalDevices( instance, physical_devices );

对每一个physical device进行如下操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
for( auto & physical_device : physical_devices ) {
    VkPhysicalDeviceFeatures device_features;
    VkPhysicalDeviceProperties device_properties;
    GetTheFeaturesAndPropertiesOfAPhysicalDevice( physical_device,
                                                 device_features, device_properties );
    //geometry shader
    if( !device_features.geometryShader ) {
        continue;
    } else {
        device_features = {};
        device_features.geometryShader = VK_TRUE;
    }
    //graphic queue
    uint32_t graphics_queue_family_index;
    if( !SelectIndexOfQueueFamilyWithDesiredCapabilities( physical_device,
                                                         VK_QUEUE_GRAPHICS_BIT, graphics_queue_family_index ) ) {
        continue;
    }
    //compute queue
    uint32_t compute_queue_family_index;
    if( !SelectIndexOfQueueFamilyWithDesiredCapabilities( physical_device,
                                                         VK_QUEUE_COMPUTE_BIT, compute_queue_family_index ) ) {
        continue;
    }
    std::vector<QueueInfo> requested_queues = { {
        graphics_queue_family_index, { 1.0f } } };
    if( graphics_queue_family_index != compute_queue_family_index ) {
        requested_queues.push_back( { compute_queue_family_index, { 1.0f } } );
    }

如果graphics和computee queue families有相同的index,我们能使用同一个queue,如果不同就要用两个

创建logical device

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
if( !CreateLogicalDevice( physical_device, requested_queues, {},
                         &device_features, logical_device ) ) {
    continue;
} else {
    if( !LoadDeviceLevelFunctions( logical_device, {} ) ) {
        return false;
    }
    GetDeviceQueue( logical_device, graphics_queue_family_index, 0,
                   graphics_queue );
    GetDeviceQueue( logical_device, compute_queue_family_index, 0,
                   compute_queue );
    return true;
}
}
return false;

Destroying a logical device

按照创建的相反顺序销毁资源

1
2
3
4
if( logical_device ) {
    vkDestroyDevice( logical_device, nullptr );
    logical_device = VK_NULL_HANDLE;
}

Posted on | In , ,

Shaders

[TOC]

说明

内容

  • Converting GLSL shaders to SPIR-V assemblies
  • Writing vertex shaders
  • Writing tessellation control shaders
  • Writing tessellation evaluation shaders
  • Writing geometry shaders
  • Writing fragment shaders
  • Writing compute shaders
  • Writing a vertex shader that multiplies a vertex position by a projection matrix
  • Using push constants in shaders
  • Writing a texturing vertex and fragment shaders
  • Displaying polygon normals with a geometry shader

介绍

3D graphics data(vertices和fragments/pixels)运行在叫做stages的一些列步骤里.某些stages只执行固定操作(只能配置某些扩展操作).单有其他stages需要programmed.控制这些stages的行为的小programs称为shaders.

vulkan里最主要的5个可编程graphic pipeline stages为vertex,tessellation control,evaluation,geometry,fragment.(1.1.85发布了Raytracing, Mesh Shaders & Other New NVIDIA Extensions，https://www.phoronix.com/scan.php?page=news_item&px=Vulkan-1.1.85-Released).compute pipeline有compute shader programs.core Vulkan API 通过SPIR-V的programs控制这些stages.他是一门中间语言,允许我们process graphics data和进行vectors,matrices,images,buffers,samplers的数学计算.这种语言的low-level特性提高了编译时间(compilation times).也使得书写shader困难.所以vulkan sdk提供一个工具链glslangValidator.

glslangValidator可以将GLSL转换为SPIR-V assemblies.

本文介绍GLSL,所有programmable stages的shaders实现,如何实现tessellation或texturing,如何使用geometry shaders来debuging.以及将GLSL转换为SPIR-V assemblies(使用glslangValidator).

Converting GLSL shaders to SPIR-V assemblies

shaders与stage

  • vert for the vertex shader stage
  • tesc for the tessellation control shader stage
  • tese for the tessellation evaluation shader stage
  • geom for the geometry shader stage
  • frag for the fragment shader stage
  • comp for the compute shader

Writing vertex shaders

顶点.

如果想绘制nosolid geometry,需要在创建logical device是激活fillModeNonSolid属性.

vertex processing是graphics pipeline第一个stage,主要目的是对顶点进行坐标转换,从局部坐标转换到coordinate system(clip space).这个clip coordinate system用于图形硬件后续步骤.其一为clipping.

但这个工作也可以延后到tessellation or geeometry shader.

存储到gl_Position.

一个例子

1
2
3
4
5
#version 450
layout( location = 0 ) in vec4 app_position;
void main() {
	gl_Position = app_position;
}

Writing tessellation control shaders

细分.

需要在创建logical device时激活tessellationShader特性.

可选的.分为三步,其中两步是可编程的.The first programmable tessellation stage is used to set up parameters that control how the tessellation is performed.通过编写tessellation control shaders指明tessellation factors的值.

tessellation control and tessellation evaluation shaders是一起用的.

tessellation stage对patches进行操作.Patches由vertices组成,但与传统polygons不同,$\color {red}{每个patch可能任意个顶点,1~(至少)32个}​$.

细分是通过在shader代码里指明的inner和outer tessellation factors实现的.inner fctor由内置gl_TessLevelInner[]数组指明patch内部是如何细分的.outer factor 对应的是gl_TessLevelOuter[],定义了如何细分patches的外边缘(outer edges).每个数组元素对应于patches的给定边.

tessellation control shader对patch的每个vertex执行一次.当前vertex的index为gl_InvocationID.只有当前的可写,但可以通过gl_in[].gl_Position读取input patch的所有vertices.

一个例子

1
2
3
4
5
6
7
8
9
10
11
#version 450
layout( vertices = 3 ) out;
void main() {
    if( 0 == gl_InvocationID ) {
        gl_TessLevelInner[0] = 3.0;
        gl_TessLevelOuter[0] = 3.0;
        gl_TessLevelOuter[1] = 4.0;
        gl_TessLevelOuter[2] = 5.0;
    }
	gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;
}

Writing tessellation evaluation shaders

Tessellation evaluations是tessellation process的第二个可编程stage.当geometry被细分后(subdivided),手机细分的结果形成新的vertices并重新修改它们.我们需要编写tessellation evaluation shaders来获取生成的顶点的位置,并将它们提供给连续的consecutive pipeline stages.

在这两个着色器之间是根据control stage 提供的参数进行细分的真实过程.tessellation的结果在evaluation stage中用到,生成新的geometry.

在tessellation evaluation中能控制新的primitives如何对其并形成.我们指定了它们的缠绕顺序(winding order)和生成顶点之间的间距.同时能选择是否在tessellation stage创建isolines, triangles,or quads来改变图元类型.

新顶点㐊直接创建的,细分器只为新vertices生成重心细分坐标(barycentric tessellation coordinates)(weights),内置变量为gl_TessCoord.我们可以使用这些坐标在形成面片的顶点的原始位置之间进行插值(interpolate),并将新的顶点放置在正确的位置.这也是evaluation shader可以访问所有顶点的原因.(gl_in[].gl_Position)

三角形通常不用做任何事

1
2
3
4
5
6
7
#version 450
layout( triangles, equal_spacing, cw ) in;
void main() {
    gl_Position = gl_in[0].gl_Position * gl_TessCoord.x +
    gl_in[1].gl_Position * gl_TessCoord.y +
    gl_in[2].gl_Position * gl_TessCoord.z;
}

Writing geometry shaders

当绘制Object时,我们提供顶点并指明图元(primitives)类型(points,lines,triangles).在vertex和可选的tessellation stages后,形成了指定的图元类型.可选的可以激活geometry stage并写geometry shaders控制或改变从vertices形成primitives的过程.在geometry shaders甚至可以创建新的primities或销毁已经存在的.

geometry shaders允许创建额外的vertices混合primitives,删除已经存在的或改变vertices形成的primitive类型.

它能访问primitvie的所有vertices,且能调整它们.根据这些数据能原文传递或者创建新的vertices和primitives.但不能在一个gs中创建太多vetices.tessellation shaders更适合做这种操作.应尽量减少gs发出的顶点数.

gs总生成strip primitives.如果想创建独立图元–不形成strip,只需要在合适的时机end a primitive–vertices emitted

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#version 450
layout( triangles ) in;
layout( triangle_strip, max_vertices = 9 ) out;
void main() {
    for( int vertex = 0; vertex < 3; ++vertex ) {
        gl_Position = gl_in[vertex].gl_Position + vec4( 0.0, -0.2, 0.0, 0.0 );
        EmitVertex();
        gl_Position = gl_in[vertex].gl_Position + vec4( -0.2, 0.2, 0.0, 0.0 );
        EmitVertex();
        gl_Position = gl_in[vertex].gl_Position + vec4( 0.2, 0.2, 0.0, 0.0 );
        EmitVertex();
        EndPrimitive();//介绍一个图元,不形成strip
    }
}

Writing fragment shaders

fragment对geometry shader后的操作(rasterization,光栅化)的数据进行计算,一般使用屏幕坐标系(screen space coordinate(x,y,depth)).能选择哪个attachment写入颜色.

geometry 形成的primitives在rasterization过程中转换为fragments(pixels).fragment sahder对每个fragment执行一遍.shader中或framebuffer tests(depth,stencil,scissor tests)中Fragments可能discard,不会成为pixels–这是它们称为fragments而不是pixels的原因.

fragment sahder最重要的目的是设置写入attachement的颜色.通常进行光照计算和texturing.和compute shaders配合,fragment shader还常用来进行后处理(bloom等)或者defered shading/lighting.同时,只有fragment shader能访问render pass定义的input attachments.

一个简单例子

1
2
3
4
5
#version 450
layout( location = 0 ) out vec4 frag_color;
void main() {
	frag_color = vec4( 0.8, 0.4, 0.0, 1.0 );
}

Writing compute shaders

compute shader常用来数学计算.它们以3D形式的组执行并可能访问a common set of data.同时,很多local groups能一起执行能更快得到结果.

只能在compute pipeline里使用.

compute shadeers没有任何早于或晚于pipeline stages的输入或输出.只有compute pipeline stage的.uniform varables必须作为其数据来源.相似,计算结果存储在Uniform variables.

有些内置变量.用来索引.

local workgroup中给定compute shader调用的索引

1
uvec3 gl_LocalInvocationID

同时分发的workgroups的数量

1
uvec3 gl_NumWorkGroups

当前workgroup的number

1
uvec3 gl_WorkGroupID

还有个给当前shader在所有workgroups里所有调用唯一编号的

1
2
uvec3 gl_GlobalInvocationID;
= gl_WorkGroupID * gl_WorkGroupSize + gl_LocalInvocationID

local workgroup的size由input layout qualifier定义.在shader里,uvec3 gl_WorkGroupSize也可以获得这个size.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#version 450
layout( local_size_x = 32, local_size_y = 32 ) in;
layout( set = 0, binding = 0, rgba8 ) uniform image2D StorageImage;
void main() {
    vec2 z = gl_GlobalInvocationID.xy * 0.001 - vec2( 0.0, 0.4 );
    vec2 c = z;
    vec4 color = vec4( 0.0 );
    for( int i=0; i<50; ++I ) {
        z.x = z.x * z.x-- z.y * z.y + c.x;
        z.y = 2.0 * z.x * z.y + c.y;
        if( dot( z, z ) > 10.0 ) {
        color = i * vec4( 0.1, 0.15, 0.2, 0.0 );
        break;
	}
	}
	imageStore( StorageImage, ivec2( gl_GlobalInvocationID.xy ), color );
}

Writing a vertex shader that multiplies vertex position by a projection matrix

将geometry从local 变换到clip space通常在vertex shader进行,尽管其他vertex processing stage(tessellation or geometry)也能完成这个工作.这个变换通过指明model,view,projection matrices和从app提供三者的值给shader或者合为一个MVP矩阵.最普通和简单的方式是使用uniform buffer.

1
2
3
4
5
6
7
8
#version 450
layout(location = 0) in vec4 app_position;
layout(set=0, binding=0) uniform UniformBuffer {
	mat4 ModelViewProjectionMatrix;
};
void main() {
	gl_Position = ModelViewProjectionMatrix * app_position;
}

uniform buffer $0^{th}$ set,$0^{th}$ binding.

using push constants in shaders

当给shaders提供数据通常使用uniform buffers,storage buffers,或其他descriptor resources.不幸的是更新这样一个 resources可能不太合适,尤其是经常改变数据的时候.

为了这个目的,需要引入push constants.通过它们我们能用更简单和快速的方法提供数据.单需要fit更小的可用空间.

使用GLSL shaders里的push constants类似uniform buffers.

不同之处

  • 1.使用layout(push_constant)
  • 必须指明instance name
  • 每个shader只能定义一个
  • 通过访问instance name of the block 访问push constant

constants在更新频繁的小数据上非常游泳,比如变换矩阵或物理量(time,dt等).需要记住数据的size比descriptor resources小得多.$\color{red}{规范要求push constants至少存储128 bytes数据}$.每个硬件平台可能允许更多的存储,但可能不会大得多.

在提供颜色的片段明暗器中定义和使用push常量的示例如下:

1
2
3
4
5
6
7
8
#version 450
layout( location = 0 ) out vec4 frag_color;
layout( push_constant ) uniform ColorBlock {
	vec4 Color;
} PushConstant;
void main() {
	frag_color = PushConstant.Color;
}

Writing texturing vertex and fragment shaders

vertex shader

1
2
3
4
5
6
7
8
#version 450
layout( location = 0 ) in vec4 app_position;
layout( location = 1 ) in vec2 app_tex_coordinates;
layout( location = 0 ) out vec2 vert_tex_coordinates;
void main() {
    gl_Position = app_position;
    vert_tex_coordinates = app_tex_coordinates;
}

fragment shader

1
2
3
4
5
6
7
#version 450
layout( location = 0 ) in vec2 vert_tex_coordinates;
layout( set=0, binding=0 ) uniform sampler2D TextureImage;
layout( location = 0 ) out vec4 frag_color;
void main() {
	frag_color = texture( TextureImage, vert_tex_coordinates );
}

Displaying polygon normals with a geometry shader

介绍一种简单的检查发现的方法.

vertex shader

1
2
3
4
5
6
7
8
9
10
11
12
#version 450
layout( location = 0 ) in vec4 app_position;
layout( location = 1 ) in vec3 app_normal;
layout( set = 0, binding = 0 ) uniform UniformBuffer {
    mat4 ModelViewMatrix;
    mat4 ProjectionMatrix;
};
layout( location = 0 ) out vec4 vert_normal;
void main() {
    gl_Position = ModelViewMatrix * app_position;
    vert_normal = vec4( mat3( ModelViewMatrix ) * app_normal * 0.2, 0.0 );
}

view space

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#version 450
layout( triangles ) in;
layout( location = 0 ) in vec4 vert_normal[];
layout( set = 0, binding = 0 ) uniform UniformBuffer {
    mat4 ModelViewMatrix;
    mat4 ProjectionMatrix;
};
layout( line_strip, max_vertices = 6 ) out;//line
layout( location = 0 ) out vec4 geom_color;
void main() {
    for( int vertex = 0; vertex < 3; ++vertex ) {
        gl_Position = ProjectionMatrix * gl_in[vertex].gl_Position;
        geom_color = vec4( 0.2 );
        EmitVertex();
        gl_Position = ProjectionMatrix * (gl_in[vertex].gl_Position +
        vert_normal[vertex]);//normal 方向延长，并变换到clip space
        geom_color = vec4( 0.6 );
        EmitVertex();
        EndPrimitive();
    }
}

为什么使用一个uniform buffer呢？一般来说cb里步骤越少效率越高

fragment shader

1
2
3
4
5
6
#version 450
layout( location = 0 ) in vec4 geom_color;
layout( location = 0 ) out vec4 frag_color;
void main() {
	frag_color = geom_color;
}

Posted on | In , ,

关于dll

介绍

Vulkan API 是硬件厂商提供的,在驱动里.安装Vulkan SDK后，开发者不用关心驱动层,可以通过(windows)vulkan-1.dll或(linux)libvulkan.so.1访问Vulkan API.

loadlibrary的方式

1
2
3
4
5
6
7
8
9
10
11
#if defined _WIN32
vulkan_library = LoadLibrary( "vulkan-1.dll" );
#elif defined __linux
vulkan_library = dlopen( "libvulkan.so.1", RTLD_NOW );
#endif
if( vulkan_library == nullptr ) {
std::cout << "Could not connect with a Vulkan Runtime library." <<
std::endl;
return false;
}
return true;

加载Vulkan API函数

方式

第一种方式:可以进行静态链接,并使用vulkan.h里定义的函数原型

第二种方式:不用vulkan.h了定义的原型,而是动态加载函数指针

第一种方式简单,但是每次调用函数时都会重定向一次,效率更低

第二种方式无重定向过程,且可以选择子集,但麻烦点，基本都用这种方式的，这里只介绍这种方式

方式

1.定义VK_NO_PROTOTYPES或者在引入vulkan.h前定义#define VK_NO_PROTOTYPES

2.创建新文件名为ListOfVulkanFunctions.inl

输入一下内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#ifndef EXPORTED_VULKAN_FUNCTION
#define EXPORTED_VULKAN_FUNCTION( function )
#endif
#undef EXPORTED_VULKAN_FUNCTION
//
#ifndef GLOBAL_LEVEL_VULKAN_FUNCTION
#define GLOBAL_LEVEL_VULKAN_FUNCTION( function )
#endif
#undef GLOBAL_LEVEL_VULKAN_FUNCTION
//
#ifndef INSTANCE_LEVEL_VULKAN_FUNCTION
#define INSTANCE_LEVEL_VULKAN_FUNCTION( function )
#endif
#undef INSTANCE_LEVEL_VULKAN_FUNCTION
//
#ifndef INSTANCE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION
#define INSTANCE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION( function,
extension )
#endif
#undef INSTANCE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION
//
#ifndef DEVICE_LEVEL_VULKAN_FUNCTION
#define DEVICE_LEVEL_VULKAN_FUNCTION( function )
#endif
#undef DEVICE_LEVEL_VULKAN_FUNCTION
//
#ifndef DEVICE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION
#define DEVICE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION( function,
extension )
#endif
#undef DEVICE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION

创建头文件VulkanFunctions.h,输入一下内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include "vulkan.h"
namespace vkapi {
#define EXPORTED_VULKAN_FUNCTION( name ) extern PFN_##name name;
#define GLOBAL_LEVEL_VULKAN_FUNCTION( name ) extern PFN_##name
name;
#define INSTANCE_LEVEL_VULKAN_FUNCTION( name ) extern PFN_##name
name;
#define INSTANCE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION( name,
extension ) extern PFN_##name name;
#define DEVICE_LEVEL_VULKAN_FUNCTION( name ) extern PFN_##name
name;
#define DEVICE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION( name,
extension ) extern PFN_##name name;
#include "ListOfVulkanFunctions.inl"
} // namespace vkapi

创建源文件VulkanFunctions.cpp,输入一下内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include "VulkanFunctions.h"
namespace vkapi {
#define EXPORTED_VULKAN_FUNCTION( name ) PFN_##name name;
#define GLOBAL_LEVEL_VULKAN_FUNCTION( name ) PFN_##name name;
#define INSTANCE_LEVEL_VULKAN_FUNCTION( name ) PFN_##name name;
#define INSTANCE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION( name,
extension ) PFN_##name name;
#define DEVICE_LEVEL_VULKAN_FUNCTION( name ) PFN_##name name;
#define DEVICE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION( name,
extension ) PFN_##name name;
#if defined _WIN32
#define LoadFunction GetProcAddress
#elif defined __linux
#define LoadFunction dlsym
#endif
#define EXPORTED_VULKAN_FUNCTION( name ) \
name = (PFN_##name)LoadFunction( vulkan_library, #name ); \
if( name == nullptr ) { \
std::cout << "Could not load exported Vulkan function named: " \
#name << std::endl; \
return false; \
}
#include "ListOfVulkanFunctions.inl"
} // namespace vkapi

通过在ListOfVulkanFunctions.inl中添加新的函数名可以加载更多vulkan api

函数名原型:name的原型为PFN_name

分为3类

global-level,instance-level,device-level

global-level

创建变量

PFN_vkEnumerateInstanceExtensionProperties

PFN_vkEnumerateInstanceLayerProperties

PFN_vkCreateInstance

并调用vkGetInstanceProcAddr获取到对于函数指针

在ListOfVulkanFunctions.inl中添加

1
2
3
4
5
6
7
#ifndef GLOBAL_LEVEL_VULKAN_FUNCTION
#define GLOBAL_LEVEL_VULKAN_FUNCTION( function )
#endif
GLOBAL_LEVEL_VULKAN_FUNCTION( vkEnumerateInstanceExtensionProperties )
GLOBAL_LEVEL_VULKAN_FUNCTION( vkEnumerateInstanceLayerProperties )
GLOBAL_LEVEL_VULKAN_FUNCTION( vkCreateInstance )
#undef GLOBAL_LEVEL_VULKAN_FUNCTION

在VulkanFunctions.cpp的#include “ListOfVulkanFunctions.inl”前添加

1
2
3
4
5
6
7
#define GLOBAL_LEVEL_VULKAN_FUNCTION( name ) \
name = (PFN_##name)vkGetInstanceProcAddr( nullptr, #name ); \
if( name == nullptr ) { \
std::cout << "Could not load global-level function named: " \
#name << std::endl; \
return false; \
}

instance-level

变量声明一样的

1
2
3
4
5
6
7
8
vkEnumeratePhysicalDevices
vkGetPhysicalDeviceProperties
vkGetPhysicalDeviceFeatures
vkGetPhysicalDeviceQueueFamilyProperties
vkCreateDevice
vkGetDeviceProcAddr
vkDestroyInstance
vkEnumerateDeviceExtensionProperties

不同之处是，调用vkGetInstanceProcAddr获取函数指针,第一个参数为instance

如何判断一个函数是instance-level还是device-level?

所有device-level函数第一个参数为VkDevice,VkQueue,VkCommandBuffer，因此所有第一个参数不是这些且不是global-level函数的就是device-level

需要额外注意的是,extensions能引入新的函数,需要加载它们,以便在程序中调用.

为了加载instance-level函数,对ListOfVulkanFunctions.inl进行更新

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#ifndef INSTANCE_LEVEL_VULKAN_FUNCTION
#define INSTANCE_LEVEL_VULKAN_FUNCTION( function )
#endif
INSTANCE_LEVEL_VULKAN_FUNCTION( vkEnumeratePhysicalDevices )
INSTANCE_LEVEL_VULKAN_FUNCTION( vkGetPhysicalDeviceProperties )
INSTANCE_LEVEL_VULKAN_FUNCTION( vkGetPhysicalDeviceFeatures )
INSTANCE_LEVEL_VULKAN_FUNCTION( vkCreateDevice )
INSTANCE_LEVEL_VULKAN_FUNCTION( vkGetDeviceProcAddr )
//...
#undef INSTANCE_LEVEL_VULKAN_FUNCTION
//
#ifndef INSTANCE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION
#define INSTANCE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION( function, extension
)
#endif
INSTANCE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION(
vkGetPhysicalDeviceSurfaceSupportKHR, VK_KHR_SURFACE_EXTENSION_NAME )
INSTANCE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION(
vkGetPhysicalDeviceSurfaceCapabilitiesKHR, VK_KHR_SURFACE_EXTENSION_NAME )
INSTANCE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION(
vkGetPhysicalDeviceSurfaceFormatsKHR, VK_KHR_SURFACE_EXTENSION_NAME )
#ifdef VK_USE_PLATFORM_WIN32_KHR
INSTANCE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION( vkCreateWin32SurfaceKHR,
VK_KHR_WIN32_SURFACE_EXTENSION_NAME )
#elif defined VK_USE_PLATFORM_XCB_KHR
INSTANCE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION( vkCreateXcbSurfaceKHR,
VK_KHR_XLIB_SURFACE_EXTENSION_NAME )
#elif defined VK_USE_PLATFORM_XLIB_KHR
INSTANCE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION( vkCreateXlibSurfaceKHR,
VK_KHR_XCB_SURFACE_EXTENSION_NAME )
#endif
#undef INSTANCE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION

更新VulkanFunctions.cpp

1
2
3
4
5
6
7
#define INSTANCE_LEVEL_VULKAN_FUNCTION( name ) \
name = (PFN_##name)vkGetInstanceProcAddr( instance, #name ); \
if( name == nullptr ) { \
std::cout << "Could not load instance-level Vulkan function named: "\
#name << std::endl; \
return false; \
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define INSTANCE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION( name, extension )
\
for( auto & enabled_extension : enabled_extensions ) { \
if( std::string( enabled_extension ) == std::string( extension ) )
{ \
name = (PFN_##name)vkGetInstanceProcAddr( instance, #name ); \
if( name == nullptr ) { \
std::cout << "Could not load instance-level Vulkan function named: "
\
#name << std::endl; \
return false; \
} \
} \
}

device-level

创建logical device(VkDevice logical_device)后,需要渲染3D场景、计算对象碰撞，运行视频帧的时候

  • 与前述基本一样，不同之处在于

    调用vkGetDeviceProcAddr(device,”“)获得函数指针

机核所有3D渲染软件都是使用device-level 函数进行工作的,它们用来创建buffers,images,samplers,shaders.使用device-level函数创建pipeline objects,同步primitives,framebuffers和很多其他资源.并且,最重要的,记录之后提交给queues让硬件执行的操作.

device-level函数可以通过vkGetInstanceProcAddr获取指针,但它不是最理想的.Vulkan被设计为灵活的API,它可以在单个程序里的多个devices上执行操作,但当我们调用vkGetInstanceProcAddr函数,我们不能提供任何与logical device关联的参数,因此这个函数返回的指针不能与device关联.device可能在调用vkGetInstanceProcAddr时都不存在,这是该调用返回一个dispatch函数–根据其参数,调用适用于给定的logical device的函数的实现.但是,这个jump有性能开销:很小但任然会消耗运行时间.

如果像避免这种不必要的jump且请求已给device的函数指针,我们需要调用vkGetDeviceProcAddr,这样能避免中间调用,这种方式有些缺陷：需要给app里所有device都请求各自的函数的函数指针.如果有多个device，需要给每个logical device自己的函数指针列表.使用C++预处理可以很容易获得已知device的函数的函数指针.

如何判断函数是device-level?

第一个参数是VkDevice,VkQueue,VkCommandBuffer

为了加载device-level函数，需要更新ListOfVulkanFunctions.inl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#ifndef DEVICE_LEVEL_VULKAN_FUNCTION
#define DEVICE_LEVEL_VULKAN_FUNCTION( function )
#endif
DEVICE_LEVEL_VULKAN_FUNCTION( vkGetDeviceQueue )
DEVICE_LEVEL_VULKAN_FUNCTION( vkDeviceWaitIdle )
DEVICE_LEVEL_VULKAN_FUNCTION( vkDestroyDevice )
DEVICE_LEVEL_VULKAN_FUNCTION( vkCreateBuffer )
DEVICE_LEVEL_VULKAN_FUNCTION( vkGetBufferMemoryRequirements )
// ...
#undef DEVICE_LEVEL_VULKAN_FUNCTION
//
#ifndef DEVICE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION
#define DEVICE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION( function, extension )
#endif
DEVICE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION( vkCreateSwapchainKHR,
VK_KHR_SWAPCHAIN_EXTENSION_NAME )
DEVICE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION( vkGetSwapchainImagesKHR,
VK_KHR_SWAPCHAIN_EXTENSION_NAME )
DEVICE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION( vkAcquireNextImageKHR,
VK_KHR_SWAPCHAIN_EXTENSION_NAME )
DEVICE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION( vkQueuePresentKHR,
VK_KHR_SWAPCHAIN_EXTENSION_NAME )
DEVICE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION( vkDestroySwapchainKHR,
VK_KHR_SWAPCHAIN_EXTENSION_NAME )
#undef DEVICE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION

更新VulkanFunctions.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#define DEVICE_LEVEL_VULKAN_FUNCTION( name ) \
name = (PFN_##name)vkGetDeviceProcAddr( device, #name ); \
if( name == nullptr ) { \
std::cout << "Could not load device-level Vulkan function named: " #name
<< std::endl; \
return false; \
}
#define DEVICE_LEVEL_VULKAN_FUNCTION_FROM_EXTENSION( name,
extension ) \
for( auto & enabled_extension : enabled_extensions ) { \
if( std::string( enabled_extension ) == std::string( extension )
) { \
name = (PFN_##name)vkGetDeviceProcAddr( logical_device, #name );\
if( name == nullptr ) { \
std::cout << "Could not load device-level Vulkan function named: "
\
#name << std::endl; \
return false; \
} \
} \
}

释放Vulkan Loader library

1
2
3
4
5
6
#if defined _WIN32
FreeLibrary( vulkan_library );
#elif defined __linux
dlclose( vulkan_library );
#endif
vulkan_library = nullptr;

Posted on | In , ,

Command Buffers and Synchronization

[TOC]

内容

Creating a command pool
Allocating command buffers
Beginning a command buffer recording operation
Ending a command buffer recording operation
Resetting a command buffer
Resetting a command pool
Creating a semaphore
Creating a fence
Waiting for fences
Resetting fences
Submitting command buffers to a queue
Synchronizing two command buffers
Checking if processing of a submitted command buffer has finished
Waiting until all commands submitted to a queue are finished
Waiting for all submitted commands to be finished
Destroying a fence
Destroying a semaphore
Freeing command buffers
Destroying a command pool

Vulkan的low-level APIs给予了我们队硬件更多的控制权.包括对资源的创建、管理、操作，以及与硬件的交互.command buffer是最重要的object.它允许我们记录操作并提交给硬件执行.更重要的是能在多线程中记录他们,而且是由驱动隐形记录并不需要开发者控制它们.vulkan允许我们重复使用已经存在的command buffers.给予了便利的同时也让开发者有更多的责任.

为此需要格外小心命令的提交,尤其要处理提交command buffer到GPU时如何同步,为此引入了semaphores和fences.

本节讨论command buffers的allocate、record、submit,如何创建synchronizatin primitives并使用它们控制提交操作,如何同步GPU上的command buffers,如何同步app和硬件.

command pool

创建command pool

command pool是command buffer申请缓存的地方.缓存是隐性和动态创建的,但如果没有它command buffer就没地方记录commands了.所以先创建command pool

1
2
3
4
5
6
VkCommandPoolCreateInfo command_pool_create_info = {
    VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
    nullptr,
    parameters,
    queue_family
};

VK_COMMAND_POOL_CREATE_TRANSIENT_BIT 从pool里申请一个cb,存在非常短的时间.

VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,能立即重置cb.如果没有这个flag,我们只能通过group进行操作(pool的cbs一起).如果没有这个flag,只能记录一次cb.如果想再次记录,需要重置整个pool.

command pools控制command buffers提交的队列.这二十用过queue family index实现,必须在创建Pool时提供.特定pool提供的cb只能提交给特定的family.

1
2
3
4
5
6
7
VkResult result = vkCreateCommandPool( logical_device,
&command_pool_create_info, nullptr, &command_pool );
if( VK_SUCCESS != result ) {
    std::cout << "Could not create command pool." << std::endl;
    return false;
}
return true;

command pools在多线程里不能同时被访问.这就是为什么将在其上记录命令缓冲区的每个应用程序线程都应该使用单独的command pools的原因.

command buffer

allocate command buffers

command buffers从command pools进行aloocate,这运行我们控制整个groups的一些属性.

  • 只能提交到当创建command pool时选择的family的queue里.
  • command pools不能异步使用,所以需要为每个线程创建自己的command pools,减少同步消耗,提升性能

command buffers也有自己的属性,一些是记录操作时指定,但在allocate command buffer时有一些重要参数,是否想allocate主或次command buffers:

  • primary command buffers能直接提交到queues.也能执行(call)次command buffers.
  • 次command buffers只能通过主command buffers执行.不能提交.

这些参数通过VkCommandBufferAllocateInfo指定

1
2
3
4
5
6
7
VkCommandBufferAllocateInfo command_buffer_allocate_info = {
    VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
    nullptr,
    command_pool,
    level,
    count
};

allocate

1
2
3
4
5
6
7
8
command_buffers.resize( count );
VkResult result = vkAllocateCommandBuffers( logical_device,
&command_buffer_allocate_info, &command_buffers[0] );
if( VK_SUCCESS != result ) {
        std::cout << "Could not allocate command buffers." << std::endl;
        return false;
}
return true;

开始command buffer record操作

当想用硬件执行操作时,需要记录它们并提交给queue.命令记录在command buffers里.当我们记录它们时,我们需要选择一个command buffer.

vulkan里能做的最重要的事情就是记录command buffers了.也是告诉硬件做什么怎么做的唯一方式.当开始record command buffers时,它们的状态时无定义的.通常,command buffer不继承任何状态.当我们记录操作时,我们需要记住设置与这些操作相关的状态.比如drawing command,使用vertex attributes和indices.在我们记录一次drawing操作前,需要用顶点数据和索引数据绑定到各自适当的缓冲区.

主command buffers能call(执行)记录在次command buffers里的命令.执行次command buffers不继承主command buffers的状态.主command buffer的状态在执行次command buffer后也是未定义的(当我们record 一个主command buffer,并且执行了它的一个次command buffer后,我们如果想继续record主command buffer,需要重新设置状态).只有一个意外的state继承规则–当主command buffer在一个render pass里,我们执行一个它的次command buffer,主command buffer的render pass和subpass states被保持着.

1
2
3
4
5
6
VkCommandBufferBeginInfo command_buffer_begin_info = {
    VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
    nullptr,
    usage,
    secondary_command_buffer_info
};

为了性能考虑,需要避免command buffer使用下列标记

1
K_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT

开始记录

1
2
3
4
5
6
7
8
VkResult result = vkBeginCommandBuffer( command_buffer,
&command_buffer_begin_info );
if( VK_SUCCESS != result ) {
    std::cout << "Could not begin command buffer recording operation." <<
    std::endl;
    return false;
}
return true;

现在可以向command buffer选择操作了.但我们如何知道哪些操作可以记录到command buffer里.这类函数的名字以vkCmd开头,第一个参数全是VkCommandBuffer.但需要记住不是所有命令都能给主和次command buffers使用.

结束command buffer recording operation

当我们不想记录更多commands到command buffer,我们需要停止recording它.

为了更快记录和更小影响性能,记录commands时不会有任何报错,所有错误都在vkEndCommandBuffer函数汇报.

所以停止record时需要判断record是否成功

1
2
3
4
5
6
7
VkResult result = vkEndCommandBuffer( command_buffer );
if( VK_SUCCESS != result ) {
    std::cout << "Error occurred during command buffer recording." <<
    std::endl;
    return false;
}
return true;

如果报错,就不能submit它,而需要重置它.

重置command buffer

如果一个command buffer报错了,必须reset才能重新record.可以通过开始另一个record操作来隐性重置它,也可以显示做到这点.

可以通过重置整个command pool来重置command buffers.也可以独立进行.只有在使用K_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT标志创建了用于分配命令缓冲区的池时,才能执行单独的重置.

显示重置让我们控制command buffer从创建它的pool里申请欢成.在显示重置时,我们能决定是否向归还缓存给pool,或者是否command buffer需要继续保留并在下次command record时复用它.

1
2
3
4
5
6
7
VkResult result = vkResetCommandBuffer( command_buffer, release_resources ?
VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT : 0 );
    if( VK_SUCCESS != result ) {
    std::cout << "Error occurred during command buffer reset." << std::endl;
    return false;
}
return true;

重置command pool

当我们不想单独重置command buffer或者如果我们创建的pool没有标记VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,我们能一次重置pool的所有command buffer.

重置command pool会导致所有由它创建的command buffers回到初始状态.这和单独重置所有command buffers一样,但更快速.并且没有指定VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT标记.

当command buffers被record,它们从pool里得到缓存,这被自动执行.当重置command buffer时,可以选择是否command buffers保留它们的缓存以备后用,或者返回给pool.

1
2
3
4
5
6
7
VkResult result = vkResetCommandPool( logical_device, command_pool,
release_resources ? VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT : 0 );
if( VK_SUCCESS != result ) {
    std::cout << "Error occurred during command pool reset." << std::endl;
    return false;
}
return true;

semaphore 和 fence

创建semaphore

在提交commands和利用(utilize)设备的处理能力前,我们需要知道如何同步操作.semaphores时用于同步的原语(primitives).它们允许我们不仅在一个队列中而且在一个逻辑设备中的不同队列之间协调提交到队列的操作.

semaphores当我们提交commands给queus使用.所以在我们使用它们前需要创建.

semaphores由两个状态:signaled或者unsignaled.semaphores在command buffer提交时使用.我们将它们提供给一个要发出信号的信号量列表时,一旦给定批中提交的所有工作完成,它们就会将状态更改为signaled.相同方式,当我们提交commands给queues,我们能指定提交的commands进入等待状态直到特定list里的所有semaphores变为signaled.通过这种方式,我们可以协调提交到队列的工作,并推迟对依赖于其他命令结果的命令的处理.

当所有semaphores处于signaled且所有等待它们的命令恢复(变为un-signaled)然后复用.

semaphores也用于从swapchain请求images,此时,semaphores必须当我们向相关的images提交commands时使用.这些commands必须等待知道images不再被presentation engine使用.

vkCreateSemaphore

1
2
3
4
5
6
7
8
9
10
11
12
VkSemaphoreCreateInfo semaphore_create_info = {
    VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
    nullptr,
    0
};
VkResult result = vkCreateSemaphore( logical_device,
&semaphore_create_info, nullptr, &semaphore );
if( VK_SUCCESS != result ) {
    std::cout << "Could not create a semaphore." << std::endl;
    return false;
}
return true;

semaphores只能用于同步提交给queues的工作,位于硬件核心.app不能获得semaphore的状态,如果app需要同步提交了的commands需要使用fences.

创建fences

fences是用来同步app和提交给图形硬件的commands的.

1
2
3
4
5
6
7
8
9
10
11
12
VkFenceCreateInfo fence_create_info = {
    VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
    nullptr,
    signaled ? VK_FENCE_CREATE_SIGNALED_BIT : 0
};
VkResult result = vkCreateFence( logical_device, &fence_create_info,
nullptr, &fence );
if( VK_SUCCESS != result ) {
    std::cout << "Could not create a fence." << std::endl;
    return false;
}
return true;

wait fences

vkWaitForFences

1
2
3
4
5
6
7
8
9
10
if( fences.size() > 0 ) {
    VkResult result = vkWaitForFences( logical_device,
    static_cast<uint32_t>(fences.size()), &fences[0], wait_for_all, timeout );
    if( VK_SUCCESS != result ) {
        std::cout << "Waiting on fence failed." << std::endl;
        return false;
    }
    return true;
}
return false;

reset fences

semaphores自动reset,但当fence标记为signaled后,app负责reset.

1
2
3
4
5
6
7
8
9
10
if( fences.size() > 0 ) {
    VkResult result = vkResetFences( logical_device,
    static_cast<uint32_t>(fences.size()), &fences[0] );
    if( VK_SUCCESS != result ) {
        std::cout << "Error occurred when tried to reset fences." << std::endl;
        return false;
    }
    return VK_SUCCESS == result;
}
return false;

submit

submit command buffers to a queue

1
2
3
4
struct WaitSemaphoreInfo {
    VkSemaphore Semaphore;
    VkPipelineStageFlags WaitingStage;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
std::vector<VkSemaphore> wait_semaphore_handles;
std::vector<VkPipelineStageFlags> wait_semaphore_stages;
for( auto & wait_semaphore_info : wait_semaphore_infos ) {
wait_semaphore_handles.emplace_back( wait_semaphore_info.Semaphore );
wait_semaphore_stages.emplace_back( wait_semaphore_info.WaitingStage );
}
VkSubmitInfo submit_info = {
    VK_STRUCTURE_TYPE_SUBMIT_INFO,
    nullptr,
    static_cast<uint32_t>(wait_semaphore_infos.size()),
    wait_semaphore_handles.size() > 0 ? &wait_semaphore_handles[0] : nullptr,
    wait_semaphore_stages.size() > 0 ? &wait_semaphore_stages[0] : nullptr,
    static_cast<uint32_t>(command_buffers.size()),
    command_buffers.size() > 0 ? &command_buffers[0] : nullptr,
    static_cast<uint32_t>(signal_semaphores.size()),
    signal_semaphores.size() > 0 ? &signal_semaphores[0] : nullptr
};


VkResult result = vkQueueSubmit( queue, 1, &submit_info, fence );
if( VK_SUCCESS != result ) {
    std::cout << "Error occurred during command buffer submission." <<
    std::endl;
    return false;
}
return true;

出于性能考虑,需要尽可能在少的dc中提交更多的batches

当一个cb提交后还没执行完,不能再次提交,除非使用flag:VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,但为了性能考虑要尽量避免这个flag.

同步两个cb

semaphores

1
2
3
4
struct WaitSemaphoreInfo {
    VkSemaphore Semaphore;
    VkPipelineStageFlags WaitingStage;
};
1
2
3
4
5
6
7
8
std::vector<VkSemaphore> first_signal_semaphores;
for( auto & semaphore_info : synchronizing_semaphores ) {
	first_signal_semaphores.emplace_back( semaphore_info.Semaphore );
}
if( !SubmitCommandBuffersToQueue( first_queue, first_wait_semaphore_infos,
first_command_buffers, first_signal_semaphores, VK_NULL_HANDLE ) ) {
    return false;
}

这里同时使用handles和pipeline stages,第二个batch会等待特定pipeline stages的所有semaphores,这意味着提交的cbs部分会开始执行,当到达提供的stages时会暂停

1
2
3
4
5
if( !SubmitCommandBuffersToQueue( second_queue, synchronizing_semaphores,
second_command_buffers, second_signal_semaphores, second_fence ) ) {
    return false;
}
return true;

这显示了如何同步从同一逻辑设备提交到不同队列的多个命令缓冲区的工作.从第二次提交开始的命令缓冲区处理将被推迟,直到第一批中的所有命令完成.

检查提交后的cb是否完成

当使用semaphores时,app没有被cb的同步给牵制.

当我们想知道cb何时结束,我们需要使用fences

创建fence,准备cb,提交给queue,记住提交时使用的fence

1
2
3
4
if( !SubmitCommandBuffersToQueue( queue, wait_semaphore_infos,
command_buffers, signal_semaphores, fence ) ) {
	return false;
}

然后等待

1
return WaitForFences( logical_device, { fence }, VK_FALSE, timeout );

这样可以确保cb成功执行才开始接下来的任务.

但是,通常,渲染不应该造成app完全暂停.我们需要检查fence是否signaled,如果没有,就继续执行其他任务,比如ai、物理.当fence signaled,然后执行需要以来提交的commands状态的任务.

fences在我们想reuse cb时也有用,在我们re-cecord它们前,必须确保不再被device执行.我们需要有一定数量的command buffers 一个接一个 记录和提交.只有这样,我们使用其中一个时,就启动一个fence(每个submitted batch需要有一个关联的fence).分批的cb越多,花费在等待fences上的时间越少.(但效率不一定)

等待queue的所有commands结束

并不总希望使用fences,app等待选择的queue执行结束也是可行的.

vkQueueWaitIdle

但这种同步在非常罕见的情况下执行.GPU比CPU快且可能需要不断提交工作以充分利用申请的性能.

在应用程序端执行等待可能会在图形硬件的管道中造成停顿，从而导致设备的利用效率低下

1
2
3
4
5
6
7
VkResult result = vkQueueWaitIdle( queue );
if( VK_SUCCESS != result ) {
    std::cout << "Waiting for all operations submitted to queue failed." <<
    std::endl;
    return false;
}
return true;

等待提交的commands结束

这种等待一般要关闭app和想要销毁创建的资源时用到

1
2
3
4
5
6
VkResult result = vkDeviceWaitIdle( logical_device );
if( VK_SUCCESS != result ) {
    std::cout << "Waiting on a device failed." << std::endl;
    return false;
}
return true;

destroy

1
2
3
4
if( VK_NULL_HANDLE != fence ) {
    vkDestroyFence( logical_device, fence, nullptr );
    fence = VK_NULL_HANDLE;
}
1
2
3
4
if( VK_NULL_HANDLE != semaphore ) {
    vkDestroySemaphore( logical_device, semaphore, nullptr );
    semaphore = VK_NULL_HANDLE;
}
1
2
3
4
5
if( command_buffers.size() > 0 ) {
    vkFreeCommandBuffers( logical_device, command_pool,
    static_cast<uint32_t>(command_buffers.size()), &command_buffers[0] );
    command_buffers.clear();
}
1
2
3
4
if( VK_NULL_HANDLE != command_pool ) {
    vkDestroyCommandPool( logical_device, command_pool, nullptr );
    command_pool = VK_NULL_HANDLE;
}