C++ 为什么你不在这里工作？_C++_Opengl_Pixels_Trace_Gldrawpixels

C++ 为什么你不在这里工作？

c++ opengl

C++ 为什么你不在这里工作？,c++,opengl,pixels,trace,gldrawpixels,C++,Opengl,Pixels,Trace,Gldrawpixels,这是密码。输出是一个灰色的正方形-所有的时间，无论输入是什么，它显然是错误的。我的目标是能够将所有像素存储在某个地方并显示出来，这样我就可以继续使用一个简单的光线跟踪器，而我似乎无法解决这个问题 #include <stdlib.h> #include <GL/glut.h > using namespace std; struct RGBType { float r; float g; float b; //float a; };

这是密码。输出是一个灰色的正方形-所有的时间，无论输入是什么，它显然是错误的。我的目标是能够将所有像素存储在某个地方并显示出来，这样我就可以继续使用一个简单的光线跟踪器，而我似乎无法解决这个问题

#include <stdlib.h>
#include <GL/glut.h >

using namespace std;

struct RGBType {

    float r;
    float g;
    float b;
    //float a;
};


void display(void)
{

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    RGBType *pixels = new RGBType[250*250];

    for (int x = 0; x < 250; x++) {
        for (int y = 0; y < 250; y++) {

               pixels->r = 0;
               pixels->g = 1;
               pixels->b = 1;
               //pixels->a = 200;
          }
     }


    glTexSubImage2D(GL_TEXTURE_2D,0,0,0,250,250,GL_RGB,GL_UNSIGNED_BYTE,pixels);


    //glColor3f(1.0,1.0,1.0);
    glBegin(GL_POLYGON);
        glVertex3f(0.0, 0.0, 0.0);
        glVertex3f(1.0, 0.0, 0.0);
        glVertex3f(1.0, 1.0, 0.0);
        glVertex3f(0.0, 1.0, 0.0);
    glEnd();


    glutSwapBuffers();
}

void init(void)
{
    //select clearing (background) color
    glClearColor(0.0, 0.0, 0.0, 0.0);

    //initialize viewing values 
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);
}


int main(int argc, char** argv)
{
    //Initialise GLUT with command-line parameters. 
    glutInit(&argc, argv);

    //Set Display Mode
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);

    //Set the window size
    glutInitWindowSize(250,250);

    //Set the window position
    glutInitWindowPosition(100,100);

    //Create the window
    glutCreateWindow("Ray Tracer");

    //Call init (initialise GLUT
    init();

    //Call "display" function
    glutDisplayFunc(display);

    //Enter the GLUT event loop
    glutMainLoop();

    return 0;
}

#包括
#包括
使用名称空间std；
结构RGBType{
浮子r；
浮球g；
浮球b；
//浮动a；
};
作废显示（作废）
{
glClear（GL_颜色_缓冲_位| GL_深度_缓冲_位）；
RGB类型*像素=新RGB类型[250*250]；
对于（int x=0；x<250；x++）{
对于（int y=0；y<250；y++）{
像素->r=0；
像素->g=1；
像素->b=1；
//像素->a=200；
}
}
glTexSubImage2D（GL_纹理_2D，0,0,025050，GL_RGB，GL_无符号_字节，像素）；
//GL3F（1.0,1.0,1.0）；
glBegin（GL_多边形）；
glVertex3f（0.0,0.0,0.0）；
glVertex3f（1.0,0.0,0.0）；
glVertex3f（1.0,1.0,0.0）；
glVertex3f（0.0,1.0,0.0）；
格伦德（）；
glutSwapBuffers（）；
}
void init（void）
{
//选择清除（背景）颜色
glClearColor（0.0,0.0,0.0,0.0）；
//初始化查看值
glMatrixMode（GL_投影）；
glLoadIdentity（）；
格洛托（0.0,1.0,0.0,1.0，-1.0,1.0）；
}
int main（int argc，字符**argv）
{
//使用命令行参数初始化GLUT。
glutInit（&argc，argv）；
//设置显示模式
glutInitDisplayMode（GLUT_RGB | GLUT_DOUBLE | GLUT_深度）；
//设置窗口大小
glutInitWindowSize（250250）；
//设置窗口位置
位置（100100）；
//创建窗口
创建窗口（“光线跟踪器”）；
//调用init（初始化GLUT
init（）；
//调用“显示”功能
glutDisplayFunc（显示器）；
//进入GLUT事件循环
glutMainLoop（）；
返回0；
}

您告诉OpenGL将

像素

解释为

无符号字符

的数组，按组读取它们，并将每四个像素的前三个字节用作RGB通道

不要对OpenGL撒谎。最终很少对你有用

尝试使用

GL\u FLOAT

然后首先创建一个实际的纹理对象

并绑定该纹理对象，然后再尝试向其上载数据

并为多边形指定一些纹理坐标

并在绘制多边形之前启用纹理

大概是这样的：

#include <GL/glut.h>

struct RGBType 
{
    float r;
    float g;
    float b;
};

GLuint tex = 0;
void init()
{
    RGBType pixels[ 250*250 ];

    RGBType* temp = pixels;
    for (int x = 0; x < 250; x++) 
    {
        for (int y = 0; y < 250; y++) 
        {
            temp->r = 0;
            temp->g = 1;
            temp->b = 1;
            temp++;
        }
    }

    glGenTextures( 1, &tex );
    glBindTexture( GL_TEXTURE_2D, tex );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, 250, 250, 0, GL_RGB, GL_FLOAT, NULL );
    glTexSubImage2D(GL_TEXTURE_2D,0,0,0,250,250,GL_RGB,GL_FLOAT,pixels);
}

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

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(-2, 2, -2, 2, -1, 1);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    glColor3ub( 255, 255, 255 );
    glEnable( GL_TEXTURE_2D );
    glBindTexture( GL_TEXTURE_2D, tex );
    glBegin(GL_QUADS);
    glTexCoord2i( 0, 0 );
    glVertex2i( 0, 0 );
    glTexCoord2i( 1, 0 );
    glVertex2i( 1, 0 );
    glTexCoord2i( 1, 1 );
    glVertex2i( 1, 1 );
    glTexCoord2i( 0, 1 );
    glVertex2i( 0, 1 );
    glEnd();

    glutSwapBuffers();
}

int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
    glutInitWindowSize(250,250);
    glutCreateWindow("Ray Tracer");
    init();
    glutDisplayFunc(display);
    glutMainLoop();
    return 0;
}

#包括
结构RGBType
{
浮子r；
浮球g；
浮球b；
};
GLuint-tex=0；
void init（）
{
RGB型像素[250*250]；
RGB类型*温度=像素；
对于（int x=0；x<250；x++）
{
对于（int y=0；y<250；y++）
{
温度->r=0；
温度->g=1；
温度->b=1；
temp++；
}
}
glGenTextures（1和tex）；
glBindTexture（GL_TEXTURE_2D，tex）；
glTexParameteri（GL_纹理2D、GL_纹理MAG_过滤器、GL_线性）；
glTexParameteri（GL_纹理2D、GL_纹理最小过滤器、GL_线性）；
GLTEXAGE2D（GL_纹理_2D，0，GL_RGB，250，250，0，GL_RGB，GL_浮点，NULL）；
glTexSubImage2D（GL_纹理_2D，0,0,025025050，GL_RGB，GL_浮点，像素）；
}
作废显示（作废）
{
glClearColor（0,0,0,1）；
glClear（GLU颜色缓冲位）；
glMatrixMode（GL_投影）；
glLoadIdentity（）；
格洛托（-2,2，-2,2，-1,1）；
glMatrixMode（GLU模型视图）；
glLoadIdentity（）；
glColor3ub（255、255、255）；
glEnable（GL_纹理_2D）；
glBindTexture（GL_TEXTURE_2D，tex）；
glBegin（GL_QUADS）；
glTexCoord2i（0,0）；
glVertex2i（0,0）；
glTexCoord2i（1,0）；
glVertex2i（1,0）；
glTexCoord2i（1,1）；
glVertex2i（1,1）；
glTexCoord2i（0,1）；
glVertex2i（0,1）；
格伦德（）；
glutSwapBuffers（）；
}
int main（int argc，字符**argv）
{
glutInit（&argc，argv）；
glutInitDisplayMode（GLUT_RGBA | GLUT_DOUBLE）；
glutInitWindowSize（250250）；
创建窗口（“光线跟踪器”）；
init（）；
glutDisplayFunc（显示器）；
glutMainLoop（）；
返回0；
}