字体渲染到屏幕外FBO上不起作用。 （注意：通过使用带有glTexImage2D的Freetype lib创建纹理来加载字体）

问题描述 投票：1回答：1

我有以下代码将矩形和少量文本呈现到屏幕外FBO上。然后，我尝试在默认/显示帧缓冲区中绑定纹理（附加到FBO）。我能够渲染矩形，但是字体没有渲染。我尝试调试，但到目前为止还没有。我只需要在OpenGL ES 2.0中执行此操作。

我的矩形是橙色的。文本/字体为红色。我使用Freetype lib和glTexImage2D调用为每种字体创建单独的纹理。直接在默认帧缓冲区上渲染时，我成功获得了一个橙色矩形和红色字体。但是，当我首先在屏幕外FBO上进行操作时，会出现一个红色的矩形和一些垃圾小文本（我认为是）。我正在继续调试，但是任何输入都会有所帮助。

注意：我是OpenGL的新手。

EGLSurface eglsurface;
EGLDisplay egldisplay;
EGLConfig eglconfig;
EGLContext eglcontext;
void* NativeWindow;
GLuint VBO;
FT_Face face;
unsigned int shaderProgram;
unsigned int vertexShader;
unsigned int fragmentShader;
int color_loc;

const GLuint WIDTH = 1920, HEIGHT = 1080;

EGLint Attributes[] = { EGL_RED_SIZE,        1,
                        EGL_GREEN_SIZE,      1,
                        EGL_BLUE_SIZE,       1,
                        EGL_ALPHA_SIZE,      1,
                        EGL_NONE };

EGLint contextAttributes[] = { EGL_CONTEXT_CLIENT_VERSION,
                               2,
                               EGL_NONE };

void GlInit()
{
  glViewport(0, 0, WIDTH, HEIGHT);

  const char *vertexShaderSource = 
    "attribute vec4 vertex;\n"
    "varying vec2 texcoord;\n"
    "void main()\n"
    "{\n"
    "gl_Position = vec4(vertex.xy, 0, 1);\n"
    "texcoord = vertex.zw;\n"
    "}\n";

  const char *fragmentShaderSource =
    "precision highp float;\n"
     "varying vec2 texcoord;\n"
    "uniform sampler2D s_texture;\n"
    "uniform vec4 myColor;\n"
    "void main(void) {\n"
    "gl_FragColor = vec4(1, 1, 1, texture2D(s_texture, texcoord).a) * myColor;\n"
    "}\n";

  unsigned int vertexShader;
  vertexShader = glCreateShader(GL_VERTEX_SHADER);
  glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
  glCompileShader(vertexShader);
  int  success;
  char infoLog[512];
  glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
  if(!success) {
    glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
    printf("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n");
  }

  fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
  glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
  glCompileShader(fragmentShader);
  glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
  if(!success) {
    glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
    printf("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n");
  }

  shaderProgram = glCreateProgram();
  glAttachShader(shaderProgram, vertexShader);
  glAttachShader(shaderProgram, fragmentShader);
  glLinkProgram(shaderProgram); 
  glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
  if(!success) {
    glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
    printf("ERROR::SHADER::LINKING_FAILED\n");
  }

  glGenBuffers(1, &VBO);
  glUseProgram(shaderProgram);

  //glClearDepthf(1.0f);
  //glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
  //glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  // SAGAR - Blend required for texture
  //glEnable(GL_BLEND);
  //glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

  // Get the color location in fragment shader, will fill on need
  color_loc = glGetUniformLocation(shaderProgram, "myColor");
}

void DrawRect()
{
  glBindBuffer(GL_ARRAY_BUFFER, VBO);

  int position_loc = glGetAttribLocation(shaderProgram, "vertex");
  glEnableVertexAttribArray(position_loc);
  glVertexAttribPointer(position_loc, 4, GL_FLOAT, GL_FALSE, 0, 0);

  GLfloat rectangle[4][4] = {
    -0.5f,  0.5f, 0.0f, 1.0f,
     0.5f,  0.5f, 0.0f, 1.0f,
    -0.5f, -0.5f, 0.0f, 1.0f,
     0.5f, -0.5f, 0.0f, 1.0f
  };

  glUniform4f(color_loc, 1.0f, 0.5f, 0.2f, 1.0f); // Orange

  glBufferData(GL_ARRAY_BUFFER, sizeof rectangle, rectangle, GL_DYNAMIC_DRAW);
  glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}

void render_fboTexture()
{
  int TextureLocation = glGetUniformLocation(shaderProgram, "s_texture");
  glUniform1i(TextureLocation, 0);
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

  // Draw in a small quad for testing
  GLfloat quad[4][4] = {
    {-0.5, 0.5, 0, 0},
    {0.5, 0.5, 1, 0},
    {-0.5, -0.5, 0, 1},
    {0.5, -0.5, 1, 1},
  };

  glBufferData(GL_ARRAY_BUFFER, sizeof quad, quad, GL_DYNAMIC_DRAW);
  glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}

void render_captiondata(const char* caption, float x, float y, float sx, float sy);
void RenderTexture()
{
    int TextureLocation = glGetUniformLocation(shaderProgram, "s_texture");
    glUniform1i(TextureLocation, 0);

    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

    // Set desired text color
    glUniform4f(color_loc, 0.5f, 0.0f, 0.0f, 1.0f); // Red

    FT_Library ft;
    if (FT_Init_FreeType(&ft)) {
      printf("SAGAR- Could not init FreeType Library\n");
    }

    if (FT_New_Face(ft, "./xyz.ttf", 0, &face)) {
      printf("SAGAR - Failed to load font\n");
    }
    FT_Set_Pixel_Sizes(face, 0, 48);

    GLuint texture;
    glActiveTexture(GL_TEXTURE0);
    glGenTextures(1, &texture);
    glBindTexture(GL_TEXTURE_2D, texture);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    // Calculate the scales both sides
    float sx = 2.0 / WIDTH;
    float sy = 2.0 / HEIGHT;
    float x = -0.4;
    float y = 0.3;

    render_captiondata("-- Hello OpenGL! --", x, y, sx, sy);
}

void render_captiondata(const char* caption, float x, float y, float sx, float sy)
{
  const char *p;
  for(p = caption; *p; p++) {
    if (FT_Load_Char(face, *p, FT_LOAD_RENDER)) {
        printf("SAGAR - Failed to load Glyph\n");
    }

    float x2 = x + face->glyph->bitmap_left * sx;
    float y2 = -y - face->glyph->bitmap_top * sy;
    float w = face->glyph->bitmap.width * sx;
    float h = face->glyph->bitmap.rows * sy;

    GLfloat fontVertices[4][4] = {
        {x2,     -y2    , 0, 0},
        {x2 + w, -y2    , 1, 0},
        {x2,     -y2 - h, 0, 1},
        {x2 + w, -y2 - h, 1, 1},
    };

    glTexImage2D(
      GL_TEXTURE_2D, 0, GL_ALPHA, face->glyph->bitmap.width, face->glyph->bitmap.rows, 0,
      GL_ALPHA, GL_UNSIGNED_BYTE, face->glyph->bitmap.buffer);

    glBufferData(GL_ARRAY_BUFFER, sizeof fontVertices, fontVertices, GL_DYNAMIC_DRAW);
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

    x += (face->glyph->advance.x/64) * sx;
    y += (face->glyph->advance.y/64) * sy;
  }
}

int main()
{
  EglInit();
  GlInit();

  // FBO experiment: SAGAR
  GLuint fbo;
  glGenFramebuffers(1, &fbo);
  glBindFramebuffer(GL_FRAMEBUFFER, fbo);

  GLuint texture;
  glGenTextures(1, &texture);
  glBindTexture(GL_TEXTURE_2D, texture);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1920, 1080, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
  glBindTexture(GL_TEXTURE_2D, 0);

  GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
  if (status != GL_FRAMEBUFFER_COMPLETE) {
    printf("Problem with OpenGL framebuffer : %x\n", status);
  }

  DrawRect();
  RenderTexture(); // Does not work
  glBindTexture(GL_TEXTURE_2D, 0);
  eglSwapBuffers(egldisplay, eglsurface);

  glBindFramebuffer(GL_FRAMEBUFFER, 0);
  glBindTexture(GL_TEXTURE_2D, texture);
  glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  render_fboTexture();
  glBindTexture(GL_TEXTURE_2D, 0);

  //RenderTexture(); // Directly onto default/main framebuffer works
  eglSwapBuffers(egldisplay, eglsurface);
  sleep(10);

  glDeleteShader(vertexShader);
  glDeleteShader(fragmentShader);
  glDeleteBuffers(1, &VBO);
  glDeleteProgram(shaderProgram);

  return 0;
}

egg相关的初始化。

void EglInit()
{   
  EGLint configCount;
  egldisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
  if (egldisplay == EGL_NO_DISPLAY) {
    printf("eglGetDisplay() failed: %d\n", eglGetError());
  }

  EGLint majorVersion = 0;
  EGLint minorVersion = 0;
  if (!eglInitialize(egldisplay, &majorVersion, &minorVersion)) {
   printf("eglInitialize() failed: %d\n", eglGetError());
  }

  if (!eglChooseConfig(egldisplay, Attributes, &eglconfig, 1, &configCount))
  {
    printf("eglChooseConfig failed : %d\n", eglGetError());
  }

  eglcontext = eglCreateContext(egldisplay, eglconfig, EGL_NO_CONTEXT, contextAttributes);
  if (eglcontext == EGL_NO_CONTEXT) {
    printf("eglCreateContext() failed\n");
  }

  eglsurface = eglCreateWindowSurface(egldisplay, eglconfig, NativeWindow, NULL);
  if (eglsurface == EGL_NO_SURFACE) {
    printf("eglCreateWindowSurface() failed\n");
  }

  eglMakeCurrent(egldisplay, eglsurface, eglsurface, eglcontext);
}
opengl-es-2.0 font-rendering
1个回答
1
投票

有问题。

渲染文本时启用Blending：

DrawRect();

glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
RenderTexture();
glDisable(GL_BLEND);

但是主要问题是片段着色器。片段着色器采用纹理的Alpha通道，并且颜色形成统一的颜色。 

gl_FragColor = vec4(1, 1, 1, texture2D(s_texture, texcoord).a) * myColor;

这对于渲染四边形和文本效果很好。请注意，字形存储在纹理中，其中红色绿色和蓝色为零，并且alpha通道包含字形蒙版。

您使用相同的着色器来着色帧缓冲区​​，这根本不起作用，因为要复制帧缓冲区，您将需要一个从纹理中读取颜色的着色器（您的着色器从制服中获取颜色）。例如：]]

gl_FragColor = texture2D(s_texture, texcoord);

如果要为所有图形使用1个着色器，则创建一个片段着色器，该片段着色器使用myColor的Alpha通道，将mix纹理和mix的颜色通道使用。如果为1，则从myColor中读取颜色，如果ti为0.0，则从纹理中读取颜色：
myColor
在vec4 texColor   = texture2D(s_texture, texcoord);
vec3 finalColor = mix(texColor.rgb, myColor.rgb, myColor.a);
gl_FragColor    = vec4(finalColor, texColor.a);
和DrawRect中设置颜色：
RenderTexture
void DrawRect()
{
    // [...]

    glUniform4f(color_loc, 1.0f, 0.5f, 0.2f, 1.0f); // Orange

但是在void RenderTexture()
{
    // [...]

    glUniform4f(color_loc, 0.5f, 0.0f, 0.0f, 1.0f); // Red
中将alpha通道设置为0.0：
render_fboTexture
此外，您还必须在void render_fboTexture()
{
    // [...]

    glUniform4f(color_loc, 1.0f, 1.0f, 1.0f, 0.0f); // use texture
} 
中翻转四边形的y分量纹理坐标：
render_fboTexture
最新问题
© www.soinside.com 2019 - 2024. All rights reserved.