C 在OpenGL中进行变换后获取顶点？

我有以下代码：

#include <gl/glut.h>
#include <stdio.h>


GLfloat xf, yf, win;
GLint view_w, view_h;

//auxiliary vector
GLfloat aux[6] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
GLfloat vertices[768] = { 0.0 };
//count for aux vector
int count = 0;

//Meant to be used for drawing different shapes, store the number of vertecies for each primitive
int primitives[64] = {};

//Index
int vIndex = 0;
int pIndex = 0;

bool flag = false;

//Dedraws the scene using the vertices vector
void Redisplay()
{
    glClear(GL_COLOR_BUFFER_BIT);
    glFlush();     
    int j = 0;
        int k;
        for (int i = 0; i < pIndex; i++)
        {
            glMatrixMode(GL_MODELVIEW);
            glLoadIdentity();
            glBegin(GL_TRIANGLES);
            k = j;
            for(; j < k + 2*primitives[i];j+=2)
                glVertex2f(vertices[j], vertices[j + 1]);
            glEnd();
            glFlush();

        }
}

//Store vertices in the vertices vector
void storePrimitive(GLfloat *vector, int nVertex)
{
    for (int i = 0; i < nVertex * 2; i++)
        vertices[vIndex++] = vector[i];
    primitives[pIndex++] = nVertex;
}

//Draw scene
void draw(void)
{
    if (count > 5)
    {
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        //If flag is true, apply a transform
        if (flag)
        {
            glPushMatrix();
            glScalef(2, 2, 1);
        }
        glBegin(GL_TRIANGLES);
        glVertex2f(aux[0], aux[1]);
        glVertex2f(aux[2], aux[3]);
        glVertex2f(aux[4], aux[5]);
        storePrimitive(aux, 3);
        if (flag)
            glPopMatrix();
        glEnd();
        glFlush();
        count = 0;
        flag = false;
    }
}

void init(void)
{
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    xf = 50.0f;
    yf = 50.0f;
    win = 250.0f;
}

void resize(GLsizei w, GLsizei h)
{
    glViewport(0, 0, w, h);
    view_w = w;
    view_h = h;

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(-win, win, -win, win);
}

void keyboardFunc(unsigned char key, int x, int y)
{
    switch (key) {
    case 'r': //Clears the screen
        glClear(GL_COLOR_BUFFER_BIT);
        glFlush();
        break;
    case 'd': //Redraw scene
        Redisplay();
        break;
    case 't': //Apply a transform to the next primitive
        flag = true;
        break;
    }
}

void mouse(int button, int state, int x, int y)
{

    if (button == GLUT_LEFT_BUTTON)
        if (state == GLUT_DOWN) {        
            aux[count] = ((2 * win * x) / view_w) - win;
            count++;
            aux[count] = (((2 * win) * (y - view_h)) / -view_h) - win;
            count++;
        }
    glutPostRedisplay();
}

int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(650, 600);
    glutInitWindowPosition(10, 10);
    glutCreateWindow("Example");
    glutDisplayFunc(draw);
    glutReshapeFunc(resize);
    glutKeyboardFunc(keyboardFunc);
    glutMouseFunc(mouse);
    init();
    glutMainLoop();
}

#包括
#包括
GLfloat xf、yf、win；
闪烁视图w，视图h；
//辅助向量
GLfloat aux[6]={0.0,0.0,0.0,0.0,0.0,0.0}；
GLfloat顶点[768]={0.0}；
//辅助向量的计数
整数计数=0；
//要用于绘制不同的形状，请存储每个基本体的顶点数
int原语[64]={}；
//索引
int-vIndex=0；
int-pIndex=0；
布尔标志=假；
//使用顶点向量反绘制场景
无效再显示（）
{
glClear（GLU颜色缓冲位）；
glFlush（）；
int j=0；
int k；
对于（int i=0；i5）
{
glMatrixMode（GLU模型视图）；
glLoadIdentity（）；
//如果标志为true，则应用变换
国际单项体育联合会（旗）
{
glPushMatrix（）；
glScalef（2,2,1）；
}
glBegin（GL_三角形）；
glVertex2f（辅助[0]，辅助[1]）；
glVertex2f（辅助[2]，辅助[3]）；
glVertex2f（辅助[4]，辅助[5]）；
（辅助，3）；
国际单项体育联合会（旗）
glPopMatrix（）；
格伦德（）；
glFlush（）；
计数=0；
flag=false；
}
}
void init（void）
{
glClearColor（0.0f、0.0f、0.0f、1.0f）；
xf=50.0f；
yf=50.0f；
温=250.0f；
}
空心尺寸调整（GLsizei w、GLsizei h）
{
glViewport（0,0,w,h）；
视图w=w；
视图h=h；
glMatrixMode（GL_投影）；
glLoadIdentity（）；
glu2d（-win，win，-win，win）；
}
void keyboardFunc（无符号字符键，整数x，整数y）
{
开关（钥匙）{
案例'r'：//清除屏幕
glClear（GLU颜色缓冲位）；
glFlush（）；
打破
案例“d”：//重新绘制场景
再显示（）；
打破
案例“t”：//对下一个基元应用转换
flag=true；
打破
}
}
无效鼠标（int按钮、int状态、int x、int y）
{
如果（按钮==GLUT\u左按钮）
如果（state==GLUT_DOWN）{
辅助[计数]=（（2*win*x）/视图w）-win；
计数++；
辅助[计数]=（（2*win）*（y-视图h））/-视图h-win；
计数++；
}
再发现（）；
}
int main（int argc，字符**argv）
{
glutInit（&argc，argv）；
glutInitDisplayMode（GLUT_SINGLE | GLUT_RGB）；
glutInitWindowSize（650600）；
位置（10，10）；
创建窗口（“示例”）；
glutDisplayFunc（draw）；
GLUTEFUNC（调整大小）；
glutKeyboardFunc（键盘Func）；
glutMouseFunc（小鼠）；
init（）；
glutMainLoop（）；
}

---

您可以看到，可以对draw函数中的基元应用变换。但是，我想做的是将变换后的基本体的顶点存储在顶点向量中。不必手动将变换应用到每个顶点就可以这样做吗？

是的，可以使用OpenGL的。 但是，我看到您使用的是老式的OpenGL，而转换反馈仅在OpenGL 3.0之后才可用。新的OpenGL样式非常不同。如果您想使用TransformFeedback，您需要删除所有代码并从头开始

---

OP找到了从

glBegin/End

捕获反馈的方法：

是否可以使用此处所述的反馈模式（）？@RaphaelSauer似乎是这样。@RaphaelSauer是的！我不知道是否可以从glBegin/End获取反馈。非常有趣的文章，谢谢分享。你想把顶点数据转换到什么空间？传统的

GL\u反馈

渲染模式只能让您进入窗口空间。@德哈斯，我想我只使用窗口空间。换句话说，在窗户上可以看到的一切。