从 C 矩阵到现代 OpenGL 中的纹理？

Question

问题

我正在尝试使用 OpenGL 在 C 中编写一个简单的程序，这将允许“绘制”一个 2D C 数组（ int ** 3 位整数）。

目前（我还没有，远非如此:)）我正在学习如何将一个 32 位签名整数数组发送到 GPU 并以某种方式显示它。

我正在尝试在现代 OpenGL 中执行此操作。

我的方法（两天前我刚开始学习这些主题，请耐心等待）：

1. 几何数据由四个顶点 ( vertices ) 组成，用于定义基于两个三角形的矩形（通过使用索引 ( indices ) 选取顶点来定义）。 vertices数据也与 2D 纹理坐标交错（用于着色器中的纹理采样）。
2. 我进行 VAO、VBO 和 EBO 的生成和绑定，以获取从 RAM 到 VRAM 的顶点数据。
3. 然后，我使用glTexImage2D()创建一个 2D 纹理，内部格式等于GL_R32I ，因为我的 C 数组的类型是int ** 。 我不太确定format和type参数，但我已将它们分别设置为GL_RED_INTEGER和GL_UNSIGNED_INT 。
4. 在片段着色器中，我试图通过执行类似texture(texture1, TexCoord).r类的操作来“读取”原始整数，但可能这是不对的......还尝试将红色组件转换为浮动：（ (float) texture(texture1, TexCoord).r但也不起作用。 只是为了让您放心，可能代码会做正确的事情，只留下FragColor = vec4(1.0f, 0.8f, 0.2f, 1.0f); 在片段着色器中确实显示了该颜色，这意味着我得到了一个用该颜色填充 window 的矩形。 所以只有当我开始摆弄纹理时，我才会得到黑屏或青色 RGB: (0, 1.0, 1.0, 1.0) 。

注意：我的 C 数组被命名为plane ，现在它被一个0值的左块和一个1 s 的右块填充。

现在，如果我可以在片段着色器中硬编码一个 if 语句，将 32 位plane中的0和1着色到任何其他两个 colors 中，我会很高兴。 然后我想我可以继续在调色板中包含一维纹理......就像在这里所做的那样。

代码

pixel.h

#ifndef PIXEL_H
#define PIXEL_H

/* 
  To make sure there will be no header conflicts, you can define
  GLFW_INCLUDE_NONE before the GLFW header to explicitly disable
  inclusion of the development environment header. This also allows
  the two headers to be included in any order. 
*/
#define GLFW_INCLUDE_NONE

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <plane.h>
#include <utils.h>
#include <stdlib.h>
#include <stdio.h>

#endif

pixel.c

#include <pixel.h>

const char *vertexShaderSource = "#version 330 core\n"
"layout (location = 0) in vec3 aPos;\n"
"layout (location = 1) in vec2 aTexCoord;\n"
"out vec2 TexCoord;\n"
"void main()\n"
"{\n"
"   gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
"   TexCoord = vec2(aTexCoord.x, aTexCoord.y);\n"
"}\0";
const char *fragmentShaderSource = "#version 330 core\n"
"out vec4 FragColor;\n"
"in vec2 TexCoord;\n"
"uniform isampler2D texture1;\n"
"void main()\n"
"{\n"
"   FragColor = vec4(1.0f, 0.8f, 0.2f, 1.0f);\n"
"   //FragColor = vec4(texture(texture1, TexCoord).r, 1.0f, 1.0f, 1.0f);\n"
"}\n\0";

int main(void)
{
  
  // Window width and height.
  const unsigned int width = 20;
  const unsigned int height = 10;
  
  // Before you can use most GLFW functions, the library must be initialized.
  if (!glfwInit()) {
    printf("Could not initialise GLFW library!");
    exit(EXIT_FAILURE);
  }
  
  /*
   * By default, the OpenGL context GLFW creates may have any version.
   * You can require a minimum OpenGL version by setting the
   * GLFW_CONTEXT_VERSION_MAJOR and GLFW_CONTEXT_VERSION_MINOR hints
   * before creation. If the required minimum version is not supported
   * on the machine, context (and window) creation fails.
   */
  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
  
  // Create a GLFW window.
  GLFWwindow* window = glfwCreateWindow(width, height, "pixel example", NULL, NULL);
  if (!window)
  {
    printf("Window or OpenGL context creation failed!\n");
    glfwTerminate();
    exit(EXIT_FAILURE);
  }
  
  // Before you can use the OpenGL API, you must have a current OpenGL context.
  glfwMakeContextCurrent(window);
  
  /* 
   * If you are using an extension loader library to access modern OpenGL
   * then this is when to initialize it, as the loader needs a current
   * context to load from. This example uses glad, but the same rule applies
   * to all such libraries.
   */
  gladLoadGL();
  
  /*
   * Set a framebuffer size callback to update the viewport when
   * the window size changes.
   */
  glfwSetFramebufferSizeCallback(window, fb);
  
  /*
   * 
   * Data to be drawn.
   * 
   */
  int **plane = NewPlane(width, height);
  PLANE(width, height, if (i < width / 2) plane[i][j] = 0; else plane[i][j] = 1;)
  //plane[width/2][height/2] = 1;
  //PLANE(width, height, printf("%d %d %d\n", i, j, plane[i][j]);)
  printf("size of int: %ld bytes\n", sizeof(int));
  
  // build and compile our shader program
  // ------------------------------------
  // vertex shader
  unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
  glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
  glCompileShader(vertexShader);
  // check for shader compile errors
  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%s\n", infoLog);
  }
  // fragment shader
  unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
  glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
  glCompileShader(fragmentShader);
  // check for shader compile errors
  glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
  if (!success)
  {
    glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
  printf("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n%s\n", infoLog);
  }
  // link shaders
  unsigned int shaderProgram = glCreateProgram();
  glAttachShader(shaderProgram, vertexShader);
  glAttachShader(shaderProgram, fragmentShader);
  glLinkProgram(shaderProgram);
  // check for linking errors
  glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
  if (!success) {
    glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
    printf("ERROR::SHADER::PROGRAM::LINKING_FAILED%s\n", infoLog);
  }
  glDeleteShader(vertexShader);
  glDeleteShader(fragmentShader);
  
  
  // float vertices[] = {
  //    1.0f,  1.0f, 0.0f, // top right
  //    1.0f, -1.0f, 0.0f, // bottom right
  //   -1.0f, -1.0f, 0.0f, // bottom left
  //   -1.0f,  1.0f, 0.0f  // top left 
  // };
  float vertices[] = {
    // positions          // texture coords
     1.0f,  1.0f, 0.0f,   1.0f, 1.0f, // top right
     1.0f, -1.0f, 0.0f,   1.0f, 0.0f, // bottom right
    -1.0f, -1.0f, 0.0f,   0.0f, 0.0f, // bottom left
    -1.0f,  1.0f, 0.0f,   0.0f, 1.0f  // top left 
  };
  
  unsigned int indices[] = {
    // note that we start from 0!
    0, 1, 3, // first triangle
    1, 2, 3 // second triangle
  };
  
  unsigned int VBO, VAO, EBO;
  glGenVertexArrays(1, &VAO);
  printf("VAO: %d\n", VAO);
  glGenBuffers(1, &VBO);
  printf("VBO: %d\n", VBO);
  glGenBuffers(1, &EBO);
  printf("EBO: %d\n", EBO);
  // bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
  glBindVertexArray(VAO);
  
  glBindBuffer(GL_ARRAY_BUFFER, VBO);
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
  
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
  
  // glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
  // glEnableVertexAttribArray(0);
  // position attribute
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
  glEnableVertexAttribArray(0);
  // texture coord attribute
  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
  glEnableVertexAttribArray(1);
  
  
  // note that this is allowed, the call to glVertexAttribPointer registered VBO as the vertex attribute's bound vertex buffer object so afterwards we can safely unbind
  glBindBuffer(GL_ARRAY_BUFFER, 0); 
  
  // remember: do NOT unbind the EBO while a VAO is active as the bound element buffer object IS stored in the VAO; keep the EBO bound.
  //glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
  
  // You can unbind the VAO afterwards so other VAO calls won't accidentally modify this VAO, but this rarely happens. Modifying other
  // VAOs requires a call to glBindVertexArray anyways so we generally don't unbind VAOs (nor VBOs) when it's not directly necessary.
  glBindVertexArray(0); 
  
  // uncomment this call to draw in wireframe polygons.
  //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  
  unsigned int texture;
  glGenTextures(1, &texture);
  glBindTexture(GL_TEXTURE_2D, texture);
  if (plane) {
    glTexImage2D(GL_TEXTURE_2D, 0, GL_R32I, width, height, 0, GL_RED_INTEGER, GL_UNSIGNED_INT, plane);
  }
  
  /*
   * 
   * Main loop
   * 
   */
  
  while (!glfwWindowShouldClose(window))
  {
    
    // Check if Escape is pressed and signal to close the window.
    input(window);
    
    // The glClearColor function is a state-setting function
    glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
    
    // The glClear is a state-using function in that it uses the
    // current state to retrieve the clearing color from.
    glClear(GL_COLOR_BUFFER_BIT);
    
    // Rendering goes here.
    glUseProgram(shaderProgram);
    glBindVertexArray(VAO); // seeing as we only have a single VAO there's no need to bind it every time, but we'll do so to keep things a bit more organized
    glDrawArrays(GL_TRIANGLES, 0, 6);
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
    
    glfwSwapBuffers(window);
    glfwPollEvents();
  }
  
  glfwDestroyWindow(window);
  
  glfwTerminate();
  exit(EXIT_SUCCESS);
}

plane.h

#ifndef PLANE_H
#define PLANE_H

#include <stdlib.h>
#include <stdio.h>

#define PLANE(width, height, A) {int i,j,_ii,_jj;for(i=0,_ii=width;i<_ii;i++)for(j=0,_jj=height;j<_jj;j++){A};}

int **NewPlane(int, int);

#endif

plane.c

#include <plane.h>

int **NewPlane(int width,int height)
{
  int **a;
  int i,j;
  
  a = (int **)calloc((size_t)(width),sizeof(int *));
  if (a == NULL) {
    fprintf(stderr,"NewPlane: error in memory allocation\n");
    exit(EXIT_FAILURE);
  }
  a[0] = (int *)calloc((size_t)((width)*(height)),sizeof(int));
  if (a[0] == NULL) {
    fprintf(stderr,"NewPlane: error in memory allocation\n");
    exit(EXIT_FAILURE);
  }
  for (i=1,j=width; i < j; i++)
    a[i] = a[i-1] + height;
  
  return a;
}

Answer 1

texture是重载的 function。 如果您使用texture查找isampler2D ，则返回值的类型为ivec4 ：

uniform isampler2D texture1;

void main() 
{
    int value = texture(texture1, TexCoord).r;

    // [...]
} 

由于内部数据类型为GL_R32I ，因此返回值在 -2,147,483,648 到 2,147,483,647 的范围内。 但是，默认帧缓冲区的颜色通道必须在 [0.0, 1.0] 范围内。 因此，您需要缩放积分值（ maxValue应该是纹理中的最大值）：

FragColor = vec4(float(value) / maxValue, 1.0f, 1.0f, 1.0f);

Answer 2

我现在可以正常工作了，有一些事情需要修复。

1. 正如@Rabbid76 所指出的，将 value 中的整value （在片段着色器代码中）转换为[0, 1]范围内的浮点数是一个重要的变化。
2. 此外，正如@tstanisl 所指出的，传递给glTexImage2D()的数据需要在 memory 中是连续的，因此，在我的情况下，更改对glTexImage2D(..., plane[0])的调用也很重要。
3. 最后，我错过了：

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

如GL_R32I TexImage2D 未正确上传中所述。