/home/carolina/workspace/spvolren_cpu/carol_glsl.c

Vá para a documentação deste arquivo.

#include "carol_glsl.h"

GLuint fragmentShader, program;

char* GLSL_textFileRead(char *fn)
{

        FILE *fp;
        char *content = NULL;

        int count=0;

        if (fn != NULL) {
                fp = fopen(fn,"rt");

                if (fp != NULL) {
      
      fseek(fp, 0, SEEK_END);
      count = ftell(fp);
      rewind(fp);

                        if (count > 0) {
                                content = (char *)malloc(sizeof(char) * (count+1));
                                count = fread(content,sizeof(char),count,fp);
                                content[count] = '\0';
                        }
                        fclose(fp);
                }
        }
        return content;
}

int GLSL_textFileWrite(char *fn, char *s)
{

        FILE *fp;
        int status = 0;

        if (fn != NULL) {
                fp = fopen(fn,"w");

                if (fp != NULL) {
                        
                        if (fwrite(s,sizeof(char),strlen(s),fp) == strlen(s))
                                status = 1;
                        fclose(fp);
                }
        }
        return(status);
}

void GLSL_texActivate(int numTextureObjects, TextureObject *textureObjects)
{
        int i;

        for (i = 0; i < numTextureObjects; i++) {
                glActiveTexture(GL_TEXTURE0 + textureObjects[i].texUnit);
                glEnable(textureObjects[i].texture.target);
                glBindTexture(textureObjects[i].texture.target,
                                          textureObjects[i].texture.id);
        }
}

void GLSL_texDeactivate(int numTextureObjects, TextureObject *textureObjects)
{       
        int i;

        for (i = 0; i < numTextureObjects; i++) {
                glActiveTexture(GL_TEXTURE0 + textureObjects[i].texUnit);
                glDisable(textureObjects[i].texture.target);
        }
}


void GLSL_activateARBProg(ARBProgram *prog) 
{       
        GLSL_texActivate(prog->numTextureObjects, prog->textureObjects);
        glEnable(prog->programType);
        glUseProgram(prog->id);
}

void GLSL_deactivateARBProg(ARBProgram *prog) 
{       
        GLSL_texDeactivate(prog->numTextureObjects, prog->textureObjects);
        glDisable(prog->programType);
        glUseProgram(0);
}

// Our GL Specific Initializations
void GLSL_init()
{
        char *fragmentShaderContent;

        fragmentShaderContent = GLSL_textFileRead("./glsl_volumeShaders/carol_raycasting.fp");
        const char *fragContent = fragmentShaderContent; 

        g.fragProgs[0].id = glCreateProgram();

        fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);    
        glShaderSource(fragmentShader, 1, &fragContent,NULL);

        free((void*)fragmentShader);

        glCompileShader(fragmentShader);

        glAttachShader(g.fragProgs[0].id,fragmentShader);

        glLinkProgram(g.fragProgs[0].id); 
}

void GLSL_raycastBackground(GLenum destinationBuffer)
{
        GLdouble modelview[16], projection[16], vertizes[4][3];
        GLint viewport[4];
        GLdouble x, y, z;
        int i;

        float texelHeight = 1.0/(float)g.windowHeight;
        float texelWidth = 1.0/(float)g.windowWidth;

        GLSL_activateARBProg(g.currentFragProg);

        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
        glEnable(GL_CULL_FACE);

        glUniform4f(glGetUniformLocation(program, "params2"), g.u.texCoordScale, 0.0, 0.0, 0.0);

        glUniform4fv(glGetUniformLocation(program, "center"), 1, g.center);

        glUniform4f(glGetUniformLocation(program, "texMax"),   g.extents[0] * g.scaleFactors[0],
                            g.extents[1] * g.scaleFactors[1],
                            g.extents[2] * g.scaleFactors[2],
                            0.0);

        glUniform4fv(glGetUniformLocation(program, "scaleFactors"), 1, g.scaleFactors);

        glGetIntegerv(GL_VIEWPORT, viewport);
        glGetDoublev(GL_MODELVIEW_MATRIX, modelview);
        glGetDoublev(GL_PROJECTION_MATRIX, projection);

        for (i = 0; i < 4; i++) {
                x = ((i&1)>>0) * viewport[2];
                y = ((i&2)>>1) * viewport[3];
                z = .5;

                gluUnProject(x, y, z, modelview, projection, viewport,
                                         &vertizes[i][0], &vertizes[i][1], &vertizes[i][2]);
        }

        glBegin(GL_QUADS);
                vertexv(vertizes[0]);
                vertexv(vertizes[1]);
                vertexv(vertizes[3]);
                vertexv(vertizes[2]);
        glEnd();

        GLSL_deactivateARBProg(g.currentFragProg);

        glDrawBuffer(GL_BACK);
}
void GLSL_renderVolume()
{
        glUniform4f(glGetUniformLocation(program, "params"),  g.u.stepSize,
                                g.u.gradScale, g.u.gradOffset, -5.0);
        glUniform4f(glGetUniformLocation(program, "params2"), g.u.texCoordScale, g.u.numIterations,
                            g.u.isoValue, 0);
        glUniform4fv(glGetUniformLocation(program, "center"), 1, g.center);
        glUniform4f(glGetUniformLocation(program, "texMax"),   g.extents[0] * g.scaleFactors[0],
                            g.extents[1] * g.scaleFactors[1],
                            g.extents[2] * g.scaleFactors[2],
                            0.0);
        glUniform4fv(glGetUniformLocation(program, "scaleFactors"), 1, g.scaleFactors);

        drawQuads();
}

void GLSL_raycastVolume()
{
        //glUseProgram(program);
        GLSL_activateARBProg(g.currentFragProg);
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
        glDisable(GL_DEPTH_TEST);

        glEnable(GL_CULL_FACE);

        GLSL_renderVolume();

        GLSL_deactivateARBProg(g.currentFragProg);
        //glUseProgram(0);
}

---