Question

I’m currently building a plug-in in C++ for the program Igor Pro. This plug-in takes three arrays of points (X, Y, Z) and returns a matrix with the pixel values of the data (float array[windowsize][windowsize]).

I’ve already developed a solution in OpenGL (glew) by using VBOs but I feel that it’s not the optimal solution.

1) Do you think I should use offscreen rendering with FBOs or PBOs? I would like to make it run as fast as possible.

2) Also, I’d like to run glutMainLoop only once. Should I change to FreeGLUT?

/*  
        RenderTriangle.c
*/
#include "VC10\triangulation.h"
#include "XOPStandardHeaders.h"         // Include ANSI headers, Mac headers, IgorXOP.h, XOP.h and XOPSupport.h
#include "glui.h"

// Prototypes
HOST_IMPORT int main(IORecHandle ioRecHandle);

// Global Variables
const int windowSize = 512;
GLuint ID;
int size,el_size;
float* waveX=NULL;
float* waveY=NULL;
float* waveZ=NULL;
waveHndl waveH;

// Custom error codes
#define OLD_IGOR 1 + FIRST_XOP_ERR
#define NON_EXISTENT_WAVE 2 + FIRST_XOP_ERR
#define REQUIRES_SP_OR_DP_WAVE 3 + FIRST_XOP_ERR

#pragma pack(2)     // All structures passed to Igor are two-byte aligned.
typedef struct FitParams {
    waveHndl waveX; 
    waveHndl waveY;
    waveHndl waveZ;
    double result;
} FitParams, *FitParamsPtr;
#pragma pack()      // Restore default structure alignment

// Prototypes of the OpenGL callbacks
void init(void);
void display(void);
void idle(void);

void init(void){

    float z_val=0;
    int point=0;

    //Loading data from the text files and applying the Delaunay algorithm
    triangulateio tri_data=triangulationWave(waveX,waveY,waveZ);
    vector<float>data_vector(tri_data.numberoftriangles*3*6); //3 points with 6 coordinates (position and color)

    size=data_vector.size();

    double zMin=tri_data.pointattributelist[N_ELEMENTS],zMax=tri_data.pointattributelist[N_ELEMENTS+1];
    for (int i_tri = 0; i_tri < tri_data.numberoftriangles; i_tri++) {

        for (int i_point = 0; i_point < 3; i_point++) {

            z_val=tri_data.pointattributelist[tri_data.trianglelist[i_tri * 3 + i_point]];
            z_val=1-((z_val-zMin)/(zMax-zMin)); //normalize and invertion

            point=6*(i_tri *3 + i_point);

            data_vector[point+0]=tri_data.pointlist[2*tri_data.trianglelist[i_tri * 3 + i_point]];
            data_vector[point+1]=tri_data.pointlist[2*tri_data.trianglelist[i_tri * 3 + i_point]+1];
            data_vector[point+2]=z_val;
            data_vector[point+3]=z_val;
            data_vector[point+4]=z_val;
            data_vector[point+5]=z_val;
        }
    }

    glewInit();

    glEnable(GL_DEPTH_TEST);
    glDepthMask(GL_TRUE);
    glDepthFunc(GL_LEQUAL);
    glDepthRange(-2.0f, 2.0f);
    glClearColor(0.0f, 1.0f, 0.0f, 0.0f);
    glShadeModel(GL_SMOOTH);
    glEnableClientState(GL_VERTEX_ARRAY);
    glGenBuffers(1,&ID);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ID);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER,size*sizeof(float), &data_vector[0], GL_STATIC_DRAW);

    el_size=6*sizeof(float);
}
void display(void){

    int zoom = 1;
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(-2*zoom, 2*zoom,2*zoom,-2*zoom, -5.0f, 5.0f);
    glPushMatrix ();
    glBindBuffer(GL_ARRAY_BUFFER, ID);

    // Pointer for the position of the points
    glEnableClientState(GL_VERTEX_ARRAY);
    glVertexPointer(3, GL_FLOAT, el_size, 0);

    // Pointer for the color of the points
    glEnableClientState(GL_COLOR_ARRAY);
    glColorPointer(3,GL_FLOAT, el_size,(void*)(el_size/2));

    //Draw callback
    glDrawArrays(GL_TRIANGLES,0,size/6);

    glPopMatrix ();
    glFlush();
}

// Idle callback function for OpenGL API
void idle(void){

    float* pixels = (float*)malloc(windowSize*windowSize*sizeof(float));
    glReadPixels(0, 0, windowSize, windowSize, GL_DEPTH_COMPONENT, GL_FLOAT, pixels);

    //
    //char waveName[MAX_OBJ_NAME+1]; 
    //CountInt dimensionSizes[MAX_DIMENSIONS+1]; 
    //float* wp;
    //strcpy(waveName, "wave0");
    //MemClear(dimensionSizes, sizeof(dimensionSizes));
    //dimensionSizes[ROWS] = windowSize*windowSize; // Make 1D wave 
    //wp = (float*)WaveData(waveH); // Get a pointer to the wave data 

    //for(int i = 0;i < windowSize*windowSize; i++){    
    //  *wp++ =pixels[i];                 
    //}

    //glDeleteBuffers(1,&ID);
}

// Main function for the XOP
extern "C" int
RenderTriangle(FitParamsPtr p)
{
    waveX=(float*)WaveData(p->waveX);
    waveY=(float*)WaveData(p->waveY);
    waveZ=(float*)WaveData(p->waveZ);

    char *myargv [1];
    int myargc=1;
    myargv [0]=strdup ("RenderTriangle");
    glutInit(&myargc,myargv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_DEPTH | GLUT_RGB);
    glutInitWindowSize(windowSize,windowSize);
    glutCreateWindow("OpenGL");
    init();
    glutDisplayFunc(display);
    glutIdleFunc(idle);
    glutMainLoop();
    p->result = 1;

    return 0;
}

static XOPIORecResult
RegisterFunction()
{
    int funcIndex;

    funcIndex = (int)GetXOPItem(0);         // Which function invoked ?
    switch (funcIndex) {
        case 0:                                 // y = RenderTriangle(w,x) (curve fitting function).
            return (XOPIORecResult)RenderTriangle;  // This function is called using the direct method.
            break;
    }
    return 0;
}

/*  XOPEntry()

    This is the entry point from the host application to the XOP for all
    messages after the INIT message.
*/
extern "C" void
XOPEntry(void)
{   
    XOPIORecResult result = 0;

    switch (GetXOPMessage()) {
        case FUNCADDRS:
            result = RegisterFunction();    // This tells Igor the address of our function.
            break;
    }
    SetXOPResult(result);
}

/*  main(ioRecHandle)

    This is the initial entry point at which the host application calls XOP.
    The message sent by the host must be INIT.
    main() does any necessary initialization and then sets the XOPEntry field of the
    ioRecHandle to the address to be called for future messages.
*/
HOST_IMPORT int
main(IORecHandle ioRecHandle)
{   
    XOPInit(ioRecHandle);                           // Do standard XOP initialization.
    SetXOPEntry(XOPEntry);                          // Set entry point for future calls.

    if (igorVersion < 600) {
        SetXOPResult(OLD_IGOR);
        return EXIT_FAILURE;
    }

    SetXOPResult(0);
    return EXIT_SUCCESS;
}

Answer 1

• VBOs are for transferring vertex data.

You’re transferring in your point cloud data via a VBO, it can’t get better than that.

• PBOs are for transferring pixel data.

You could use a PBO to asynchronously read the data from the OpenGL framebuffer.

• FBOs can be drawn onto.

You should use a FBO to isolate your target framebuffer from any window operations.

2) Also, I’d like to run glutMainLoop only once. Should I change to FreeGLUT?

You don’t have to run the mainloop at all. All you need is just a window created; it won’t show up until the mainloop is started. You need the window to get an OpenGL context, but you can safely omit the mainloop.

Instead of registering any callbacks (they won’t be called), just execute your OpenGL commands in order. If your library gets called several times you don’t have to recreate the window, but it may be neccessary to call glutSetWindow to make the context current.

1. setup a FBO to draw onto
2. draw to FBO
3. glReadPixels
   • either into a PBO and glMapBuffer and memcpy.
   • or directly into a buffer of apropriate size.