/home/carolina/workspace/spvolren_cpu/arbprogram.c

Vá para a documentação deste arquivo.

/*
 * Copyright (c) 2005  Institute for Visualization and Interactive
 * Systems, University of Stuttgart, Germany
 *
 * This source code is distributed as part of the single-pass volume
 * rendering project. Details about this project can be found on the
 * project web page at http://www.vis.uni-stuttgart.de/eng/research/
 * fields/current/spvolren. This file may be distributed, modified,
 * and used free of charge as long as this copyright notice is
 * included in its original form. Commercial use is strictly
 * prohibited.
 *
 * Filename: arbprogram.c
 * 
 */

#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <glh/glh_extensions.h>
#if defined WIN32
#include <io.h>
#include <direct.h>
#else
#include <unistd.h>
#include <dirent.h>
#endif

#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>

#include "arbprogram.h"
#include "tools.h"
#include "sysconf.h"


#define VP_HEADER               "!!ARBvp"
#define FP_HEADER               "!!ARBfp"

#define TEXTURE_MARKER  "#!"

static int arbpCompare(const void *p1, const void *p2)
{
        ARBProgram *fp1, *fp2;

        fp1 = (ARBProgram *)p1;
        fp2 = (ARBProgram *)p2;

        return strcmp(fp1->filename, fp2->filename);
}

static int loadProgram(ARBProgram *prog, int numTextures, Texture *textures)
{
        const GLubyte *error_string;
        TextureObject *textureObject;
        int i, textureUnit, found;
        char textureName[256];
    GLint error_pos;
        char *cp;

        if (strstr(prog->prog, VP_HEADER) == prog->prog) {
                prog->programType = GL_VERTEX_SHADER;
        } else if (strstr(prog->prog, FP_HEADER) == prog->prog) {
                prog->programType = GL_FRAGMENT_SHADER;
        } else {
                fprintf(stderr, "unknown program type\n");
                exit(1);
        }

        prog->numTextureObjects = 0;
        prog->textureObjects = NULL;

        cp = prog->prog;
        while (*cp) {
                while (*cp && *cp != '\n' && *cp != '\r') {
                        cp++;
                }
                if (*cp && (*cp == '\n' || *cp == '\r')) {
                        cp++;
                }
                if (strstr(cp, TEXTURE_MARKER) == cp) {
                        cp += 2;
                        if (sscanf(cp, "%s=", textureName) != 1) {
                                fprintf(stderr, "parse error in file %s\n",
                                                prog->filename);
                                exit(1);
                        }
                        cp = strchr(cp, '=') + 1;
                        if (sscanf(cp, "%i", &textureUnit) != 1) {
                                fprintf(stderr, "parse error in file %s: %s\n",
                                                prog->filename, cp);
                                exit(1);
                        }
                        prog->numTextureObjects++;
                        if (! (prog->textureObjects = (TextureObject *)realloc(
                                                                                                prog->textureObjects,
                                                                                                prog->numTextureObjects *
                                                                                                sizeof(TextureObject)))) {
                                fprintf(stderr, "not enough memory for texture objects\n");
                                exit(1);
                        }
                        textureObject = &prog->textureObjects[prog->numTextureObjects - 1];
                        textureObject->texUnit = textureUnit;

                        found = 0;
                        for (i = 0; i < numTextures; i++) {
                                if (! strcmp(textureName, textures[i].name)) {
                                        textureObject->texture = textures[i];
                                        found = 1;
                                        break;
                                }
                        }
                        if (! found) {
                                fprintf(stderr, "invalid texture name '%s' in program %s\n",
                                                textureName, prog->filename);
                                exit(1);
                        }
                }
        }

        glEnable(prog->programType);

    /*glGenProgramsARB(1, &prog->id);
    glBindProgramARB(prog->programType, prog->id);
    glProgramStringARB(prog->programType, GL_PROGRAM_FORMAT_ASCII_ARB, 
                                           (GLsizei)strlen(prog->prog), (GLubyte *)prog->prog);

    glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &error_pos);
    if (error_pos != -1) {
        error_string = glGetString(GL_PROGRAM_ERROR_STRING_ARB);
        fprintf(stderr, "%s", (char *) error_string);

                return 0;
    }*/

        glDisable(prog->programType);

    return 1;
}

ARBProgram loadARBProg(const char *filename, int numTextures, Texture *textures)
{
        ARBProgram prog;
        int fd;
        struct stat statbuf;
        char *fnp;

        if (! (fnp = strrchr(filename, DIR_SEP))) {
            fnp = (char *) filename;
        } else {
            fnp++;
        }

        if (! (prog.filename = strdup(fnp))) {
                fprintf(stderr, "cannot duplicate filename\n");
                exit(1);
        }       

#if defined WIN32
        if ((fd = open(filename, O_RDONLY | O_BINARY)) < 0) {
#else
        if ((fd = open(filename, O_RDONLY)) <  0) {
#endif
                perror("opening file failed");
                exit(1);
        }

        if (fstat(fd, &statbuf) < 0) {
                fprintf(stderr, "failed to get file stats of %s\n", 
                                filename);
        }

        prog.size = statbuf.st_size;

        if (! (prog.prog = (char *)malloc(prog.size + 1))) {
                fprintf(stderr, "not enough memory for "
                                "program\n");
                exit(1);
        }
        
        if (read(fd, prog.prog, prog.size) != prog.size) {
                fprintf(stderr, "reading file %s failed\n",
                                prog.filename);
                exit(1);
        }
        prog.prog[prog.size] = '\0';

        if (! loadProgram(&prog, numTextures, textures)) {
                fprintf(stderr, "exiting due to parse error in program "
                                "'%s'\n", prog.filename);
                exit(1);
        }
        close(fd);

        return prog;
}

#if ! defined WIN32
void loadARBProgs(char *directory, char *extension, 
                                  int numTextures, Texture *textures,
                                  int *numProgs, ARBProgram **progs)
{
        ARBProgram *prog;
        struct dirent *entry;
        struct stat statbuf;
        DIR *dp;
    char *file;

        *numProgs = 0;
        *progs = NULL;

        fprintf(stderr, "\nloading programs ...\n");

        if ((dp = opendir(directory)) == NULL) {
                fprintf(stderr, "cannot open current directory\n");
                return;
        }

        while((entry = readdir(dp))) {
            if (! (file = (char *)malloc(strlen(directory) + strlen(entry->d_name) + 2))) {
                fprintf(stderr, "not enough memory for file template\n");
                exit(1);
            }
            strcpy(file, directory);
            if (!endsWith(directory, "/")) {
                strcat(file, "/");
            }
            strcat(file, entry->d_name);
                lstat(file, &statbuf);
                if (S_ISREG(statbuf.st_mode)) {
                        if (endsWith(entry->d_name, extension)) {
                                (*numProgs)++;
                                if (! (*progs = (ARBProgram *)realloc(*progs, 
                                                          *numProgs * sizeof(ARBProgram)))) {
                                        fprintf(stderr, "not enough memory for "
                                                        "program structures\n");
                                        exit(1);
                                }
                                prog = &(*progs)[*numProgs - 1];

                                *prog = loadARBProg(file, numTextures, textures);
                        }
                }
            free(file);
        }
        closedir(dp);

        if (! *numProgs) {
                fprintf(stderr, "no programs found\n");
                exit(1);
        }

        fprintf(stderr, "\n");

        /* Sort the programs according to their names since otherwise the
           order will continuously change when editing the files */
        qsort(*progs, *numProgs, sizeof(ARBProgram), arbpCompare);
}
#else
void loadARBProgs(char *directory, char *extension, 
                                  int numTextures, Texture *textures,
                                  int *numProgs, ARBProgram **progs)
{
        struct _finddata_t fd;
        ARBProgram *prog;
        char *files, *cwd;
        intptr_t handle;
        
        *numProgs = 0;
        *progs = NULL;

        fprintf(stderr, "\nloading programs ...\n");

        if (endsWith(directory, "\\")) {
                directory[strlen(directory) - 1] = '\0';
        }

        if (! (files = (char *)malloc(strlen(directory) + 3 +
                                                                         strlen(extension)))) {
                fprintf(stderr, "not enough memory for file template\n");
                exit(1);
        }
        if (!(cwd = _getcwd(NULL, 256))) {
                fprintf(stderr, "Failed to get current working directory\n");
                exit(1);
        }
        if (_chdir(directory) != 0) {
                fprintf(stderr, "directory '%s' not found\n", directory);
        }
        sprintf(files, ".\\*%s", extension);
        if ((handle = _findfirst(files, &fd)) == -1) {
                fprintf(stderr, "no programs found in %s\n", files);
                return;
        }
        
        free(files);

        do {
                (*numProgs)++;
                if (! (*progs = (ARBProgram *)realloc(*progs,
                                                *numProgs * sizeof(ARBProgram)))) {
                        fprintf(stderr, "not enough memory for "
                                        "program structures\n");
                        exit(1);
                }
                prog = &(*progs)[*numProgs - 1];

                *prog = loadARBProg(fd.name, numTextures, textures);
        } while(! _findnext(handle, &fd));

        if (! *numProgs) {
                fprintf(stderr, "no programs found\n");
                exit(1);
        }

        /* restore working directory */
        if (_chdir(cwd) != 0) {
                fprintf(stderr, "Failed to restore working directory\n");
                exit(1);
        }
        free(cwd);

        fprintf(stderr, "\n");

        /* Sort the programs according to their names since otherwise the
           order will continously change when editing the files */
        qsort(*progs, *numProgs, sizeof(ARBProgram), arbpCompare);
}
#endif

void activateARBProg(ARBProgram *prog) 
{       
        texActivate(prog->numTextureObjects, prog->textureObjects);
        glEnable(prog->programType);
        glBindProgramARB(prog->programType, prog->id);
}

void deactivateARBProg(ARBProgram *prog) 
{       
        texDeactivate(prog->numTextureObjects, prog->textureObjects);
        glDisable(prog->programType);
        glBindProgramARB(prog->programType, 0);
}

---