C++ Can'；用Opengl绘制三角形_C++_Opengl_Shader_Fragment Shader_Vertex Shader

C++ Can'；用Opengl绘制三角形

c++ opengl

C++ Can'；用Opengl绘制三角形,c++,opengl,shader,fragment-shader,vertex-shader,C++,Opengl,Shader,Fragment Shader,Vertex Shader,在这段代码中，我想使用openGL在蓝色背景上绘制一个简单的三角形，但是当我编译和运行代码时，只有一个蓝色背景的窗口出现（没有应该绘制的白色三角形），iam使用Xcode 我的代码 #include <iostream> #include <string> #include <GLUT/glut.h> #include <OpenGL/gl3.h> #include <fstream> using namespace std; //

在这段代码中，我想使用openGL在蓝色背景上绘制一个简单的三角形，但是当我编译和运行代码时，只有一个蓝色背景的窗口出现（没有应该绘制的白色三角形），iam使用Xcode

我的代码

#include <iostream>
#include <string>
#include <GLUT/glut.h>
#include <OpenGL/gl3.h>
#include <fstream>

using namespace std;

// VAO & VBO objects
GLuint VBO;
GLuint VAO;

void display();

// vertex Data (position)
float vertex[] = {-1.0, 0.0 , 1.0,
                   0.0, 1.0 , 0.0,
                   0.0, 0.0 , 0.0 };

GLuint Program;

GLuint Vshader;
GLuint Fshader;

// main program

int main (int argc, char *argv[])

{    

   glutInit(&argc, argv);
   glutInitDisplayMode(GLUT_DOUBLE);
   glutInitWindowSize(1000, 400);
   glutInitWindowPosition(100, 100);
   glutCreateWindow("My First GLUT/OpenGL Window");
   glutDisplayFunc(display);
   glutMainLoop();


   return 0;
}



// main display function 

void display()

{
// reading the vertex shader

fstream VertexS;
VertexS.open("/Users/hawbashali/Desktop/Project X/BwlbWl/BwlbWl/vertexShader");

if(VertexS.good() == false)
    cout << "Error openning the file \n";
if(VertexS.bad() == true)
    cout << "Read/writing error on i/o operation \n";
if (VertexS.fail() == true)
    cout <<"Logical error on i/o operation \n";

VertexS.seekg(0,ios::end);
int size =  (int)VertexS.tellg();
VertexS.clear();
VertexS.seekg(0,ios::beg);

char* vBuffer = new (nothrow) char[size];

VertexS.read(vBuffer,size);

VertexS.close();



// reading fragment shader

fstream FragS;
FragS.open("/Users/hawbashali/Desktop/Project X/BwlbWl/BwlbWl/fragmentShader");

if(FragS.good() == false)
    cout << "Error openning the file \n";
if(FragS.bad() == true)
    cout << "Read/writing error on i/o operation \n";
if (FragS.fail() == true)
    cout <<"Logical error on i/o operation \n";

FragS.seekg(0,ios::end);
int size2 =  (int)FragS.tellg();
FragS.clear();
FragS.seekg(0,ios::beg);

char* fBuffer = new (nothrow) char[size2];

FragS.read(fBuffer,size2);

FragS.close();


// creating shaders

Vshader = glCreateShader(GL_VERTEX_SHADER);
Fshader = glCreateShader(GL_FRAGMENT_SHADER);

GLint x = size;
GLint y = size2;


glShaderSource(Vshader, 1,(const char**)&vBuffer, &x);
glShaderSource(Fshader, 1, (const char**)&fBuffer, &y);

glCompileShader(Vshader);
glCompileShader(Fshader);

Program = glCreateProgram();

glAttachShader(Program, Vshader);
glAttachShader(Program, Fshader);

glLinkProgram(Program);

glUseProgram(Program);



glClearColor(0, 0, 1,1);
glClear(GL_COLOR_BUFFER_BIT);

glGenBuffers(1,&VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER,9 *sizeof(vertex),vertex, GL_STATIC_DRAW);

glEnableVertexAttribArray(0);

glVertexAttribPointer(0, 3,GL_FLOAT, GL_TRUE, 0, 0);

// Drawing the triangle
glDrawArrays(GL_TRIANGLES, 0, 3);

glDisableVertexAttribArray(0);

glutSwapBuffers();

glDeleteShader(Vshader);
glDeleteShader(Fshader);

delete [] vBuffer;
delete [] fBuffer;

};

片段着色器

#version 320 core
out vec4 fColor;
void
main()
{
  fColor = vec4(0.0, 0.0, 1.0, 1.0);
}

你试图在蓝色背景上画一个蓝色三角形。您必须拨出对比度才能看到：）

把其中一个做成不同的颜色，比如红色

你还：

失踪
不请求核心上下文
使用

试试这个：

#include <GL/glew.h>
#include <GL/freeglut.h>
#include <vector>
#include <iostream>

struct Program
{
    static GLuint Load( const char* vert, const char* geom, const char* frag )
    {
        GLuint prog = glCreateProgram();
        if( vert ) AttachShader( prog, GL_VERTEX_SHADER, vert );
        if( geom ) AttachShader( prog, GL_GEOMETRY_SHADER, geom );
        if( frag ) AttachShader( prog, GL_FRAGMENT_SHADER, frag );
        glLinkProgram( prog );
        CheckStatus( prog );
        return prog;
    }

private:
    static void CheckStatus( GLuint obj )
    {
        GLint status = GL_FALSE, len = 10;
        if( glIsShader(obj) )   glGetShaderiv( obj, GL_COMPILE_STATUS, &status );
        if( glIsProgram(obj) )  glGetProgramiv( obj, GL_LINK_STATUS, &status );
        if( status == GL_TRUE ) return;
        if( glIsShader(obj) )   glGetShaderiv( obj, GL_INFO_LOG_LENGTH, &len );
        if( glIsProgram(obj) )  glGetProgramiv( obj, GL_INFO_LOG_LENGTH, &len );
        std::vector< char > log( len, 'X' );
        if( glIsShader(obj) )   glGetShaderInfoLog( obj, len, NULL, &log[0] );
        if( glIsProgram(obj) )  glGetProgramInfoLog( obj, len, NULL, &log[0] );
        std::cerr << &log[0] << std::endl;
        exit( -1 );
    }

    static void AttachShader( GLuint program, GLenum type, const char* src )
    {
        GLuint shader = glCreateShader( type );
        glShaderSource( shader, 1, &src, NULL );
        glCompileShader( shader );
        CheckStatus( shader );
        glAttachShader( program, shader );
        glDeleteShader( shader );
    }
};

#define GLSL(version, shader) "#version " #version "\n" #shader

const char* vert = GLSL
( 
    150 core,
    layout(location = 0) in vec4 vPosition;
    void
    main()
    {
        gl_Position = vPosition;
    }
);

const char* frag = GLSL
( 
    150 core,
    out vec4 fColor;
    void
    main()
    {
        fColor = vec4(1.0, 0.0, 0.0, 1.0);
    }
);

// VAO & VBO objects
GLuint VAO;
GLuint VBO;
GLuint prog;
void init()
{
    // vertex Data (position)
    float vertex[] = { -1.0, -1.0 , 0.0,
                        1.0, -1.0 , 0.0,
                        0.0,  1.0 , 0.0 };

    glGenVertexArrays( 1, &VAO );
    glBindVertexArray( VAO );

    glGenBuffers(1,&VBO);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, 9 * sizeof(vertex), vertex, GL_STATIC_DRAW);

    prog = Program::Load( vert, NULL, frag );
    glUseProgram( prog );

    glEnableVertexAttribArray(0);
    glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, 0, 0 );
}

void display()
{
    glClearColor(0, 0, 1,1);
    glClear(GL_COLOR_BUFFER_BIT);

    // Drawing the triangle
    glDrawArrays(GL_TRIANGLES, 0, 3);
    glutSwapBuffers();
}

int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode( GLUT_RGBA | GLUT_DOUBLE );
    glutInitWindowSize(1000, 400);
    glutInitWindowPosition(100, 100);
    glutInitContextVersion(3, 2);
    glutInitContextProfile(GLUT_CORE_PROFILE);
    glutCreateWindow("My First GLUT/OpenGL Window");

    glewExperimental = GL_TRUE;
    if( GLEW_OK != glewInit() )
        return -1;

    init();

    glutDisplayFunc(display);
    glutMainLoop();
    return 0;
}

#包括
#包括
#包括
#包括
结构程序
{
静态粘合负载（常量字符*垂直，常量字符*几何，常量字符*框架）
{
GLuint prog=glCreateProgram（）；
if（vert）附加着色器（prog，GL_VERTEX_着色器，vert）；
if（geom）AttachShader（prog，GL_GEOMETRY_SHADER，geom）；
if（frag）附加着色器（prog，GL_FRAGMENT_着色器，frag）；
GLLINK计划（prog）；
检查状态（prog）；
返回程序；
}
私人：
静态无效检查状态（GLuint obj）
{
闪烁状态=GLU FALSE，len=10；
if（glishader（obj））glGetShaderiv（obj、GL\u编译状态和状态）；
if（glIsProgram（obj））glGetProgramiv（obj、GL链接状态和状态）；
if（status==GL_TRUE）返回；
if（glishader（obj））glGetShaderiv（obj，GL\u INFO\u LOG\u LENGTH，&len）；
if（glIsProgram（obj））glGetProgramiv（obj、GL\u INFO\u LOG\u LENGTH和len）；
标准：：向量log（len，'X'）；
if（glishader（obj））glGetShaderInfoLog（obj、len、NULL和log[0]）；
if（glIsProgram（obj））glGetProgramInfoLog（obj，len，NULL，&log[0]）；
标准：cerr
您正试图在蓝色背景上绘制一个蓝色三角形。您必须调整对比度才能看到：）
把其中一个做成不同的颜色，比如红色
你还：

失踪
不请求核心上下文
使用

试试这个：
#include <GL/glew.h>
#include <GL/freeglut.h>
#include <vector>
#include <iostream>

struct Program
{
    static GLuint Load( const char* vert, const char* geom, const char* frag )
    {
        GLuint prog = glCreateProgram();
        if( vert ) AttachShader( prog, GL_VERTEX_SHADER, vert );
        if( geom ) AttachShader( prog, GL_GEOMETRY_SHADER, geom );
        if( frag ) AttachShader( prog, GL_FRAGMENT_SHADER, frag );
        glLinkProgram( prog );
        CheckStatus( prog );
        return prog;
    }

private:
    static void CheckStatus( GLuint obj )
    {
        GLint status = GL_FALSE, len = 10;
        if( glIsShader(obj) )   glGetShaderiv( obj, GL_COMPILE_STATUS, &status );
        if( glIsProgram(obj) )  glGetProgramiv( obj, GL_LINK_STATUS, &status );
        if( status == GL_TRUE ) return;
        if( glIsShader(obj) )   glGetShaderiv( obj, GL_INFO_LOG_LENGTH, &len );
        if( glIsProgram(obj) )  glGetProgramiv( obj, GL_INFO_LOG_LENGTH, &len );
        std::vector< char > log( len, 'X' );
        if( glIsShader(obj) )   glGetShaderInfoLog( obj, len, NULL, &log[0] );
        if( glIsProgram(obj) )  glGetProgramInfoLog( obj, len, NULL, &log[0] );
        std::cerr << &log[0] << std::endl;
        exit( -1 );
    }

    static void AttachShader( GLuint program, GLenum type, const char* src )
    {
        GLuint shader = glCreateShader( type );
        glShaderSource( shader, 1, &src, NULL );
        glCompileShader( shader );
        CheckStatus( shader );
        glAttachShader( program, shader );
        glDeleteShader( shader );
    }
};

#define GLSL(version, shader) "#version " #version "\n" #shader

const char* vert = GLSL
( 
    150 core,
    layout(location = 0) in vec4 vPosition;
    void
    main()
    {
        gl_Position = vPosition;
    }
);

const char* frag = GLSL
( 
    150 core,
    out vec4 fColor;
    void
    main()
    {
        fColor = vec4(1.0, 0.0, 0.0, 1.0);
    }
);

// VAO & VBO objects
GLuint VAO;
GLuint VBO;
GLuint prog;
void init()
{
    // vertex Data (position)
    float vertex[] = { -1.0, -1.0 , 0.0,
                        1.0, -1.0 , 0.0,
                        0.0,  1.0 , 0.0 };

    glGenVertexArrays( 1, &VAO );
    glBindVertexArray( VAO );

    glGenBuffers(1,&VBO);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, 9 * sizeof(vertex), vertex, GL_STATIC_DRAW);

    prog = Program::Load( vert, NULL, frag );
    glUseProgram( prog );

    glEnableVertexAttribArray(0);
    glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, 0, 0 );
}

void display()
{
    glClearColor(0, 0, 1,1);
    glClear(GL_COLOR_BUFFER_BIT);

    // Drawing the triangle
    glDrawArrays(GL_TRIANGLES, 0, 3);
    glutSwapBuffers();
}

int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode( GLUT_RGBA | GLUT_DOUBLE );
    glutInitWindowSize(1000, 400);
    glutInitWindowPosition(100, 100);
    glutInitContextVersion(3, 2);
    glutInitContextProfile(GLUT_CORE_PROFILE);
    glutCreateWindow("My First GLUT/OpenGL Window");

    glewExperimental = GL_TRUE;
    if( GLEW_OK != glewInit() )
        return -1;

    init();

    glutDisplayFunc(display);
    glutMainLoop();
    return 0;
}

#包括
#包括
#包括
#包括
结构程序
{
静态粘合负载（常量字符*垂直，常量字符*几何，常量字符*框架）
{
GLuint prog=glCreateProgram（）；
if（vert）附加着色器（prog，GL_VERTEX_着色器，vert）；
if（geom）AttachShader（prog，GL_GEOMETRY_SHADER，geom）；
if（frag）附加着色器（prog，GL_FRAGMENT_着色器，frag）；
GLLINK计划（prog）；
检查状态（prog）；
返回程序；
}
私人：
静态无效检查状态（GLuint obj）
{
闪烁状态=GLU FALSE，len=10；
if（glishader（obj））glGetShaderiv（obj、GL\u编译状态和状态）；
if（glIsProgram（obj））glGetProgramiv（obj、GL链接状态和状态）；
if（status==GL_TRUE）返回；
if（glishader（obj））glGetShaderiv（obj，GL\u INFO\u LOG\u LENGTH，&len）；
if（glIsProgram（obj））glGetProgramiv（obj、GL\u INFO\u LOG\u LENGTH和len）；
标准：：向量log（len，'X'）；
if（glishader（obj））glGetShaderInfoLog（obj、len、NULL和log[0]）；
if（glIsProgram（obj））glGetProgramInfoLog（obj，len，NULL，&log[0]）；
std:：cerr您在以下行中提供了无效的缓冲区大小：
glBufferData(GL_ARRAY_BUFFER, 9 * sizeof(vertex), vertex, GL_STATIC_DRAW);

因为sizeof（vertex）
应该返回数组的总大小（例如36）而不是底层类型，因此无需乘以9。如果仍要使用乘法，请尝试以下操作：
9 * sizeof(float)

我必须把它写下来……你应该像genpfault的回答那样分开初始化和绘制循环。
你在下面的行中提供了无效的缓冲区大小：
glBufferData(GL_ARRAY_BUFFER, 9 * sizeof(vertex), vertex, GL_STATIC_DRAW);

因为sizeof（vertex）
应该返回数组的总大小（例如36）而不是底层类型，因此无需乘以9。如果仍要使用乘法，请尝试以下操作：
9 * sizeof(float)

我必须写下来……你应该像genpfault的回答那样分离初始化和绘制周期。
你到底打算如何在OSX上使用#version 430 core
？@genpfault好吧，现在我学了很辛苦，即使我把它改回#version 320，结果都是一样的。你到底打算如何使用#version 430 core
在OSX上？@genpfault好吧，现在我学的很辛苦，即使我把它改回#version 320，结果还是一样..谢谢你的回复，但这并没有解决问题我试过代码它工作得很好，但事实是它不使用VBO或VAO，我想使用它们，所以我对d很熟悉在opengl中使用不同的绘图方式，虽然我修改了代码，使其使用VBO，但它仍然使用背景色，您有什么进一步的建议吗？我真的需要帮助。我发布的程序是如何在您的系统上失败的？像以前一样缺少三角形？我使用xcode进行编码，而xcode使用glut库而不是freeglut（windows实现），我的代码给出了glutInitContextVersion（3，2）；
glutInitContextProfile（GLUT\u核心配置文件）的错误
错误消息未声明标识符的使用我认为这是特定于freeglut not glut本身的，当我注释掉这些行时，我得到以下错误错误：0:1:''：版本“150”不受支持错误：0:1:''：语法错误#版本错误：0:2:'布局]：语法错误语法错误听起来好像您没有将着色器重写为conform to#version 120
。请参见编辑。布局在GLSL 1.20中不受支持。因此您必须使用GLGetAttriblation（）
查询着色器程序，而不是通过布局强制定位。感谢您的回复，但这并没有解决问题。我尝试了代码，它工作得非常好，但事实是它不使用VBO或VAO，我想使用它们，因此我熟悉opengl中的不同绘制方式，尽管我修改了t代码，所以它使用VBO，但它仍然是