Hello
I’m now transferring texture to fragment shader.
But it’s still not working.
here is my (test)shader :
#extension GL_ARB_texture_rectangle : enable
uniform sampler2DRect depthTex;
void main(void)
{
float depth=texture2DRect(depthTex,gl_FragCoord.xy).x;
gl_FragColor = gl_Color; // c'est aussi simple que cela
gl_FragDepth=float;
}
and here how i try to exchange data :
program = LoadProgram(NULL, "test.frag");
glUseProgram(program);
glActiveTexture (GL_TEXTURE1);
glBindTexture (GL_TEXTURE_2D, txDepth);
depthTexLoc = glGetUniformLocation(program, "depthTex");
glBindTexture (GL_TEXTURE_2D, txDepth);
glUniform1i(depthTexLoc, 1);
some used fonctions :
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <GL/glew.h> /* utilisation de glew ! */
#include "loadprogram.h"
int ExtensionSupportee(const char *nom)
{
#ifndef __glew_h__
const char *extensions = glGetString(GL_EXTENSIONS);
#endif
if(
#ifdef __glew_h__
glewIsSupported(nom)
#else
strstr(extensions, nom) != NULL
#endif
)
return 1;
else
{
fprintf(stderr, "extension %s non supportee
", nom);
return 0;
}
}
int InitExtensions(void)
{
int state = 1;
if(!ExtensionSupportee("GL_ARB_shading_language_100") ||
!ExtensionSupportee("GL_ARB_shader_objects") ||
!ExtensionSupportee("GL_ARB_vertex_shader") ||
!ExtensionSupportee("GL_ARB_fragment_shader")
/* rajoutez ici les extensions que vous utiliserez */)
{
state = 0;
}
return state;
}
/* charge le code source d'un shader */
static char* LoadSource(const char *filename)
{
char *src = NULL; /* code source de notre shader */
FILE *fp = NULL; /* fichier */
long size; /* taille du fichier */
long i; /* compteur */
/* on ouvre le fichier */
fp = fopen(filename, "r");
/* on verifie si l'ouverture a echoue */
if(fp == NULL)
{
fprintf(stderr, "impossible d'ouvrir le fichier '%s'
", filename);
return NULL;
}
/* on recupere la longueur du fichier */
fseek(fp, 0, SEEK_END);
size = ftell(fp);
/* on se replace au debut du fichier */
rewind(fp);
/* on alloue de la memoire pour y placer notre code source */
src = malloc(size+1); /* +1 pour le caractere de fin de chaine '\0' */
if(src == NULL)
{
fclose(fp);
fprintf(stderr, "erreur d'allocation de memoire!
");
return NULL;
}
/* lecture du fichier */
for(i=0; i<size; i++)
src[i] = fgetc(fp);
/* on place le dernier caractere a '\0' */
src[size] = '\0';
fclose(fp);
return src;
}
GLuint LoadProgram(const char *vsname, const char *psname)
{
GLuint prog = 0;
GLuint vs = 0, ps = 0;
GLint link_status = GL_TRUE;
GLint logsize = 0;
char *log = NULL;
/* verification des arguments */
if(vsname == NULL && psname == NULL)
{
fprintf(stderr, "creation d'un program demande, mais aucuns "
"noms de fichiers source envoye, arret.
");
return 0;
}
/* chargement des shaders */
if(vsname != NULL)
{
vs = LoadShader(GL_VERTEX_SHADER, vsname);
if(vs == 0)
return 0;
}
if(psname != NULL)
{
ps = LoadShader(GL_FRAGMENT_SHADER, psname);
if(ps == 0)
{
if(glIsShader(vs))
glDeleteShader(vs);
return 0;
}
}
/* creation du program */
prog = glCreateProgram();
/* on envoie nos shaders a notre program */
if(vs)
glAttachShader(prog, vs);
if(ps)
glAttachShader(prog, ps);
/* on lie le tout */
glLinkProgram(prog);
/* on verifie que tout s'est bien passe */
glGetProgramiv(prog, GL_LINK_STATUS, &link_status);
if(link_status != GL_TRUE)
{
glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &logsize);
log = malloc(logsize + 1);
if(log == NULL)
{
glDeleteProgram(prog);
glDeleteShader(vs);
glDeleteShader(ps);
fprintf(stderr, "impossible d'allouer de la memoire!
");
return 0;
}
memset(log, '\0', logsize + 1);
glGetProgramInfoLog(prog, logsize, &logsize, log);
fprintf(stderr, "impossible de lier le program :
%s", log);
free(log);
glDeleteProgram(prog);
glDeleteShader(vs);
glDeleteShader(ps);
return 0;
}
/* les shaders sont dans le program maintenant, on en a plus besoin */
glDeleteShader(vs);
glDeleteShader(ps);
return prog;
}
GLuint LoadShader(GLenum type, const char *filename)
{
GLuint shader = 0;
GLsizei logsize = 0;
GLint compile_status = GL_TRUE;
char *log = NULL;
char *src = NULL;
/* creation d'un shader de sommet */
shader = glCreateShader(type);
if(shader == 0)
{
fprintf(stderr, "impossible de creer le shader
");
return 0;
}
/* chargement du code source */
src = LoadSource(filename);
if(src == NULL)
{
/* theoriquement, la fonction LoadSource a deja affiche un message
d'erreur, nous nous contenterons de supprimer notre shader
et de retourner 0 */
glDeleteShader(shader);
return 0;
}
/* assignation du code source */
glShaderSource(shader, 1, (const GLchar**)&src, NULL);
/* compilation du shader */
glCompileShader(shader);
/* liberation de la memoire du code source */
free(src);
src = NULL;
/* verification du succes de la compilation */
glGetShaderiv(shader, GL_COMPILE_STATUS, &compile_status);
if(compile_status != GL_TRUE)
{
/* erreur a la compilation recuperation du log d'erreur */
/* on recupere la taille du message d'erreur */
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logsize);
/* on alloue un esapce memoire dans lequel OpenGL ecrira le message */
log = malloc(logsize + 1);
if(log == NULL)
{
fprintf(stderr, "impossible d'allouer de la memoire!
");
return 0;
}
/* initialisation du contenu */
memset(log, '\0', logsize + 1);
glGetShaderInfoLog(shader, logsize, &logsize, log);
fprintf(stderr, "impossible de compiler le shader '%s' :
%s",
filename, log);
/* ne pas oublier de liberer la memoire et notre shader */
free(log);
glDeleteShader(shader);
return 0;
}
return shader;
}
but i always get 0 values.
so i try this :
#extension GL_ARB_texture_rectangle : enable
uniform float alpha;
void main(void)
{
gl_FragColor = gl_Color; // c'est aussi simple que cela
gl_FragDepth=alpha;
}
with this :
program = LoadProgram(NULL, "test.frag");
glUseProgram(program);
lphaParam = glGetUniformLocation(program, "alpha");
glUniform1i(alphaParam, 0.666);
still give me 0.
any idea?