#include <stdio.h>

#include <stdlib.h>

#include <GL/glew.h>

#include <GL/glut.h>

int main(int argc, char **argv) {

    // 这里声明纹理的大小为：teSize;而数组的大小就必须是texSize*texSize*4

    int texSize = ;

    int i;

    // 生成测试数组的数据

    float* data = (float*)malloc(*texSize*texSize*sizeof(float));

    float* result = (float*)malloc(*texSize*texSize*sizeof(float));

    for (i=; i<texSize*texSize*; i++)

        data[i] = (i+1.0)*0.01F;

    // 初始化OpenGL的环境

    glutInit (&argc, argv);

    glutCreateWindow("TEST1");

    glewInit();

    // 视口的比例是 1:1 pixel=texel=data 使得三者一一对应

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    gluOrtho2D(0.0,texSize,0.0,texSize);

    glMatrixMode(GL_MODELVIEW);

    glLoadIdentity();

    glViewport(,,texSize,texSize);

    // 生成并绑定一个FBO，也就是生成一个离屏渲染对像

    GLuint fb;

    glGenFramebuffersEXT(,&fb);

    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,fb);

    // 生成两个纹理，一个是用来保存数据的纹理，一个是用作渲染对像的纹理

    GLuint tex,fboTex;

    glGenTextures (, &tex);

    glGenTextures (, &fboTex);

    glBindTexture(GL_TEXTURE_RECTANGLE_ARB,fboTex);

    // 设定纹理参数

    glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,

                    GL_TEXTURE_MIN_FILTER, GL_NEAREST);

    glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,

                    GL_TEXTURE_MAG_FILTER, GL_NEAREST);

    glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,

                    GL_TEXTURE_WRAP_S, GL_CLAMP);

    glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,

                    GL_TEXTURE_WRAP_T, GL_CLAMP);

   // 这里在显卡上分配FBO纹理的贮存空间，每个元素的初始值是0；

    glTexImage2D(GL_TEXTURE_RECTANGLE_ARB,,GL_RGBA32F_ARB,

                 texSize,texSize,,GL_RGBA,GL_FLOAT,);

    // 分配数据纹理的显存空间

    glBindTexture(GL_TEXTURE_RECTANGLE_ARB,tex);

    glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,

                    GL_TEXTURE_MIN_FILTER, GL_NEAREST);

    glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,

                    GL_TEXTURE_MAG_FILTER, GL_NEAREST);

    glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,

                    GL_TEXTURE_WRAP_S, GL_CLAMP);

    glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,

                    GL_TEXTURE_WRAP_T, GL_CLAMP);

    glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_COLOR,GL_DECAL);

    glTexImage2D(GL_TEXTURE_RECTANGLE_ARB,,GL_RGBA32F_ARB,

                 texSize,texSize,,GL_RGBA,GL_FLOAT,);

    //把当前的FBO对像，与FBO纹理绑定在一起

    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,

                              GL_COLOR_ATTACHMENT0_EXT,

                              GL_TEXTURE_RECTANGLE_ARB,fboTex,);

    // 把本地数据传输到显卡的纹理上。

    glBindTexture(GL_TEXTURE_RECTANGLE_ARB,tex);

    glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB,,,,texSize,texSize,

                    GL_RGBA,GL_FLOAT,data);

    //--------------------begin-------------------------

    //以下代码是渲染一个大小为texSize * texSize矩形，

    //其作用就是把纹理中的数据，经过处理后，保存到帧缓冲中去，

    //由于用到了离屏渲染，这里的帧缓冲区指的就是FBO纹理。

    //在这里，只是简单地把数据从纹理直接传送到帧缓冲中，

    //没有对这些流过GPU的数据作任何处理，但是如果我们会用CG、

    //GLSL等高级着色语言，对显卡进行编程，便可以在GPU中

    //截获这些数据，并对它们进行任何我们所想要的复杂运算。

    //这就是GPGPU技术的精髓所在.

    glColor4f(1.00f,1.00f,1.00f,1.0f);

    glBindTexture(GL_TEXTURE_RECTANGLE_ARB,tex);

    glEnable(GL_TEXTURE_RECTANGLE_ARB);

            glBegin(GL_QUADS);

                glTexCoord2f(0.0, 0.0);

                glVertex2f(0.0, 0.0);

                glTexCoord2f(texSize, 0.0);

                glVertex2f(texSize, 0.0);

                glTexCoord2f(texSize, texSize);

                glVertex2f(texSize, texSize);

                glTexCoord2f(0.0, texSize);

                glVertex2f(0.0, texSize);

            glEnd();

    //--------------------end------------------------

    // 从帧缓冲中读取数据，并把数据保存到result数组中。

    glReadBuffer(GL_COLOR_ATTACHMENT0_EXT);

    glReadPixels(, , texSize, texSize,GL_RGBA,GL_FLOAT,result);

    // 显示最终的结果

    printf("Data before roundtrip:");

    for (i=; i<texSize*texSize*; i++)

        printf("%f",data[i]);

    printf("Data after roundtrip:");

    for (i=; i<texSize*texSize*; i++)

        printf("%f",result[i]);

    // 释放本地内存

    free(data);

    free(result);

    // 释放显卡内存

    glDeleteFramebuffersEXT (,&fb);

    glDeleteTextures (,&tex);

    glDeleteTextures(,&fboTex);

    return ;

}

        --------------CPU----------------      -------------GPU------------

        |                               |      |                          |

        |   data arr:                   |      |  texture:                |

        |    [][][][][][][][][]     --------------> [][][]                |

        |                               |      |    [][][]                |

        |                               |      |    [][][]                |

        |                               |      |           /             |

        |   result:                     |      |              FBO:        |

        |    [][][][][][][][][]         |      |              [][][]      |

        |                              <-----------------     [][][]      |

        |                               |      |              [][][]      |

        |-------------------------------|      |--------------------------|

---

---

for (int i=; i<N; i++)

    dataY[i] = dataY[i] + alpha * dataX[i];

float saxpy (

      float2 coords : TEXCOORD0,

      uniform sampler2D textureY,

      uniform sampler2D textureX,

      uniform float alpha ) : COLOR

      {

          float result;

          float yval=y_old[i];

          float y = tex2D(textureY,coords);

          float xval=x[i];

          float x = tex2D(textureX,coords);

          y_new[i]=yval+alpha*xval;

          result = y + alpha * x;

          return result;

}

	texture2D	texture rectangle
样本定义	uniform sampler2D	uniform samplerRECT
纹理查找函数	tex2D(name, coords)	texRECT(name, coords)

float4 saxpy (

    float2 coords : TEXCOORD0,

    uniform samplerRECT textureY,

    uniform samplerRECT textureX,

    uniform float alpha ) : COLOR

{

    float4 result;

    float4 y = texRECT(textureY,coords);

    float4 x = texRECT(textureX,coords);

    result = y + alpha*x;

    // equivalent: result.rgba=y.rgba+alpha*x.rgba

    //         or: result.r=y.r+alpha*x.y; result.g=...

    return result;

}

我们可以把着色代码保存在字符数组或文本文件中，然后通过OpenGL的CG运行时函数来访问它们。

// Cg vars

CGcontext cgContext;

CGprofile fragmentProfile;

CGprogram fragmentProgram;

CGparameter yParam, xParam, alphaParam;

char* program_source = "float saxpy( [....] return result; } ";

CGcontext  是一个指向CG运行时组件的入口指针，由于我们打算对片段管线进行编程，因此我们要一个fragment profile，以及一个程序container。为了简单起见，我们还声明了三个句柄，分别对应了着色程序中的三个没有语义的入口参数。我们用一个全局的字符串变量来保存前面所写好的着色代码。现在就把所有的CG初始化工作放在一个函数中完成。这里只作了最简单的介绍，详细的内容可以查看CG手册，或者到Cg Toolkit page.网页上学习一下。

void initCG(void) {

    // set up Cg

    cgContext = cgCreateContext();

    fragmentProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT);

    cgGLSetOptimalOptions(fragmentProfile);

    // create fragment program

    fragmentProgram = cgCreateProgram (

                          cgContext,CG_SOURCE,program_source,

                          fragmentProfile,"saxpy",NULL);

    // load program

    cgGLLoadProgram (fragmentProgram);

    // and get parameter handles by name

    yParam = cgGetNamedParameter (fragmentProgram,"textureY");

    xParam = cgGetNamedParameter (fragmentProgram,"textureX");

    alphaParam = cgGetNamedParameter (fragmentProgram,"alpha");

}

// GLSL vars

GLhandleARB programObject;

GLhandleARB shaderObject;

GLint yParam, xParam, alphaParam;

// shader for luminance data          |   // shader for RGBA data

// and texture rectangles             |   // and texture2D

                                      |

uniform samplerRect textureY;         |   uniform sampler2D textureY;

uniform samplerRect textureX;         |   uniform sampler2D textureX;

uniform float alpha;                  |   uniform float alpha;

                                      |

void main(void) {                     |    void main(void) {

    float y = textureRect(            |       vec4 y = texture2D(

           textureY,                  |              textureY,

           gl_TexCoord[].st).x;      |             gl_TexCoord[].st);

    float x = textureRect(            |       vec4 x = texture2D(

           textureX,                  |              textureX

           gl_TexCoord[].st).x;      |             gl_TexCoord[].st);

    gl_FragColor.x =                  |       gl_FragColor =

            y + alpha*x;              |              y + alpha*x;

}                                     |   }

void initGLSL(void) {

    // create program object

    programObject = glCreateProgramObjectARB();

    // create shader object (fragment shader) and attach to program

    shaderObject = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);

    glAttachObjectARB (programObject, shaderObject);

    // set source to shader object

    glShaderSourceARB(shaderObject, , &program_source, NULL);

    // compile

    glCompileShaderARB(shaderObject);

    // link program object together

    glLinkProgramARB(programObject);

    // Get location of the texture samplers for future use

    yParam = glGetUniformLocationARB(programObject, "textureY");

    xParam = glGetUniformLocationARB(programObject, "textureX");

    alphaParam = glGetUniformLocationARB(programObject, "alpha");

}

---

// enable fragment profile

cgGLEnableProfile(fragmentProfile);

// bind saxpy program

cgGLBindProgram(fragmentProgram);

glUseProgramObjectARB(programObject);    

// enable texture y_old (read-only)

cgGLSetTextureParameter(yParam, y_oldTexID);

cgGLEnableTextureParameter(yParam);

// enable texture x (read-only)

cgGLSetTextureParameter(xParam, xTexID);

cgGLEnableTextureParameter(xParam);

// enable scalar alpha

cgSetParameter1f(alphaParam, alpha);

// enable texture y_old (read-only)

glActiveTexture(GL_TEXTURE0);

glBindTexture(textureParameters.texTarget,yTexID[readTex]);

glUniform1iARB(yParam,); // texunit 0

// enable texture x (read-only)

glActiveTexture(GL_TEXTURE1);

glBindTexture(textureParameters.texTarget,xTexID);

glUniform1iARB(xParam, ); // texunit 1

// enable scalar alpha

glUniform1fARB(alphaParam,alpha);

// attach target texture to first attachment point

glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,

                          GL_COLOR_ATTACHMENT0_EXT,

                          texture_target, y_newTexID, );

// set the texture as render target

glDrawBuffer (GL_COLOR_ATTACHMENT0_EXT);

// make quad filled to hit every pixel/texel

glPolygonMode(GL_FRONT,GL_FILL);

// and render quad

glBegin(GL_QUADS);

    glTexCoord2f(0.0, 0.0);

    glVertex2f(0.0, 0.0);

    glTexCoord2f(texSize, 0.0);

    glVertex2f(texSize, 0.0);

    glTexCoord2f(texSize, texSize);

    glVertex2f(texSize, texSize);

    glTexCoord2f(0.0, texSize);

    glVertex2f(0.0, texSize);

glEnd();如果使用 texture2D ，就必须单位化所有的纹理坐标，等价的代码如下： 

// make quad filled to hit every pixel/texel

glPolygonMode(GL_FRONT,GL_FILL);

// and render quad

glBegin(GL_QUADS);

    glTexCoord2f(0.0, 0.0);

    glVertex2f(0.0, 0.0);

    glTexCoord2f(1.0, 0.0);

    glVertex2f(texSize, 0.0);

    glTexCoord2f(1.0, 1.0);

    glVertex2f(texSize, texSize);

    glTexCoord2f(0.0, 1.0);

    glVertex2f(0.0, texSize);

glEnd();

这里提示一下那些做高级应用的程序员：在我们的着色程序中，只用到了一组纹理坐标，但是我们也可以为每个顶点定义多组不同的纹理坐标，相关的更多细节，可以查看一下glMultiTexCoord()函数的使用。

---

---

// two textures identifiers referencing y_old and y_new

GLuint yTexID[];

// ping pong management vars

int writeTex = ;

int readTex = ;

GLenum attachmentpoints[] = { GL_COLOR_ATTACHMENT0_EXT,

                              GL_COLOR_ATTACHMENT1_EXT

                            };

// attach two textures to FBO

glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,

                          attachmentpoints[writeTex],

                          texture_Target, yTexID[writeTex], );

glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,

                          attachmentpoints[readTex],

                          texture_Target, yTexID[readTex], );

// enable fragment profile, bind program [...]

// enable texture x (read-only) and uniform parameter [...]

// iterate computation several times

for (int i=; i<numIterations; i++) {

    // set render destination

    glDrawBuffer (attachmentpoints[writeTex]);

    // enable texture y_old (read-only)

    cgGLSetTextureParameter(yParam, yTexID[readTex]);

    cgGLEnableTextureParameter(yParam);

    // and render multitextured viewport-sized quad

    // swap role of the two textures (read-only source becomes

    // write-only target and the other way round):

    swap();

}

---

---

rect_nv_r_32.name              = "TEXRECT - float_NV - R - 32";

rect_nv_r_32.texTarget         = GL_TEXTURE_RECTANGLE_ARB;

rect_nv_r_32.texInternalFormat = GL_FLOAT_R32_NV;

rect_nv_r_32.texFormat         = GL_LUMINANCE;

rect_nv_r_32.shader_source     = "float saxpy ("

                            "in float2 coords : TEXCOORD0,"

                            "uniform samplerRECT textureY,"

                            "uniform samplerRECT textureX,"

                            "uniform float alpha )  : COLOR {"

                            "float y = texRECT (textureY, coords);"

                            "float x = texRECT (textureX, coords);"

                            "return y+alpha*x; }";

为了给不同的情况取得一个合适的工作版本，我们只须要查找和替换就可以了。或者使用第二个命令行参数如：rect_nv_r_32。在应用程序中，一个全局变量textureParameters 指向我们实现要使用的结构体。

---

---

void checkGLErrors(const char *label) {

    GLenum errCode;

    const GLubyte *errStr;

    if ((errCode = glGetError()) != GL_NO_ERROR) {

        errStr = gluErrorString(errCode);

        printf("OpenGL ERROR: ");

        printf((char*)errStr);

        printf("(Label: ");

        printf(label);

        printf(") .");

    }

}

bool checkFramebufferStatus() {

    GLenum status;

    status=(GLenum)glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);

    switch(status) {

        case GL_FRAMEBUFFER_COMPLETE_EXT:

            return true;

        case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:

            printf("Framebuffer incomplete,incomplete attachment");

            return false;

        case GL_FRAMEBUFFER_UNSUPPORTED_EXT:

            printf("Unsupported framebuffer format");

            return false;

        case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT:

            printf("Framebuffer incomplete,missing attachment");

            return false;

        case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:

            printf("Framebuffer incomplete,attached images

                    must have same dimensions");

            return false;

        case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT:

             printf("Framebuffer incomplete,attached images

                     must have same format");

            return false;

        case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT:

            printf("Framebuffer incomplete,missing draw buffer");

            return false;

        case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT:

            printf("Framebuffer incomplete,missing read buffer");

            return false;

    }

    return false;

}

// register the error callback once the context has been created

cgSetErrorCallback(cgErrorCallback);

// callback function

void cgErrorCallback(void) {

    CGerror lastError = cgGetError();

    if(lastError) {

        printf(cgGetErrorString(lastError));

        printf(cgGetLastListing(cgContext));

    }

}

/**

 * copied from

 * http://www.lighthouse3d.com/opengl/glsl/index.php?oglinfo

 */

void printInfoLog(GLhandleARB obj) {

    int infologLength = ;

    int charsWritten  = ;

    char *infoLog;

    glGetObjectParameterivARB(obj,

                              GL_OBJECT_INFO_LOG_LENGTH_ARB,

                              &infologLength);

    if (infologLength > ) {

        infoLog = (char *)malloc(infologLength);

        glGetInfoLogARB(obj, infologLength,

                        &charsWritten, infoLog);

        printf(infoLog);

        printf("");

        free(infoLog);

    }

}

GLint success;

glGetObjectParameterivARB(programObject,

                          GL_OBJECT_LINK_STATUS_ARB,

                          &success);

if (!success) {

    printf("Shader could not be linked!");

}

---

---

This software is provided 'as-is', without any express or implied

warranty.  In no event will the author be held liable for any

damages arising from the use of this software. 

Permission is granted to anyone to use this software for any

purpose, including commercial applications, and to alter it

and redistribute it freely.