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

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "basic_defs.h"
#include "arbprogram.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_raycastBackground (GLenum destinationBuffer)
 Faz raycasting no background.
void GLSL_init ()
void GLSL_renderVolume ()
void GLSL_raycastVolume ()

Variáveis

GLuint fragmentShader
GLuint program

Descrição Detalhada

Classe que reúne funcionalidades modificadas em relação ao framework original.

Neste arquivo, funções do framework original que foram modificadas estão declaradas. Seus nomes são idênticos aos nomes das funções que substituem, com o prefixo GLSL sendo a única diferença.

Definição no arquivo carol_glsl.h.

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