Fatal编程技术网
  • opengl/
  • 优化OpenGL片段着色器

优化OpenGL片段着色器

opengl

优化OpenGL片段着色器,opengl,shader,fragment-shader,Opengl,Shader,Fragment Shader,我有一个顶点/片段着色器，它绘制一个矩形，根据纹理执行许多计算。（它混合像素、修改像素等）。问题是每个矩形及其包含的像素不会改变。我只移动整个矩形并缩放它们 有没有办法优化片段着色器，因为矩形实际上不需要重新计算？因此，如果我理解正确，您只需计算一次这些矩形，然后想重用它们？这类任务通过渲染到纹理，然后进一步使用生成的纹理来解决 渲染到纹理最容易通过帧缓冲区对象完成 编辑：使用FBO渲染到纹理的简单示例 // test_fbo_teapot.cpp #include <GL/glew.h

我有一个顶点/片段着色器，它绘制一个矩形，根据纹理执行许多计算。（它混合像素、修改像素等）。问题是每个矩形及其包含的像素不会改变。我只移动整个矩形并缩放它们

有没有办法优化片段着色器，因为矩形实际上不需要重新计算？

因此，如果我理解正确，您只需计算一次这些矩形，然后想重用它们？这类任务通过渲染到纹理，然后进一步使用生成的纹理来解决

渲染到纹理最容易通过帧缓冲区对象完成

编辑：使用FBO渲染到纹理的简单示例

// test_fbo_teapot.cpp

#include <GL/glew.h> // Uses GLEW for extension loading
#include <GL/glut.h> // Uses GLUT as framework
                     // Check those are on your system for compilation
                     // and if not please install them.

#include <cmath>
#include <iostream>

using namespace std;

namespace render
{
    int width, height;
    float aspect;

    void init();
    void reshape(int width, int height);
    void display();

    int const fbo_width = 512;
    int const fbo_height = 512;

    GLuint fb, color, depth;
};

void idle();

int main(int argc, char *argv[])
{
    glutInit(&argc, argv);
    glutInitDisplayMode( GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH );

    glutCreateWindow("FBO test");
    glutDisplayFunc(render::display);
    glutReshapeFunc(render::reshape);
    glutIdleFunc(idle);

    glewInit();

    render::init();
    glutMainLoop();

    return 0;
}

void idle()
{
    glutPostRedisplay();
}

void CHECK_FRAMEBUFFER_STATUS()
{                                                         
    GLenum status;
    status = glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER); 
    switch(status) {
    case GL_FRAMEBUFFER_COMPLETE:
        break;

    case GL_FRAMEBUFFER_UNSUPPORTED:
    /* choose different formats */
        break;

    default:
        /* programming error; will fail on all hardware */
        throw "Framebuffer Error";
    }
}

namespace render
{
    float const light_dir[]={1,1,1,0};
    float const light_color[]={1,0.95,0.9,1};

    void init()
    {
        glGenFramebuffers(1, &fb);
        glGenTextures(1, &color);
        glGenRenderbuffers(1, &depth);

        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fb);

        glBindTexture(GL_TEXTURE_2D, color);
        glTexImage2D(   GL_TEXTURE_2D, 
                0, 
                GL_RGBA, 
                fbo_width, fbo_height,
                0, 
                GL_RGBA, 
                GL_UNSIGNED_BYTE, 
                NULL);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, color, 0);

        glBindRenderbuffer(GL_RENDERBUFFER, depth);
        glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, fbo_width, fbo_height);
        glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depth);

        CHECK_FRAMEBUFFER_STATUS();
    }

    void reshape(int width, int height)
    {
        render::width=width;
        render::height=height;
        aspect=float(width)/float(height);
        glutPostRedisplay();
    }

    void prepare()
    {
        static float a=0, b=0, c=0;

        glBindTexture(GL_TEXTURE_2D, 0);
        glEnable(GL_TEXTURE_2D);
        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fb);

        glViewport(0,0,fbo_width, fbo_height);

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

        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluPerspective(45, 1, 1, 10);

        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();

        glEnable(GL_LIGHT0);
        glEnable(GL_LIGHTING);

        glEnable(GL_DEPTH_TEST);
        glDisable(GL_CULL_FACE);

        glLightfv(GL_LIGHT0, GL_POSITION, light_dir);
        glLightfv(GL_LIGHT0, GL_DIFFUSE, light_color);

        glTranslatef(0,0,-5);

        glRotatef(a, 1, 0, 0);
        glRotatef(b, 0, 1, 0);
        glRotatef(c, 0, 0, 1);

        glutSolidTeapot(0.75);

        a=fmod(a+0.1, 360.);
        b=fmod(b+0.5, 360.);
        c=fmod(c+0.25, 360.);
    }

    void intermediary()
    {
    }

    void final()
    {
        static float a=0, b=0, c=0;

        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);

        glViewport(0,0, width, height);

        glClearColor(1,1,1,1);
        glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluPerspective(45, aspect, 1, 10);

        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        glTranslatef(0,0,-5);

        glRotatef(b, 0, 1, 0);

        b=fmod(b+0.5, 360.);

        glEnable(GL_TEXTURE_2D);
        glBindTexture(GL_TEXTURE_2D, color);

        glEnable(GL_DEPTH_TEST);
        glEnable(GL_CULL_FACE);

        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        glDisable(GL_LIGHTING);

        float cube[][5]=
        {
            {-1, -1, -1,  0,  0},
            { 1, -1, -1,  1,  0},
            { 1,  1, -1,  1,  1},
            {-1,  1, -1,  0,  1},

            {-1, -1,  1, -1,  0},
            { 1, -1,  1,  0,  0},
            { 1,  1,  1,  0,  1},
            {-1,  1,  1, -1,  1},
        };
        unsigned int faces[]=
        {
            0, 1, 2, 3,
            1, 5, 6, 2,
            5, 4, 7, 6,
            4, 0, 3, 7,
            3, 2, 6, 7,
            4, 5, 1, 0
        };

        glEnableClientState(GL_VERTEX_ARRAY);
        glEnableClientState(GL_TEXTURE_COORD_ARRAY);

        glVertexPointer(3, GL_FLOAT, 5*sizeof(float), &cube[0][0]);
        glTexCoordPointer(2, GL_FLOAT, 5*sizeof(float), &cube[0][3]);

        glCullFace(GL_BACK);
        glDrawElements(GL_QUADS, 24, GL_UNSIGNED_INT, faces);

        glCullFace(GL_FRONT);
        glDrawElements(GL_QUADS, 24, GL_UNSIGNED_INT, faces);

        glDisableClientState(GL_VERTEX_ARRAY);
        glDisableClientState(GL_TEXTURE_COORD_ARRAY);

    }

    void display()
    {
        prepare();
        intermediary();
        final();

        glutSwapBuffers();
    }
};

//test\u fbo\u teapot.cpp
#include//使用GLEW加载扩展
#include//使用GLUT作为框架
//检查您的系统上是否有用于编译的文件
//如果没有，请安装它们。
#包括
#包括
使用名称空间std；
命名空间呈现
{
int宽度、高度；
浮动方面；
void init（）；
空洞重塑（内部宽度、内部高度）；
void display（）；
int const fbo_width=512；
int const fbo_height=512；
胶水，颜色，深度；
};
无效空闲（）；
int main（int argc，char*argv[]）
{
glutInit（&argc，argv）；
glutInitDisplayMode（GLUT_RGBA | GLUT_DOUBLE | GLUT_深度）；
玻璃窗（“FBO测试”）；
glutDisplayFunc（渲染：：显示）；
GLUTREFORMATEFUNC（渲染：：重塑）；
glutIdleFunc（空闲）；
glewInit（）；
render:：init（）；
glutMainLoop（）；
返回0；
}
无效空闲（）
{
再发现（）；
}
无效检查\u帧缓冲区\u状态（）
{                                                         
盂状态；
状态=glCheckFramebufferStatus（GL\u DRAW\u FRAMEBUFFER）；
开关（状态）{
案例GL\u帧缓冲区\u完成：
打破
不支持案例GL\u帧缓冲区\u：
/*选择不同的格式*/
打破
违约：
/*编程错误；将在所有硬件上失败*/
抛出“帧缓冲区错误”；
}
}
命名空间呈现
{
float const light_dir[]={1,1,1,0}；
float const light_color[]={1,0.95,0.9,1}；
void init（）
{
glGenFramebuffers（1和fb）；
glGenTextures（1，彩色）；
glGenRenderbuffers（1和深度）；
glBindFramebuffer（GL_DRAW_FRAMEBUFFER，fb）；
glBindTexture（GL_纹理_2D，颜色）；
glTexImage2D（GL_纹理_2D，
0, 
格尔巴，
fbo_宽度，fbo_高度，
0, 
格尔巴，
GL_无符号字节，
无效）；
glTexParameteri（GL_纹理2D、GL_纹理最小过滤器、GL_线性）；
glTexParameteri（GL_纹理2D、GL_纹理MAG_过滤器、GL_线性）；
glFramebufferTexture2D（GL_DRAW_FRAMEBUFFER，GL_COLOR_ATTACHMENT0，GL_TEXTURE_2D，COLOR，0）；
glBindRenderbuffer（GLU RENDERBUFFER，深度）；
GLRENDERBUFFER存储（GLRENDERBUFFER，GLRENDERBUFFER深度组件24，fbo宽度，fbo高度）；
glFramebufferRenderbuffer（GL_DRAW_FRAMEBUFFER，GL_DEPTH_附件，GL_RENDERBUFFER，DEPTH）；
检查_帧缓冲区_状态（）；
}
空洞重塑（整型宽度、整型高度）
{
渲染：：宽度=宽度；
渲染：：高度=高度；
纵横比=浮动（宽度）/浮动（高度）；
再发现（）；
}
无效准备（）
{
静态浮动a=0，b=0，c=0；
glBindTexture（GL_TEXTURE_2D，0）；
glEnable（GL_纹理_2D）；
glBindFramebuffer（GL_DRAW_FRAMEBUFFER，fb）；
glViewport（0,0，fbo_宽度，fbo_高度）；
glClearColor（1,1,1,0）；
glClear（GL_颜色_缓冲_位| GL_深度_缓冲_位）；
glMatrixMode（GL_投影）；
glLoadIdentity（）；
GLU透视图（45,1,1,10）；
glMatrixMode（GLU模型视图）；
glLoadIdentity（）；
glEnable（GL_LIGHT0）；
glEnable（德国劳埃德大学照明）；
glEnable（GLU深度试验）；
glDisable（GLU消隐面）；
glLightfv（GL_LIGHT0，GL_位置，light_dir）；
glLightfv（GL_LIGHT0，GL_漫反射，light_color）；
glTranslatef（0,0，-5）；
glRotatef（a，1，0，0）；
glRotatef（b，0，1，0）；
glRotatef（c，0，0，1）；
茶壶（0.75）；
a=fmod（a+0.1360.）；
b=fmod（b+0.5360）；
c=fmod（c+0.25360）；
}
无效中介人（）
{
}
最终作废（）
{
静态浮动a=0，b=0，c=0；
glBindFramebuffer（GL\u DRAW\u FRAMEBUFFER，0）；
glViewport（0,0，宽度，高度）；
glClearColor（1,1,1,1）；
glClear（GL_颜色_缓冲_位| GL_深度_缓冲_位）；
glMatrixMode（GL_投影）；
glLoadIdentity（）；
透视图（45，纵横比，1，10）；
glMatrixMode（GLU模型视图）；
glLoadIdentity（）；
glTranslatef（0,0，-5）；
glRotatef（b，0，1，0）；
b=fmod（b+0.5360）；
glEnable（GL_纹理_2D）；
glBindTexture（GL_纹理_2D，颜色）；
glEnable（GLU深度试验）；
glEnable（GL_CULL_面）；
glEnable（GL_混合物）；
glBlendFunc（GL_SRC_ALPHA，GL_ONE_减去GL_SRC_ALPHA）；
glDisable（GLU照明）；
浮动立方体[][5]=
{
{-1, -1, -1,  0,  0},
{ 1, -1, -1,  1,  0},
{ 1,  1, -1,  1,  1},
{-1,  1, -1,  0,  1},
{-1, -1,  1, -1,  0},
{ 1, -1,  1,  0,  0},
{ 1,  1,  1,  0,  1},
{-1,  1,  1, -1,  1},
};
无符号整数面[]=
{
0, 1, 2, 3,
1, 5, 6, 2,
5, 4, 7, 6,
4, 0, 3, 7,
3, 2, 6, 7,
4, 5, 1, 0
};
glEnableClientState（GL_顶点_数组）；
glEnableClientState（GL_纹理_坐标_阵列）；
glvertexointer（3，GL_FLOAT，5*sizeof（FLOAT），&cube[0][0]）；
glTexCoordPointer（2，GL_FLOAT，5*sizeof（FLOAT），&cube[0][3]）；
正面（背面）；
GLD元件（GLU四边形，24，GL_