C++ 坐标值的作用就好像它们要大得多

我试图用整数类型的坐标绘制，但失败了。然后我试着画一个简单的三角形，就像是从教程中画出来的一样。结果，屏幕的一半是三角形的颜色，另一半是

glClearColor

I set。我开始改变数值，当坐标小于

0.0000000000000 5f

（我怀疑这比

float

的精度更高）时，角点开始出现，尽管应该已经小于

1.0f

。尝试搜索没有任何结果，可能是因为我不知道正确的单词

以下是我最终得到的代码：

包括和功能我快速移动到这里：

#include <GL/glew.h>

#include <glfw3.h>

#include <unistd.h>
#include <stdio.h>

/* function that creates shader */
GLuint makeShader(const GLchar* vertexShaderSource, const GLchar* fragmentShaderSource,
                                  GLchar*& infoLog, const GLchar* geometryShaderSource = NULL)
{

    GLint isSuccess;
    infoLog = nullptr;

    GLuint vertexShaderID = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShaderID, 1, &vertexShaderSource, nullptr);
    glCompileShader(vertexShaderID);

    glGetShaderiv(vertexShaderID, GL_COMPILE_STATUS, &isSuccess);

    if(!isSuccess)
    {
        infoLog = new GLchar[1024];
        glGetShaderInfoLog(vertexShaderID, 1024, nullptr, infoLog);
        printf("Error compiling vertex shader: %s\n", infoLog);
        printf("\n%s\n\n", vertexShaderSource);
        return 0;
    }

    GLuint geometryShaderID;
    if(geometryShaderSource!=NULL){

        geometryShaderID = glCreateShader(GL_GEOMETRY_SHADER);
        glShaderSource(geometryShaderID, 1, &geometryShaderSource, nullptr);
        glCompileShader(geometryShaderID);

        glGetShaderiv(geometryShaderID, GL_COMPILE_STATUS, &isSuccess);

        if(!isSuccess)
        {
            infoLog = new GLchar[1024];
            glGetShaderInfoLog(geometryShaderID, 1024, nullptr, infoLog);
            printf("Error compiling geometry shader: %s\n", infoLog);
            printf("\n%s\n\n", geometryShaderSource);
            return 0;
        }
    }

    GLuint fragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShaderID, 1, &fragmentShaderSource, nullptr);
    glCompileShader(fragmentShaderID);

    glGetShaderiv(fragmentShaderID, GL_COMPILE_STATUS, &isSuccess);

    if(!isSuccess)
    {
        infoLog = new GLchar[1024];
        glGetShaderInfoLog(fragmentShaderID, 1024, nullptr, infoLog);
        printf("Error compiling fragment shader: %s\n", infoLog);
        printf("\n%s\n\n", fragmentShaderSource);
        return 0;
    }

    GLuint shaderID = glCreateProgram();
    glAttachShader(shaderID, vertexShaderID);
    glAttachShader(shaderID, fragmentShaderID);
    if(geometryShaderSource!=NULL){
        glAttachShader(shaderID, geometryShaderID);
    }
    glLinkProgram    (shaderID);
    glValidateProgram(shaderID);

    glDeleteShader(vertexShaderID);
    glDeleteShader(fragmentShaderID);
    if(geometryShaderSource!=NULL){
        glDeleteShader(geometryShaderID);
    }

    glGetProgramiv(shaderID, GL_LINK_STATUS, &isSuccess);

    if (!isSuccess)
    {
        infoLog = new GLchar[1024];
        glGetProgramInfoLog(shaderID, 1024, nullptr, infoLog);     // Generate error as infoLog
        //std::cout << "Error " << infoLog << std::endl;  // Display
        printf("Error linking shader %s\n", infoLog);
        return 0;
    }
    return shaderID;
}

---

编译器还告诉我def文件末尾的corrupt.drective，但我怀疑它是否重要。

顶点着色器中的转换刚刚中断：

设置

w_clip=0

将意味着从概念上讲，您的点在

x、y、z

方向上无限远，GPU将把您的基本体剪裁到与查看体积的交点（仍然是有限的）

此外：

我开始改变数值，当坐标小于

0.0000000000000 5f

时，角点开始显示（我怀疑这比浮点精度更高）

---

这不是浮点数的工作方式，接近零的精度相当高，最小的非标准化单精度浮点数将是

2^（-126）

，大约是

0.00000000000000000000000000000012

，如果你进入非标准化范围，你可以进入

2^-149

。

请在更多的数据中描述你的实际问题。我不清楚你写了什么我的问题是opengl的奇怪行为。通常情况下，它会画得好像左下角的坐标为-1x-1y，右上角的坐标为1x 1y，但在这种情况下，这些值要小得多，要小几十亿倍。我想知道这件事的原因，以及避免它的方法

int main(void)
{
    GLFWwindow* window;
    float FPSlimit = 60;
    int windowSX = 800, windowSY = 600;

    /* Initialize the library */
    if (!glfwInit()){
        return -1;}

    /* Create window */
    window = glfwCreateWindow(windowSX, windowSY, "abc", NULL, NULL);
    if (!window)
    {
        printf("Failed to create window\n");
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    glfwSwapInterval(0);

    /* Initialize GLEW */
    if(glewInit()){
        printf("Failed to initialize GLEW\n");
        glfwTerminate();
        return -1;
    }

    glClearColor(0.1, 0.3f, 0.2f, 1.0f);
    double timeDeltaFPSmaintain = 0;

    GLuint vao;
    GLuint vbo;
    glGenVertexArrays(1, &vao);
    glGenBuffers(1, &vbo);

    glBindVertexArray(vao);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
    //changing normalisation to GL_TRUE didnt do anything

    float dat[] = {-0.000000000000000000024f, -0.000000000000000000024f, 0.f,
                    1.f, -1.f, 0.f,
                    0.f, 0.000000000000000000054f, 0.f};
    glBufferData(GL_ARRAY_BUFFER, 3*3*sizeof(float), dat, GL_STATIC_DRAW);

    GLchar* log;
    const GLchar* v = "#version 330 \n layout (location = 0) in vec3 pos;\n void main(){gl_Position = vec4(pos.xyz, 0);}";
    const GLchar* f = "#version 330 \n out vec4 color; void main(){color = vec4(1, 0, 0, 0);}";
    GLuint sha = makeShader(v, f, log);
    printf("%i\n", glGetError());//Shows 0

    /* Main loop: */
    while (!glfwWindowShouldClose(window))
    {
        glClear(GL_COLOR_BUFFER_BIT);
        glUseProgram(sha);
        glBindVertexArray(vao);
        glDrawArrays(GL_TRIANGLES, 0, 3);
        glfwSwapBuffers(window);

        glfwPollEvents();

        // nvidia starts to use 100% of one of CPU cores with vSync for some reason
        timeDeltaFPSmaintain = (glfwGetTime() - timeDeltaFPSmaintain)*1000000;
        if(FPSlimit>1){
            usleep(1000000/FPSlimit-unsigned(timeDeltaFPSmaintain));}
        timeDeltaFPSmaintain = glfwGetTime();
    }

    glfwTerminate();
    return 0;
}

gl_Position = vec4(pos.xyz, 0);