Referência do Arquivo /home/carolina/workspace/spvolren_cpu/carol_glsl.c

#include "carol_glsl.h"

Vá para o código-fonte deste arquivo.

Funções

char * GLSL_textFileRead (char *fn)
 Essa função abre o arquivo de nome fn e lê todo o seu conteúdo, devolvendo esse conteúdo sob a forma de uma cadeia de caracteres.
int GLSL_textFileWrite (char *fn, char *s)
 Essa função abre o arquivo de nome fn e escreve a cadeia de caracteres s como seu conteúdo.
void GLSL_texActivate (int numTextureObjects, TextureObject *textureObjects)
 Ativa um array de texturas de tamanho numTextureObjects. Ativar nesse caso significa ativar o mapeamento dessas texturas para um certo alvo (target). O alvo pode ser 1D, 2D, 3D ou um cube map, efetivamente formatando a textura para poder ser indexada de acordo com o alvo.
void GLSL_texDeactivate (int numTextureObjects, TextureObject *textureObjects)
 Desativa um array de texturas de tamanho numTextureObjects. Desativar nesse caso significa desligar o mapeamento dessas texturas de um certo alvo (target)..
void GLSL_activateARBProg (ARBProgram *prog)
 Ativar programa de shaders, usando a estrutura ARBProgram.
void GLSL_deactivateARBProg (ARBProgram *prog)
 Desativar programa de shaders, usando a estrutura ARBProgram.
void GLSL_init ()
void GLSL_raycastBackground (GLenum destinationBuffer)
 Faz raycasting no background.
void GLSL_renderVolume ()
void GLSL_raycastVolume ()

Variáveis

GLuint fragmentShader
GLuint program

Funções

void GLSL_activateARBProg ( ARBProgram *  prog  ) 

Ativar programa de shaders, usando a estrutura ARBProgram.

Parâmetros:
prog Programa a ser ativado.
Veja também:
ARBProgram.

Definição na linha 75 do arquivo carol_glsl.c.

00076 {       
00077         GLSL_texActivate(prog->numTextureObjects, prog->textureObjects);
00078         glEnable(prog->programType);
00079         glUseProgram(prog->id);
00080 }

void GLSL_deactivateARBProg ( ARBProgram *  prog  ) 

Desativar programa de shaders, usando a estrutura ARBProgram.

Parâmetros:
prog Programa a ser desativado.
Veja também:
ARBProgram.

Definição na linha 82 do arquivo carol_glsl.c.

00083 {       
00084         GLSL_texDeactivate(prog->numTextureObjects, prog->textureObjects);
00085         glDisable(prog->programType);
00086         glUseProgram(0);
00087 }

void GLSL_init (  ) 

Faz inicialização do programa de shaders, lendo o conteúdo de um arquivo, compilando e linkando um fragment program (pixel shader) ao programa.

Definição na linha 90 do arquivo carol_glsl.c.

00091 {
00092         char *fragmentShaderContent;
00093 
00094         fragmentShaderContent = GLSL_textFileRead("./glsl_volumeShaders/carol_raycasting.fp");
00095         const char *fragContent = fragmentShaderContent; 
00096 
00097         g.fragProgs[0].id = glCreateProgram();
00098 
00099         fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);    
00100         glShaderSource(fragmentShader, 1, &fragContent,NULL);
00101 
00102         free((void*)fragmentShader);
00103 
00104         glCompileShader(fragmentShader);
00105 
00106         glAttachShader(g.fragProgs[0].id,fragmentShader);
00107 
00108         glLinkProgram(g.fragProgs[0].id); 
00109 }

void GLSL_raycastBackground ( GLenum  destinationBuffer  ) 

Faz raycasting no background.

Parâmetros:
destinationBuffer Buffer de destino

Definição na linha 111 do arquivo carol_glsl.c.

00112 {
00113         GLdouble modelview[16], projection[16], vertizes[4][3];
00114         GLint viewport[4];
00115         GLdouble x, y, z;
00116         int i;
00117 
00118         float texelHeight = 1.0/(float)g.windowHeight;
00119         float texelWidth = 1.0/(float)g.windowWidth;
00120 
00121         GLSL_activateARBProg(g.currentFragProg);
00122 
00123         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
00124         glEnable(GL_CULL_FACE);
00125 
00126         glUniform4f(glGetUniformLocation(program, "params2"), g.u.texCoordScale, 0.0, 0.0, 0.0);
00127 
00128         glUniform4fv(glGetUniformLocation(program, "center"), 1, g.center);
00129 
00130         glUniform4f(glGetUniformLocation(program, "texMax"),   g.extents[0] * g.scaleFactors[0],
00131                             g.extents[1] * g.scaleFactors[1],
00132                             g.extents[2] * g.scaleFactors[2],
00133                             0.0);
00134 
00135         glUniform4fv(glGetUniformLocation(program, "scaleFactors"), 1, g.scaleFactors);
00136 
00137         glGetIntegerv(GL_VIEWPORT, viewport);
00138         glGetDoublev(GL_MODELVIEW_MATRIX, modelview);
00139         glGetDoublev(GL_PROJECTION_MATRIX, projection);
00140 
00141         for (i = 0; i < 4; i++) {
00142                 x = ((i&1)>>0) * viewport[2];
00143                 y = ((i&2)>>1) * viewport[3];
00144                 z = .5;
00145 
00146                 gluUnProject(x, y, z, modelview, projection, viewport,
00147                                          &vertizes[i][0], &vertizes[i][1], &vertizes[i][2]);
00148         }
00149 
00150         glBegin(GL_QUADS);
00151                 vertexv(vertizes[0]);
00152                 vertexv(vertizes[1]);
00153                 vertexv(vertizes[3]);
00154                 vertexv(vertizes[2]);
00155         glEnd();
00156 
00157         GLSL_deactivateARBProg(g.currentFragProg);
00158 
00159         glDrawBuffer(GL_BACK);
00160 }

void GLSL_raycastVolume (  ) 

Faz o raycasting no volume, ou seja, ativa o fragment program (pixel shader), depois passa as variáveis uniformes e desenha as primitivas na tela chamando GLSL_renderVolume, e por fim, desativa o pixel shader.

Definição na linha 177 do arquivo carol_glsl.c.

00178 {
00179         //glUseProgram(program);
00180         GLSL_activateARBProg(g.currentFragProg);
00181         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
00182         glDisable(GL_DEPTH_TEST);
00183 
00184         glEnable(GL_CULL_FACE);
00185 
00186         GLSL_renderVolume();
00187 
00188         GLSL_deactivateARBProg(g.currentFragProg);
00189         //glUseProgram(0);
00190 }

void GLSL_renderVolume (  ) 

Define quais variáveis da aplicação em OpenGL são passadas como parâmetros para o shader, sob a forma de variáveis uniformes (uniform variable). Depois, desenha primitivas gráficas (no caso, QUADS).

Definição na linha 161 do arquivo carol_glsl.c.

00162 {
00163         glUniform4f(glGetUniformLocation(program, "params"),  g.u.stepSize,
00164                                 g.u.gradScale, g.u.gradOffset, -5.0);
00165         glUniform4f(glGetUniformLocation(program, "params2"), g.u.texCoordScale, g.u.numIterations,
00166                             g.u.isoValue, 0);
00167         glUniform4fv(glGetUniformLocation(program, "center"), 1, g.center);
00168         glUniform4f(glGetUniformLocation(program, "texMax"),   g.extents[0] * g.scaleFactors[0],
00169                             g.extents[1] * g.scaleFactors[1],
00170                             g.extents[2] * g.scaleFactors[2],
00171                             0.0);
00172         glUniform4fv(glGetUniformLocation(program, "scaleFactors"), 1, g.scaleFactors);
00173 
00174         drawQuads();
00175 }

void GLSL_texActivate ( int  numTextureObjects,
TextureObject *  textureObjects 
)

Ativa um array de texturas de tamanho numTextureObjects. Ativar nesse caso significa ativar o mapeamento dessas texturas para um certo alvo (target). O alvo pode ser 1D, 2D, 3D ou um cube map, efetivamente formatando a textura para poder ser indexada de acordo com o alvo.

Parâmetros:
numTextureObjects Tamanho do array de texturas.
textureObjects Array de texturas.
Veja também:
TextureObject.

Definição na linha 52 do arquivo carol_glsl.c.

00053 {
00054         int i;
00055 
00056         for (i = 0; i < numTextureObjects; i++) {
00057                 glActiveTexture(GL_TEXTURE0 + textureObjects[i].texUnit);
00058                 glEnable(textureObjects[i].texture.target);
00059                 glBindTexture(textureObjects[i].texture.target,
00060                                           textureObjects[i].texture.id);
00061         }
00062 }

void GLSL_texDeactivate ( int  numTextureObjects,
TextureObject *  textureObjects 
)

Desativa um array de texturas de tamanho numTextureObjects. Desativar nesse caso significa desligar o mapeamento dessas texturas de um certo alvo (target)..

Parâmetros:
numTextureObjects Tamanho do array de texturas.
textureObjects Array de texturas.

Definição na linha 64 do arquivo carol_glsl.c.

00065 {       
00066         int i;
00067 
00068         for (i = 0; i < numTextureObjects; i++) {
00069                 glActiveTexture(GL_TEXTURE0 + textureObjects[i].texUnit);
00070                 glDisable(textureObjects[i].texture.target);
00071         }
00072 }

char* GLSL_textFileRead ( char *  fn  ) 

Essa função abre o arquivo de nome fn e lê todo o seu conteúdo, devolvendo esse conteúdo sob a forma de uma cadeia de caracteres.

Parâmetros:
fn Nome do arquivo.

Definição na linha 5 do arquivo carol_glsl.c.

00006 {
00007 
00008         FILE *fp;
00009         char *content = NULL;
00010 
00011         int count=0;
00012 
00013         if (fn != NULL) {
00014                 fp = fopen(fn,"rt");
00015 
00016                 if (fp != NULL) {
00017       
00018       fseek(fp, 0, SEEK_END);
00019       count = ftell(fp);
00020       rewind(fp);
00021 
00022                         if (count > 0) {
00023                                 content = (char *)malloc(sizeof(char) * (count+1));
00024                                 count = fread(content,sizeof(char),count,fp);
00025                                 content[count] = '\0';
00026                         }
00027                         fclose(fp);
00028                 }
00029         }
00030         return content;
00031 }

int GLSL_textFileWrite ( char *  fn,
char *  s 
)

Essa função abre o arquivo de nome fn e escreve a cadeia de caracteres s como seu conteúdo.

Parâmetros:
fn Nome do arquivo.
s Conteúdo a ser colocado no arquivo.

Definição na linha 33 do arquivo carol_glsl.c.

00034 {
00035 
00036         FILE *fp;
00037         int status = 0;
00038 
00039         if (fn != NULL) {
00040                 fp = fopen(fn,"w");
00041 
00042                 if (fp != NULL) {
00043                         
00044                         if (fwrite(s,sizeof(char),strlen(s),fp) == strlen(s))
00045                                 status = 1;
00046                         fclose(fp);
00047                 }
00048         }
00049         return(status);
00050 }

Variáveis

GLuint fragmentShader

Variável global que representa um pixel shader.

Definição na linha 3 do arquivo carol_glsl.c.

GLuint program

Variável global que representa um programa (conjunto de vertex e pixel shaders).

Definição na linha 3 do arquivo carol_glsl.c.

 Todos Estruturas de Dados Arquivos Funções Variáveis Definições de Tipos Enumerações Valores enumerados Definições e Macros
Gerado em Sat Dec 12 01:59:33 2009 para Carolina Simões Gomes (RA042533). Estudo de um framework para Raycasting em GPU por  doxygen 1.6.1