glhelpers.cpp

OPENGL2.0用于ARM11 3D处理

#include "stdafx.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <float.h>
#include "glHelpers.h"
//#include "buffers.h"
//#include "glContext.h"

#include <vector>
#include <list>

#define GLES2LIB
#define EN_REG_DUMP 1


ghShader::ghShader(const char* text, const unsigned int* bin,  int binLen, int binCS)
{
    textShader = text;
    binShader = bin;
    binShaderLen = sizeof(int) * binLen; //added shariq for converting the size in byte
    binShaderCheckSum = binCS;
}

ghShader::ghShader()
{
    textShader = 0;
    binShader = 0;
    binShaderLen = 0;
    binShaderCheckSum = 0;
}



ghProgram::ghProgram(ghShader vertShaderObject, ghShader fragShaderObject)
{
    vertShader = vertShaderObject;
    fragShader = fragShaderObject;

    loadShadersFromFile = false;

    prog = 0;
    vs = 0;
    fs = 0;

    progUsed = false;

    //_registerProgram(this);
}
    

//Loading from files is only supported on WIN32

ghProgram::ghProgram(const char* vsFileName, const char* fsFileName)
{

    vsFile = vsFileName;
    fsFile = fsFileName;
    loadShadersFromFile = true;
    
    prog = 0;
    vs = 0;
    fs = 0;
}


ghProgram::~ghProgram()
{
    reset();

}

GLint ghProgram::loc(const char* varName)
{
	//TODO: implement a cache? (not for performance but will it help in isolating bugs in gl lib?)
	return glGetUniformLocation(prog, varName);
}

void ghProgram::bindAttribLoc(int index, const char* attribName)
{

    std::string s(attribName);
    
    unsigned int i=0;
    
    for(i=0; i<attribBindings.size(); i++)
    {
        if(attribBindings[i].attribName == s)
        {
            attribBindings[i].index = index;
            break;
        }
    }
    if(i==attribBindings.size())
    {
        attribBindings.push_back(AttribBinding(s,index));
    }
}

void ghProgram::reset()
{
    if(prog)
    {
        glDeleteProgram(prog);
    }

    if(vs)
    {
        glDeleteShader(vs);
    }

    if(fs)
    {
        glDeleteShader(fs);
    }
    
    prog = 0;
    vs = 0;
    fs = 0;
}

int ghProgram::reload()
{
    if(progUsed)
    {
    return    load();
    }
    
    return 0;
}



void checkGLerror(const char* location)
{
    GLenum err = glGetError();
    
    const char* errString = 0;
    switch(err)
    {
        case GL_NO_ERROR:           errString = "GL_NO_ERROR"; break;
        case GL_INVALID_ENUM:       errString = "GL_INVALID_ENUM"; break;
        case GL_INVALID_VALUE:      errString = "GL_INVALID_VALUE"; break;
        case GL_INVALID_OPERATION:  errString = "GL_INVALID_OPERATION"; break;
        case GL_STACK_OVERFLOW:     errString = "GL_STACK_OVERFLOW"; break;
        case GL_STACK_UNDERFLOW:    errString = "GL_STACK_UNDERFLOW"; break;
        case GL_OUT_OF_MEMORY:      errString = "GL_OUT_OF_MEMORY"; break;
        case GL_INVALID_FRAMEBUFFER_OPERATION: errString = "GL_INVALID_FRAMEBUFFER_OPERATION"; break;
        default:                    errString = "UNKNOWN ERROR!!"; break;
    }

    if(err != GL_NO_ERROR)
    {
        printf("%s: %s\n", location,errString);
       // __asm int 3;
    }
	
}

void checkFBStatus(const char* location)
{
    GLenum fbStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER);

    const char* statusString = 0;
    switch(fbStatus)
    {
    case GL_FRAMEBUFFER_COMPLETE: 
        statusString = "GL_FRAMEBUFFER_COMPLETE"; break;   
    case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: 
        statusString = "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT"; break;
    case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: 
        statusString = "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"; break;
//    case GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT: 
//        statusString = "GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT"; break;
    case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS: 
        statusString = "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS"; break;
    case GL_FRAMEBUFFER_INCOMPLETE_FORMATS: 
        statusString = "GL_FRAMEBUFFER_INCOMPLETE_FORMATS"; break;
    case GL_FRAMEBUFFER_UNSUPPORTED: 
        statusString = "GL_FRAMEBUFFER_UNSUPPORTED"; break;
//    case GL_FRAMEBUFFER_STATUS_ERROR: 
//        statusString = "GL_FRAMEBUFFER_STATUS_ERROR"; break;
    default:
        statusString = "UNKNOWN!"; break;
    }

    printf("@%s FBstatus :%s\n", location, statusString);
}

extern "C" unsigned char* binFileRead(const char*fn, unsigned int* len){

	FILE* fp;
	unsigned char* content = NULL;
	if(fn!=NULL) 
	{
		fp = fopen(fn,"rb");
		if(fp!=NULL) {
			fseek(fp,0,SEEK_END);
			*len = ftell(fp);
			fseek(fp,0,SEEK_SET);

			if(*len > 0) {
				content = (unsigned char*)malloc(sizeof(unsigned char)* (*len));
				*len = fread(content,sizeof(unsigned char),*len, fp);
			}
			fclose(fp);
		}
		else{
			printf("\nERROR: unable to open file %s for reading\n", fn);
		}
	}

	return content;
}

//Taken from lighthouse3d's tut..
extern "C" char *textFileRead(const char *fn) {


	FILE *fp;
	char *content = NULL;

	int count=0;

    if (fn != NULL) {
		fp = fopen(fn,"rt");

        if (fp != NULL) {
      
      fseek(fp, 0, SEEK_END);
      count = ftell(fp);
      fseek(fp,0,SEEK_SET);

			if (count > 0) {
				content = (char *)malloc(sizeof(char) * (count+1));
				count = fread(content,sizeof(char),count,fp);
				content[count] = '\0';
			}
            //printf("SOURCE:%s\n",content);
			fclose(fp);
		}
        else
        {
            printf("\nERROR: unable to open file %s for reading\n", fn);
        }
	}
   
	return content;
}

int ghProgram::load()
{
    progUsed = true;
    //if(!this->vs)
    {
        this->reset();//to be safe
        this->vs = glCreateShader(GL_VERTEX_SHADER);
        this->fs = glCreateShader(GL_FRAGMENT_SHADER);
        this->prog = glCreateProgram();

            
        glAttachShader(this->prog, this->fs);
        checkGLerror();

        glAttachShader(this->prog, this->vs);
        checkGLerror();
    }



    if(this->loadShadersFromFile)
    {
#ifndef GLES2LIB
        const char* vsText = textFileRead(this->vsFile);
        const char* fsText = textFileRead(this->fsFile);
        if(vsText && fsText)
        {
            printf("\nReloading: %s, %s\n",this->vsFile, this->fsFile);
            glShaderSource(this->fs, 1, &(fsText) , NULL);
            checkGLerror("Post fs text shader load");

            glShaderSource(this->vs, 1, &(vsText) , NULL);
            checkGLerror("Post fs text shader load");

            free((void*)vsText);
            free((void*)fsText);
        }
        else
        {
            printf("Program load failed, one or more shader files not found\n");
            return 0;
        }
#else
		unsigned int vsBinLen=0;
		unsigned int fsBinLen=0;
		char fname[512];
		sprintf(fname,"%s.bin",vsFile);
		const unsigned char* vsBin = binFileRead(fname, &vsBinLen);
		sprintf(fname,"%s.bin",fsFile);
		const unsigned char* fsBin = binFileRead(fname, &fsBinLen);
		glShaderBinary(1, &this->fs, (GLenum)0, fsBin, fsBinLen);
		checkGLerror("Post fs bin load (from filesystem)");
		glShaderBinary(1, &this->vs, (GLenum)0, vsBin, vsBinLen);
		checkGLerror("Post vs bin load (from filesystem)");
#endif

    }
    else
    {
#ifndef GLES2LIB
        glShaderSource(this->fs, 1, &(this->fragShader.textShader) , NULL);
        checkGLerror("Post fs text shader load");

        glShaderSource(this->vs, 1, &(this->vertShader.textShader) , NULL);
        checkGLerror("Post fs text shader load");
#else

    isCheckSumValid(this->fragShader.binShader, this->fragShader.binShaderLen,
        this->fragShader.binShaderCheckSum,"Fragment Shader");
    isCheckSumValid(this->vertShader.binShader, this->vertShader.binShaderLen,
        this->vertShader.binShaderCheckSum,"Vertex Shader");

    glShaderBinary(1, &this->fs, (GLenum)0, this->fragShader.binShader, this->fragShader.binShaderLen);
    checkGLerror("Post fs bin load");

    glShaderBinary(1, &this->vs, (GLenum)0, this->vertShader.binShader, this->vertShader.binShaderLen);
    checkGLerror("Post vs bin load");
#endif
	}


    for(unsigned int i=0; i<this->attribBindings.size(); i++)
    {
        glBindAttribLocation(this->prog, this->attribBindings[i].index, this->attribBindings[i].attribName.c_str());
    }

    glLinkProgram(this->prog);
    checkGLerror();

    static char buff[4000];
    int len;
    glGetProgramInfoLog(this->prog, sizeof(buff), &len, buff);

    printf("\nProgram info log:\n%s\n", buff);
    fflush(stdout);
    
    glUseProgram(this->prog);
    checkGLerror("set current program");
    
    return 1;
}

/*****************************************************************************************/

//TODO: remove this and use c++ swap
void tswap(float& a, float& b)
{
	
	float temp = a;
	a = b;
	b = temp;	
}

/* element order reference:
	m[0]  m[4]  m[8]   m[12]
	m[1]  m[5]  m[9]   m[13]
	m[2]  m[6]  m[10]  m[14]
	m[3]  m[7]  m[11]  m[15]
*/


extern "C" void matTranspose(float* m)
{
	tswap(m[1],m[4]); 	tswap(m[2],m[8]); 	tswap(m[3],m[12]);
						tswap(m[6],m[9]);      tswap(m[7],m[13]);
											tswap(m[11],m[14]);
}


extern "C" void matIdentity(float m[16])
{
	for(int i=0; i<16; i++)
	{
		m[i] = (i%5==0)? 1.0f : 0.0f;  //The first and every fifth element after that is 1.0 other are 0.0
	}
}

/*
#ifndef fabs
float fabs(float f)
{
	return (f >0)? f : -f;
}
#endif
*/