奇怪的opengl渲染断断续续
strange opengl rendering stutter
我在我的简单opengl（通过GLFW3）应用程序中遇到了一个奇怪的口吃。尽管启用了vsync（帧速率几乎稳定在60fps），但旋转三角形的运动并不总是平滑的——有时几乎就像跳过了一些帧。我试着查看对glSwapBuffers（）的连续调用之间的时间差，但这些调用似乎非常一致。
我做错什么了吗？我应该使用某种运动模糊过滤使其看起来更平滑吗？
代码：
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <cfloat>
#include <cassert>
#include <minmax.h>
#include <string>
#include <iostream>
#include <fstream>
#include <vector>
#include <Windows.h>
#include <GL/glew.h>
#include <gl/GLU.h>
//#include <GL/GL.h>
#include <GLFW/glfw3.h>
#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
#ifdef _WIN32
#pragma warning(disable:4996)
#endif
static int swap_interval;
static double frame_rate;
GLuint LoadShaders(const char * vertex_file_path,const char * fragment_file_path){
// Create the shaders
GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
// Read the Vertex Shader code from the file
std::string VertexShaderCode;
std::ifstream VertexShaderStream(vertex_file_path, std::ios::in);
if(VertexShaderStream.is_open()){
std::string Line = "";
while(getline(VertexShaderStream, Line))
VertexShaderCode += "n" + Line;
VertexShaderStream.close();
}else{
printf("Impossible to open %s. Are you in the right directory ? Don't forget to read the FAQ !n", vertex_file_path);
return 0;
}
// Read the Fragment Shader code from the file
std::string FragmentShaderCode;
std::ifstream FragmentShaderStream(fragment_file_path, std::ios::in);
if(FragmentShaderStream.is_open()){
std::string Line = "";
while(getline(FragmentShaderStream, Line))
FragmentShaderCode += "n" + Line;
FragmentShaderStream.close();
}
GLint Result = GL_FALSE;
int InfoLogLength;
// Compile Vertex Shader
printf("Compiling shader : %sn", vertex_file_path);
char const * VertexSourcePointer = VertexShaderCode.c_str();
glShaderSource(VertexShaderID, 1, &VertexSourcePointer , NULL);
glCompileShader(VertexShaderID);
// Check Vertex Shader
glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result);
if (Result != GL_TRUE)
{
glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
if ( InfoLogLength > 0 ){
std::vector<char> VertexShaderErrorMessage(InfoLogLength+1);
glGetShaderInfoLog(VertexShaderID, InfoLogLength, NULL, &VertexShaderErrorMessage[0]);
printf("%sn", &VertexShaderErrorMessage[0]);
}
}
// Compile Fragment Shader
printf("Compiling shader : %sn", fragment_file_path);
char const * FragmentSourcePointer = FragmentShaderCode.c_str();
glShaderSource(FragmentShaderID, 1, &FragmentSourcePointer , NULL);
glCompileShader(FragmentShaderID);
// Check Fragment Shader
glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result);
if (Result != GL_TRUE)
{
glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
if ( InfoLogLength > 0 ){
std::vector<char> FragmentShaderErrorMessage(InfoLogLength+1);
glGetShaderInfoLog(FragmentShaderID, InfoLogLength, NULL, &FragmentShaderErrorMessage[0]);
printf("%sn", &FragmentShaderErrorMessage[0]);
}
}
// Link the program
printf("Linking programn");
GLuint ProgramID = glCreateProgram();
glAttachShader(ProgramID, VertexShaderID);
glAttachShader(ProgramID, FragmentShaderID);
glLinkProgram(ProgramID);
// Check the program
glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result);
if (Result != GL_TRUE)
{
glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength);
if ( InfoLogLength > 0 ){
std::vector<char> ProgramErrorMessage(InfoLogLength+1);
glGetProgramInfoLog(ProgramID, InfoLogLength, NULL, &ProgramErrorMessage[0]);
printf("%sn", &ProgramErrorMessage[0]);
}
}
#ifdef _DEBUG
glValidateProgram(ProgramID);
#endif
glDeleteShader(VertexShaderID);
glDeleteShader(FragmentShaderID);
return ProgramID;
}
static void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
glViewport(0, 0, width, height);
}
static void set_swap_interval(GLFWwindow* window, int interval)
{
swap_interval = interval;
glfwSwapInterval(swap_interval);
}
static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
if (key == GLFW_KEY_SPACE && action == GLFW_PRESS)
set_swap_interval(window, 1 - swap_interval);
}
static bool init(GLFWwindow** win)
{
if (!glfwInit())
exit(EXIT_FAILURE);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_COMPAT_PROFILE);
// creating a window using the monitor param will open it full screen
const bool useFullScreen = false;
GLFWmonitor* monitor = useFullScreen ? glfwGetPrimaryMonitor() : NULL;
*win = glfwCreateWindow(640, 480, "", monitor, NULL);
if (!(*win))
{
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwMakeContextCurrent(*win);
GLenum glewError = glewInit();
if( glewError != GLEW_OK )
{
printf( "Error initializing GLEW! %sn", glewGetErrorString( glewError ) );
return false;
}
//Make sure OpenGL 2.1 is supported
if( !GLEW_VERSION_2_1 )
{
printf( "OpenGL 2.1 not supported!n" );
return false;
}
glfwMakeContextCurrent(*win);
glfwSetFramebufferSizeCallback(*win, framebuffer_size_callback);
glfwSetKeyCallback(*win, key_callback);
// get version info
const GLubyte* renderer = glGetString (GL_RENDERER); // get renderer string
const GLubyte* version = glGetString (GL_VERSION); // version as a string
printf("Renderer: %sn", renderer);
printf("OpenGL version supported %sn", version);
return true;
}
std::string string_format(const std::string fmt, ...) {
int size = 100;
std::string str;
va_list ap;
while (1) {
str.resize(size);
va_start(ap, fmt);
int n = vsnprintf((char *)str.c_str(), size, fmt.c_str(), ap);
va_end(ap);
if (n > -1 && n < size) {
str.resize(n);
return str;
}
if (n > -1)
size = n + 1;
else
size *= 2;
}
return str;
}
int main(int argc, char* argv[])
{
srand(9); // constant seed, for deterministic results
unsigned long frame_count = 0;
GLFWwindow* window;
init(&window);
// An array of 3 vectors which represents 3 vertices
static const GLfloat g_vertex_buffer_data[] = {
-1.0f, -1.0f, 0.0f,
1.0f, -1.0f, 0.0f,
0.0f, 1.0f, 0.0f,
};
GLuint vbo;
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
// acclocate GPU memory and copy data
glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW);
unsigned int vao = 0;
glGenVertexArrays (1, &vao);
glBindVertexArray (vao);
glEnableVertexAttribArray (0);
glBindBuffer (GL_ARRAY_BUFFER, vbo);
glVertexAttribPointer (0, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Create and compile our GLSL program from the shaders
GLuint programID = LoadShaders( "1.vert", "1.frag" );
// Use our shader
glUseProgram(programID);
GLint locPosition = glGetAttribLocation(programID, "vertex");
assert(locPosition != -1);
glm::mat4 world(1.0f);
GLint locWorld = glGetUniformLocation(programID, "gWorld");
assert(locWorld != -1 && "Error getting address (was it optimized out?)!");
glUniformMatrix4fv(locWorld, 1, GL_FALSE, glm::value_ptr(world));
GLenum err = glGetError();
GLint loc = glGetUniformLocation(programID, "time");
assert(loc != -1 && "Error getting uniform address (was it optimized out?)!");
bool isRunning = true;
while (isRunning)
{
static float time = 0.0f;
static float oldTime = 0.0f;
static float fpsLastUpdateTime = 0.0f;
oldTime = time;
time = (float)glfwGetTime();
static std::string fps;
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram (programID);
glUniform1f(loc, time);
glBindVertexArray (vao);
glDrawArrays (GL_TRIANGLES, 0, 3);
glfwSwapBuffers(window);
glfwPollEvents();
isRunning = !glfwWindowShouldClose(window);
float dT = time-oldTime;
if (time-fpsLastUpdateTime > 0.5)
{
static const char* fmt = "frame rate: %.1f frames per second";
glfwSetWindowTitle(window, string_format(fmt, 1.0f/(dT)).c_str());
fpsLastUpdateTime = time;
}
}
glfwDestroyWindow(window);
glfwTerminate();
return 0;
}
////////////////////////////////////////
// 1.frag
////////////////////////////////////////
#version 330 core
// Ouput data
out vec3 color;
void main()
{
// Output color = red
color = vec3(1,0,0);
}
//////////////////////////////////////////////
// 1.vert
//////////////////////////////////////////////
#version 330 core
// Input vertex data, different for all executions of this shader.
in vec3 vertex;
uniform mat4 gWorld;
uniform float time;
void main()
{
gl_Position = gWorld * vec4(vertex, 1.0f);
gl_Position.x += sin(time);
gl_Position.y += cos(time)/2.0f;
gl_Position.w = 1.0;
}
好的。我回到家，做了更多的测试。
首先我试图禁用V-Sync，但我做不到！我不得不禁用windows的桌面效果（Aero）才能做到这一点，瞧，Aero被禁用后，口吃就消失了（打开了V-Sync）。
然后我在关闭V-Sync的情况下进行了测试，当然，我得到了更高的帧速率，偶尔会出现预期的撕裂。
然后我在全屏幕上进行了测试。有Aero和没有Aero的渲染都很流畅。
我找不到其他有同样问题的人。你认为这是GLFW3的错误吗？驱动程序/硬件问题（我有最新驱动程序的GTS450）？
谢谢大家的回答。我学到了很多，但我的问题仍未解决。
这是一个奇怪的Windows dwm（桌面窗口管理器）组合模式和glfwSwapBuffers()交互问题。我还没有找到问题的根源。但你可以通过以下操作之一来解决口吃问题：
- 进入全屏
- 禁用dwm窗口合成（请参阅我对线性移动断断续续的回答）
- 启用多重采样：
glfwWindowHint(GLFW_SAMPLES, 4);
如果没有看到这个结结巴巴的问题，很难说出问题是什么。但你的程序给人的第一印象是好的。
所以我想你会观察到一个帧偶尔会显示两次。导致非常轻微的口吃。当您尝试使用vsync在60Hz监视器上输出60帧时，通常会发生这种情况
在这样的设置中，你不能错过一个vsync周期，否则你会看到一个停顿，因为帧显示了两次
另一方面，几乎不可能保证这一点，因为windows平台上的调度器会将线程调度15毫秒（我不知道这个值的正确值）
因此，优先级较高的线程可能会使用CPU，而您的呈现线程无法及时将缓冲区交换为新帧。当你增加值时，例如120赫兹显示器上的120帧，你会更频繁地看到这些口吃
所以我不知道如何在windows平台上防止这种情况。但如果有人知道，我也很乐意知道。
如果不可视化您的问题，很难判断，但除非我们谈论的是一些严重的口吃，否则这很少是渲染问题。程序中的运动/物理由CPU处理。实现动画的方式完全取决于CPU。
这意味着：
假设你在每个CPU周期内旋转你的三角形一个固定的量。这在很大程度上取决于CPU周期完成所需的时间。cpu工作负载之类的事情可能会对屏幕结果产生巨大影响（但不一定）。甚至不需要占用大量的CPU就可以注意到差异。所需要的只是一个后台进程来唤醒和查询更新。这可能会导致一个"尖峰"，可以观察到它是动画流中的一个微小暂停（由于CPU可能在动画周期中造成的微小延迟）。这可以解释为口吃。
现在了解了以上内容，有几种方法可以解决你的问题（但在我看来，不值得为你试图做的事情投资）。您需要找到一种方法来获得一致的动画步骤（具有较小的变化余地）。
这是一篇值得探索的好文章：http://gafferongames.com/game-physics/fix-your-timestep/
最终，上面实现的大多数方法将产生更好的渲染流。但仍然不是所有这些都能保证物理渲染的精度。在我自己还没有尝试的情况下，我想说的是，一个人必须在他/她的渲染过程中实现插值，以确保绘制尽可能平滑。
现在我最想向大家解释的是，口吃通常是由CPU引起的，因为它直接干扰了你处理物理的方式。但总的来说，利用时间处理物理和在渲染周期内进行插值绝对是一个值得探索的话题。
相关文章：
- OpenGL - 在抛出"__gnu_cxx：：recursive_init_error"实例后终止调用？
- 了解 GLM- openGL 中的相机转换
- 如何在全屏模式下(在OpenGL中）使背景透明
- 为什么我不能使用 EGL 创建无头 OpenGl 上下文？
- OpenGL大的3D纹理(>2GB）非常慢
- OpenGl glm rotate
- C++atioglxx.pdb未加载错误glBufferData OpenGL
- OpenGL在启用深度测试时不会丢弃我的碎片
- OpenGL相机和相机空间转型的困惑
- OpenGL将纹理四边形渲染为(0,0）
- OpenGL 和 GLM 矩阵无法正确扩展，总是按比例缩小
- 发布旋转矩阵(openGL/glm）
- 如何在Visual Basic中使用矩形函数OpenGL绘制矩形
- 无法使用VAO和EBO(openGL）绘制多个对象
- 为什么我的点没有在 OpenGL 中绘制鼠标所在的位置?
- OpenGL 16 位模板缓冲区?
- 将QOpenGLWidget子类转换为使用Metal而不是OpenGL的子类是否可行?
- 在顶点着色器中使用 OpenGl 的未声明标识符，我在顶点着色器中绘制三角形时遇到问题
- 在 openGL 中多次绑定缓冲区
- 奇怪的opengl渲染断断续续
