Jump to content
  • Advertisement
Sign in to follow this  
GloW_on_dub

OpenGL [GLSL]transfer texture to fragment shader

This topic is 3022 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

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\n", 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'\n", 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!\n");

        return NULL;

    }

    

    /* lecture du fichier */

    for(i=0; i<size; i++)

        src = 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.\n");

        

        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!\n");

            return 0;

        }

        memset(log, '\0', logsize + 1);

        glGetProgramInfoLog(prog, logsize, &logsize, log);

        

        fprintf(stderr, "impossible de lier le program :\n%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\n");

        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!\n");

            return 0;

        }

        /* initialisation du contenu */

        memset(log, '\0', logsize + 1);

        

        glGetShaderInfoLog(shader, logsize, &logsize, log);

        fprintf(stderr, "impossible de compiler le shader '%s' :\n%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?

Share this post


Link to post
Share on other sites
Advertisement
Hello!
I don't know if you've found a solution, but I have an article which could help you: http://www.lighthouse3d.com/opengl/glsl/index.php?texture

Share this post


Link to post
Share on other sites
0 is a valid location since its the first and only uniform in your fragment program. If you get -1, then you know something is wrong. As far as I can see, the code looks correct. However, one thing I found out when doing GLSL shader code and debugging is that if a variable is not used in the shader to derive the output somehow, then its optimized out by the compiler. For example, even if you sample from you texture and don't use the return value to produce the output of the fragment program, then calling glGetUniform will return -1 for the sampler location. What does gl_FragDepth=float; do ? I'm assuming you left something out since you can't assign a type as a value.

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

We are the game development community.

Whether you are an indie, hobbyist, AAA developer, or just trying to learn, GameDev.net is the place for you to learn, share, and connect with the games industry. Learn more About Us or sign up!

Sign me up!