static void initShader_phong ()
{
/*if (! glutExtensionSupported("GL_ARB_vertex_program"))
Fail("GL_ARB_vertex_program not available on this machine");
if (! glutExtensionSupported("GL_ARB_fragment_program"))
Fail("GL_ARB_fragment_program not available on this machine");*/
glEnable(GL_VERTEX_PROGRAM_ARB);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glGenProgramsARB(3, Shader);
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, Shader[0]);
glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(ShaderSrc[0]), ShaderSrc[0]);
checkShader(0);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, Shader[1]);
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(ShaderSrc[1]), ShaderSrc[1]);
checkShader(1);
/*glBindProgramARB(GL_VERTEX_PROGRAM_ARB, Shader[2]);
glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(ShaderSrc[2]), ShaderSrc[2]);
checkShader(2);*/
glDisable(GL_VERTEX_PROGRAM_ARB);
glDisable(GL_FRAGMENT_PROGRAM_ARB);
}
static void R_InitConverter( void )
{
const GLubyte *pError;
glGenProgramsARB( 1, &conv.vp );
glBindProgramARB( GL_VERTEX_PROGRAM_ARB, conv.vp );
glProgramStringARB( GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen( convVpCode ), convVpCode );
pError = glGetString( GL_PROGRAM_ERROR_STRING_ARB );
if( pError && pError[0] )
__debugbreak();
glBindProgramARB( GL_VERTEX_PROGRAM_ARB, 0 );
glGenProgramsARB( 1, &conv.fp );
glBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, conv.fp );
glProgramStringARB( GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen( convFpCode ), convFpCode );
pError = glGetString( GL_PROGRAM_ERROR_STRING_ARB );
if( pError && pError[0] )
__debugbreak();
glBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, 0 );
}
static void create_sphere_programs() {
GLint errpos ;
glGenProgramsARB(1, &sphere_vertex_program_id) ;
glBindProgramARB(GL_VERTEX_PROGRAM_ARB,sphere_vertex_program_id) ;
glProgramStringARB(
GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
(GLsizei)strlen(sphere_vertex_program_source), sphere_vertex_program_source
) ;
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errpos) ;
if(errpos != -1) {
const char* s = (const char*)(glGetString(GL_PROGRAM_ERROR_STRING_ARB)) ;
std::cerr << "vertex program ARB error" << ":" << errpos << ": " << s << std::endl ;
}
glGenProgramsARB(1, &sphere_fragment_program_id) ;
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB,sphere_fragment_program_id) ;
glProgramStringARB(
GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
(GLsizei)strlen(sphere_fragment_program_source), sphere_fragment_program_source
) ;
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errpos) ;
if(errpos != -1) {
const char* s = (const char*)(glGetString(GL_PROGRAM_ERROR_STRING_ARB)) ;
std::cerr << "fragment program ARB error" << ":" << errpos << ": " << s << std::endl ;
}
}
void PaletteRenderer::DataItem::updateTextureCache(const VolumeRenderer* renderer,int majorAxis)
{
/* Call the base class method: */
VolumeRenderer::DataItem::updateTextureCache(renderer,majorAxis);
if(renderingPath==FragmentProgram)
{
if(setParameters)
{
/* Upload the appropriate fragment program: */
if(has3DTextures&&renderer->getRenderingMode()==VIEW_PERPENDICULAR)
{
if(renderer->getTextureFunction()==REPLACE)
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB,GL_PROGRAM_FORMAT_ASCII_ARB,strlen(fp3),fp3);
else
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB,GL_PROGRAM_FORMAT_ASCII_ARB,strlen(fp4),fp4);
}
else
{
if(renderer->getTextureFunction()==REPLACE)
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB,GL_PROGRAM_FORMAT_ASCII_ARB,strlen(fp1),fp1);
else
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB,GL_PROGRAM_FORMAT_ASCII_ARB,strlen(fp2),fp2);
}
if(glGetError()==GL_INVALID_OPERATION)
{
GLint errorPos;
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB,&errorPos);
const GLubyte* error=glGetString(GL_PROGRAM_ERROR_STRING_ARB);
Misc::throwStdErr("Fragment program error \"%s\" at position %d",error,errorPos);
}
}
}
else if(renderingPath==PalettedTexture)
{
/* Check if the color map needs to be uploaded: */
const PaletteRenderer* paletteRenderer=static_cast<const PaletteRenderer*>(renderer);
/*************************************************************************
Another bug in SGI's OpenGL implementation: Though color maps are treated
as a texture object resource, they are not always installed when a texture
object is bound. Thus, we have to upload them manually everytime we bind;
painful and sloow.
*************************************************************************/
uploadColorMap=false;
#ifndef __SGI_IRIX__
if(uploadData||cachedColorMapVersion!=paletteRenderer->colorMapVersion)
#endif
{
cachedColorMapVersion=paletteRenderer->colorMapVersion;
textureCacheValid=false;
uploadColorMap=!paletteRenderer->sharePalette;
}
}
}
static void Init( void )
{
/* scale of 10.0 gives me a visible result on nv hardware.
*/
static const char *modulate2D =
"!!ARBfp1.0\n"
"TEMP R0;\n"
"MUL R0, fragment.position.z, {10.0}.x;\n"
"MOV result.color, R0; \n"
"END"
;
GLuint modulateProg;
if (!GLEW_ARB_fragment_program) {
printf("Error: GL_ARB_fragment_program not supported!\n");
exit(1);
}
printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
/* Setup the fragment program */
glGenProgramsARB(1, &modulateProg);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, modulateProg);
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(modulate2D), (const GLubyte *)modulate2D);
printf("glGetError = 0x%x\n", (int) glGetError());
printf("glError(GL_PROGRAM_ERROR_STRING_ARB) = %s\n",
(char *) glGetString(GL_PROGRAM_ERROR_STRING_ARB));
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glClearColor(.3, .3, .3, 0);
}
static GLuint
_arb_program_from_string(GLenum kind, int shader_flags, char const * source, size_t source_length, char * * out_error_message)
{
GLuint program;
glGenProgramsARB(1, &program);
glBindProgramARB(kind, program);
glProgramStringARB(kind, GL_PROGRAM_FORMAT_ASCII_ARB, source_length, source);
GLint error_position;
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &error_position);
if(error_position >= 0) {
const GLubyte * error_string = glGetString(GL_PROGRAM_ERROR_STRING_ARB);
asprintf(out_error_message, "Error in program at position %d: %s", error_position, error_string);
goto error;
}
glBindProgramARB(kind, 0);
return program;
error:
glBindProgramARB(kind, 0);
glDeleteProgramsARB(1, &program);
return 0;
}
/**
* The GL_ARB_fragment_shader spec, issue 23 says:
* (23) What is the result of a sample from an incomplete texture?
* The definition of texture completeness can be found in section 3.8.9
* of the core GL spec.
*
* RESOLVED: The result of a sample from an incomplete texture is the
* constant vector (0,0,0,1).
*
* In this test we swizzle RGBA->ABGR so we don't need to worry if the
* framebuffer has an alpha channel.
*/
GLboolean
test_arb_fp(void)
{
static const char *fragProgramText =
"!!ARBfp1.0\n"
"TEMP t1;\n"
"TEX t1, fragment.texcoord[0], texture[0], 2D;\n"
"MOV result.color, t1.abgr;\n"
"END\n";
static const GLfloat expected[4] = { 1.0, 0.0, 0.0, 0.0 };
int pos = 1;
GLboolean p;
GLuint prog;
glGenProgramsARB(1, &prog);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, prog);
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB,
GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(fragProgramText),
(const GLubyte *) fragProgramText);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glColor3f(0, 1, 0);
draw_rect(1);
glDisable(GL_FRAGMENT_PROGRAM_ARB);
glDeleteProgramsARB(1, &prog);
p = probe_pos(pos, expected);
if (!p)
printf(" Testing ARB fragment program\n");
return p;
}
static void Init( void )
{
GLint errno;
GLuint prognum;
static const char *prog1 =
"!!ARBvp1.0\n"
"MOV result.color, vertex.color;\n"
"MOV result.position, vertex.position;\n"
"END\n";
glGenProgramsARB(1, &prognum);
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prognum);
glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(prog1), (const GLubyte *) prog1);
assert(glIsProgramARB(prognum));
errno = glGetError();
printf("glGetError = %d\n", errno);
if (errno != GL_NO_ERROR)
{
GLint errorpos;
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errorpos);
printf("errorpos: %d\n", errorpos);
printf("%s\n", (char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB));
}
glEnableClientState( GL_VERTEX_ARRAY );
glEnableClientState( GL_COLOR_ARRAY );
glVertexPointer( 3, GL_FLOAT, sizeof(verts[0]), verts );
glColorPointer( 4, GL_UNSIGNED_BYTE, 0, color );
}
static void Init( void )
{
GLint errno;
GLuint prognum;
static const char *prog1 =
"!!ARBvp1.0\n"
"MOV result.color, vertex.color;\n"
/* "MOV result.color, {0,0,0,1};\n" */
"MOV result.position, vertex.position;\n"
"END\n";
glGenProgramsARB(1, &prognum);
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prognum);
glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(prog1), (const GLubyte *) prog1);
assert(glIsProgramARB(prognum));
errno = glGetError();
printf("glGetError = %d\n", errno);
if (errno != GL_NO_ERROR)
{
GLint errorpos;
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errorpos);
printf("errorpos: %d\n", errorpos);
printf("%s\n", (char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB));
}
}
static void Init( void )
{
static const char *modulate2D =
"!!ARBfp1.0\n"
"TEMP R0;\n"
"DP4 result.color, fragment.color.xxxx, fragment.color; \n"
"END"
;
GLuint modulateProg;
if (!glutExtensionSupported("GL_ARB_fragment_program")) {
printf("Error: GL_ARB_fragment_program not supported!\n");
exit(1);
}
printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
/* Setup the fragment program */
glGenProgramsARB(1, &modulateProg);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, modulateProg);
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(modulate2D), (const GLubyte *)modulate2D);
printf("glGetError = 0x%x\n", (int) glGetError());
printf("glError(GL_PROGRAM_ERROR_STRING_ARB) = %s\n",
(char *) glGetString(GL_PROGRAM_ERROR_STRING_ARB));
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glClearColor(.3, .3, .3, 0);
}
FragmentProgram::FragmentProgram(istream &is)
{
if (!GL_ARB_fragment_program_initialized) {
console::print(1, 0, 0, "Error(FragmentProgram): GL_ARB_fragment_program not initialized");
return;
}
string program;
char ch;
while (is.get(ch)) program += ch;
glGetError();
glGenProgramsARB(1, &id);
if (glGetError()) {
console::print(1.0, 0.0, 0.0, "Could not generate FragmentProgram id!");
return;
}
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, id);
glGetError();
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)program.size(), program.c_str());
if (glGetError()) {
console::print(1.0f, 0.0f, 0.0f, (char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB));
}
// TODO: throw exception on error
}
GLuint HCoreLoadFragmentProgramOpenGL_ASM(const char *filename)
{
char filename_fullpath[256];
sprintf(filename_fullpath, "%s%s", HCoreGetShaderPath(), filename);
unsigned int size = 0;
unsigned char *buffer = (unsigned char *) HCoreLoadBinaryStream(filename_fullpath, &size);
if ( buffer==NULL )
{
return 0;
}
GLuint shader_id = 0;
glGenProgramsARB(1, &shader_id);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, shader_id );
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, size, buffer);
if ( GL_INVALID_OPERATION == glGetError() )
{
GLint errPos;
glGetIntegerv( GL_PROGRAM_ERROR_POSITION_ARB, &errPos );
GLubyte *errString = (GLubyte *) glGetString(GL_PROGRAM_ERROR_STRING_ARB);
fprintf( stderr, "error at position: %d\n%s\n", errPos, errString );
glDeleteProgramsARB(1, &shader_id);
shader_id = 0;
}
HCoreReleaseBinaryStream(buffer);
return shader_id;
}
static void load_program(const char *prog, GLuint prognum)
{
int a;
GLint errorpos, errno;
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prognum);
glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(prog), (const GLubyte *) prog);
assert(glIsProgramARB(prognum));
errno = glGetError();
printf("glGetError = %d\n", errno);
if (errno != GL_NO_ERROR)
{
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errorpos);
printf("errorpos: %d\n", errorpos);
printf("%s\n", (char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB));
for (a=-10; a<10; a++)
{
if ((errorpos+a < 0) || (errorpos+a >= strlen(prog))) continue;
printf("%c", prog[errorpos+a]);
}
printf("\n");
exit(1);
}
}
void
piglit_init(int argc, char **argv)
{
static const char * program =
"!!ARBvp1.0\n"
"MOV result.color, vertex.color;\n"
"MOV result.position, vertex.position;\n"
"END\n";
GLuint program_no;
piglit_require_extension("GL_ARB_draw_elements_base_vertex");
piglit_require_extension("GL_ARB_vertex_program");
glGenProgramsARB(1, &program_no);
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, program_no);
glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(program), program);
assert(glIsProgramARB(program_no));
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, sizeof(vertices[0]), vertices);
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(4, GL_UNSIGNED_BYTE, 0, colors);
}
bool CVertexProgram::Load(const char* pCodeString)
{
m_uiProgram = 0;
m_bLoaded = false;
// load vertex programs
if (extgl_Extensions.ARB_vertex_program)
{
glGenProgramsARB(1, &m_uiProgram);
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, m_uiProgram);
glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(pCodeString), pCodeString);
const GLubyte* pError = glGetString(GL_PROGRAM_ERROR_STRING_ARB);
if (strlen((char*) pError) > 0)
{
fprintf(stderr, "Failed to compile vertex shader (%s)\n", pError);
m_uiProgram = 0;
}
else
{
fprintf(stderr, "successfully loaded vertex program\n");
m_bLoaded = true;
}
}
else
{
fprintf(stderr, "ARB_vertex_program extension not found (hardware or driver doesn't support hardware vertex shaders)\n");
m_uiProgram = 0;
}
return m_bLoaded;
}
static unsigned int LoadProgram(GLenum target, const char* filename, const char* program_type)
{
GLuint ret = 0;
if (!GLEW_ARB_vertex_program) {
return ret;
}
if (target == GL_FRAGMENT_PROGRAM_ARB && !GLEW_ARB_fragment_program) {
return ret;
}
CFileHandler file(std::string("shaders/") + filename);
if (!file.FileExists ()) {
char c[512];
SNPRINTF(c, 512, "[myGL::LoadProgram] Cannot find %s-program file '%s'", program_type, filename);
throw content_error(c);
}
int fSize = file.FileSize();
char* fbuf = new char[fSize + 1];
file.Read(fbuf, fSize);
fbuf[fSize] = '\0';
glGenProgramsARB(1, &ret);
glBindProgramARB(target, ret);
glProgramStringARB(target, GL_PROGRAM_FORMAT_ASCII_ARB, fSize, fbuf);
if (CheckParseErrors(target, filename, fbuf)) {
ret = 0;
}
delete[] fbuf;
return ret;
}
uint LoadFragmentProgram(string fn)
{
int len;
char* buf=LoadTextFile (fn, len);
if(!buf) return 0;
uint ret;
glGenProgramsARB( 1, &ret );
glBindProgramARB( GL_FRAGMENT_PROGRAM_ARB,ret);
glProgramStringARB( GL_FRAGMENT_PROGRAM_ARB,GL_PROGRAM_FORMAT_ASCII_ARB,len,buf);
if ( GL_INVALID_OPERATION == glGetError() )
{
// Find the error position
GLint errPos;
glGetIntegerv( GL_PROGRAM_ERROR_POSITION_ARB,&errPos );
// Print implementation-dependent program
// errors and warnings string.
const GLubyte *errString=glGetString( GL_PROGRAM_ERROR_STRING_ARB);
fltk::message("Error at position %d when loading fragment program file %s:\n%s",errPos,fn.c_str(),errString);
return 0;
}
return ret;
}
static void initShaders ()
{
int err;
char* FragSrc = textFileRead(FragLoc);
if (FragSrc == NULL){
printf("ERROR:Src Prog is %s\n",FragSrc);
}
if (! glutExtensionSupported("GL_ARB_vertex_program"))
Fail("GL_ARB_vertex_program not available on this machine");
if (! glutExtensionSupported("GL_ARB_fragment_program"))
Fail("GL_ARB_fragment_program not available on this machine");
/* Fragment shader */
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, &FragShader);
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(FragSrc), FragSrc);
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &err);
if (err >= 0)
printf("Error in fragment shader %s\n",
glGetString(GL_PROGRAM_ERROR_STRING_ARB));
free(FragSrc);
}
bool Viewer::loadVertexProgram()
{
glGenProgramsARB( 1, &m_vertexProgramId );
glBindProgramARB( GL_VERTEX_PROGRAM_ARB, m_vertexProgramId );
glProgramStringARB( GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(vertexProgramStr), vertexProgramStr );
if ( GL_INVALID_OPERATION == glGetError() )
{
// Find the error position
GLint errPos;
glGetIntegerv( GL_PROGRAM_ERROR_POSITION_ARB,
&errPos );
// Print implementation-dependent program
// errors and warnings string.
const unsigned char *errString = glGetString( GL_PROGRAM_ERROR_STRING_ARB);
fprintf( stderr, "error at position: %d\n%s\n",
errPos, errString );
return false;
}
glBindProgramARB( GL_VERTEX_PROGRAM_ARB, 0 );
return true;
}
bool VertexShaderCache::CompileVertexShader(VERTEXSHADER& vs, const char* pstrprogram)
{
// Reset GL error before compiling shaders. Yeah, we need to investigate the causes of these.
GLenum err = GL_REPORT_ERROR();
if (err != GL_NO_ERROR)
{
ERROR_LOG(VIDEO, "glError %08x before VS!", err);
}
#if defined HAVE_CG && HAVE_CG
char stropt[64];
sprintf(stropt, "MaxLocalParams=256,MaxInstructions=%d", s_nMaxVertexInstructions);
const char *opts[] = {"-profileopts", stropt, "-O2", "-q", NULL};
CGprogram tempprog = cgCreateProgram(g_cgcontext, CG_SOURCE, pstrprogram, g_cgvProf, "main", opts);
if (!cgIsProgram(tempprog)) {
if (s_displayCompileAlert) {
PanicAlert("Failed to create vertex shader");
s_displayCompileAlert = false;
}
cgDestroyProgram(tempprog);
ERROR_LOG(VIDEO, "Failed to load vs %s:", cgGetLastListing(g_cgcontext));
ERROR_LOG(VIDEO, "%s", pstrprogram);
return false;
}
if (cgGetError() != CG_NO_ERROR)
{
WARN_LOG(VIDEO, "Failed to load vs %s:", cgGetLastListing(g_cgcontext));
WARN_LOG(VIDEO, "%s", pstrprogram);
}
// This looks evil - we modify the program through the const char * we got from cgGetProgramString!
// It SHOULD not have any nasty side effects though - but you never know...
char *pcompiledprog = (char*)cgGetProgramString(tempprog, CG_COMPILED_PROGRAM);
char *plocal = strstr(pcompiledprog, "program.local");
while (plocal != NULL) {
const char* penv = " program.env";
memcpy(plocal, penv, 13);
plocal = strstr(plocal + 13, "program.local");
}
glGenProgramsARB(1, &vs.glprogid);
SetCurrentShader(vs.glprogid);
glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)strlen(pcompiledprog), pcompiledprog);
err = GL_REPORT_ERROR();
if (err != GL_NO_ERROR) {
ERROR_LOG(VIDEO, "%s", pstrprogram);
ERROR_LOG(VIDEO, "%s", pcompiledprog);
}
cgDestroyProgram(tempprog);
#endif
#if defined(_DEBUG) || defined(DEBUGFAST)
vs.strprog = pstrprogram;
#endif
return true;
}
enum piglit_result
piglit_display(void)
{
static const char *fp_source =
"!!ARBfp1.0\n"
"TEX result.color, fragment.texcoord[0], texture[1], 2D;\n"
"END\n";
bool pass = true;
GLuint tex;
GLuint prog;
texrect_w = piglit_width / 4 / 2;
texrect_h = piglit_height / 2;
glGenProgramsARB(1, &prog);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, prog);
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB,
GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(fp_source),
(const GLubyte *) fp_source);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glActiveTexture(GL_TEXTURE1);
tex = piglit_rgbw_texture(GL_RGBA, 2, 2, false, false,
GL_UNSIGNED_NORMALIZED);
/* Given that the failure mode we had that led to this test
* being written was that the sampler state read was
* pseudo-random, go through several statechanges on the
* sampler to make sure we're reliably getting our sampler
* state.
*/
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
piglit_draw_rect_tex(-1, -1, 0.5, 2,
0, 0, 1, 1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
piglit_draw_rect_tex(-0.5, -1, 0.5, 2,
0, 0, 1, 1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
piglit_draw_rect_tex(0, -1, 0.5, 2,
0, 0, 1, 1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
piglit_draw_rect_tex(0.5, -1, 0.5, 2,
0, 0, 1, 1);
pass = pass && test_nearest(piglit_width * 0 / 4);
pass = pass && test_linear(piglit_width * 1 / 4);
pass = pass && test_nearest(piglit_width * 2 / 4);
pass = pass && test_linear(piglit_width * 3 / 4);
piglit_present_results();
glDeleteTextures(1, &tex);
glDisable(GL_FRAGMENT_PROGRAM_ARB);
glDeleteProgramsARB(1, &prog);
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
void ATITShader::resurrect()
{
glEnable(GL_VERTEX_PROGRAM_ARB);
glEnable(GL_TEXT_FRAGMENT_SHADER_ATI);
glGenProgramsARB(1, &mVertexProgram);
glGenProgramsARB(1, &mFragmentProgram);
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, mVertexProgram);
glBindProgramARB(GL_TEXT_FRAGMENT_SHADER_ATI, mFragmentProgram);
glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, mVertexSourceStringLength, mVertexSourceString);
glProgramStringARB(GL_TEXT_FRAGMENT_SHADER_ATI, GL_PROGRAM_FORMAT_ASCII_ARB, mPixelSourceStringLength, mPixelSourceString);
glDisable(GL_VERTEX_PROGRAM_ARB);
glDisable(GL_TEXT_FRAGMENT_SHADER_ATI);
}
int buildprog(const char *prog,bool vtxorfrg)
{
GLuint progid=0;
#if defined(GL_ARB_vertex_program) && defined(GL_ARB_fragment_program)
GLint errorPos,isNative;
glGenProgramsARB(1,&progid);
if (vtxorfrg)
{
glBindProgramARB(GL_VERTEX_PROGRAM_ARB,progid);
glProgramStringARB(GL_VERTEX_PROGRAM_ARB,GL_PROGRAM_FORMAT_ASCII_ARB,strlen(prog),prog);
}
else
{
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB,progid);
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB,GL_PROGRAM_FORMAT_ASCII_ARB,strlen(prog),prog);
}
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB,&errorPos);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB,GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB,&isNative);
if (errorPos==0)
{
WARNMSG("shader programs unavailable");
WARNMSG((char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB));
ERRORMSG();
}
else
{
if (errorPos!=-1)
{
WARNMSG((char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB));
ERRORMSG();
}
if (isNative!=1) WARNMSG("shader program non-native");
}
#endif
return(progid);
}
bool CgUtil::MakeHaloShader(int pow) {
char fp[10096];
sprintf(fp,"\
!!ARBfp1.0\n\
\n\
ATTRIB data = fragment.texcoord; \n\
\n\
TEMP tmp,tmp2,tmp3, t,t0,t1,t2,nor,n,nabs,nsign,disp,res,depth,pos,\n\
lighting; \n\
\n\
MOV nor, data; \n\
MUL tmp, data, data; \n\
ADD tmp2.x, tmp.x, tmp.y;\n\
ADD tmp2.z, -tmp2.x, 1;\n\
KIL tmp2.z;\n\
\n\
MAD tmp2.x, -data.z, tmp2.x, data.z;\n\
\n\
#TEST!\n\
#ADD tmp2.x, tmp2.x, %10.8f;\n\
#CMP result.color, tmp2.x, {1,0,0,1}, {0,0,1,1};\n\
\n\
MUL tmp, fragment.position, {%14.12f, %14.12f, 0, 0};\n\
#MAD tmp, fragment.position, {0.5, 0.5, 0, 0}, {0.5, 0.5, 0, 0};\n\
TEX tmp.z, tmp, texture[1], 2D; # tmp.z = old depth \n\
ADD tmp.z, tmp.z, -fragment.position.z; \n\
MUL_SAT tmp.z, tmp.z, program.env[0].x; \n\
MUL tmp.z, tmp.z, tmp2.x; \n\
MUL tmp.z, tmp.z, tmp2.x; # again for smoother edges\n\
", +P_halo_str-1, 1.0f/(1<<pow), 1.0f/(1<<pow) );
if (P_halo_str<1.0) {
sprintf(fp,"%sMUL tmp.z , tmp.z, %10.8f;\n",fp, P_halo_str );
}
if (!doingAlphaSnapshot)
sprintf(fp,"%sMAD result.color, {0,0,0,1}, tmp.z, {%5.4f,%5.4f,%5.4f,0.0} ;\n",fp,P_halo_col,P_halo_col,P_halo_col);
else {
if (P_halo_col==1.0) // white halo
sprintf(fp,"%sMOV result.color, tmp.z;\n",fp);
else
sprintf(fp,"%sMUL result.color, {0,0,0,1}, tmp.z;\n",fp);
}
sprintf(fp,"%sEND\n",fp);
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(fp), fp);
// printf("\n-------<fp HALO>--------\n%s",fp);
if(!checkProgramError(fp)) return false;
return true;
}
void CgUtil::LoadVertexHaloShader() {
char vp[10096];
sprintf(vp,"\
!!ARBvp1.0\n\
\n\
ATTRIB pos = vertex.position;\n\
ATTRIB dataA = vertex.texcoord[0];\n\
ATTRIB dataB = vertex.texcoord[1];\n\
\n\
");
sprintf(vp,"%s\
\n\
PARAM mat[4] = { state.matrix.mvp };\n\
PARAM matP[4] = { state.matrix.projection };\n\
\n\
TEMP p,po, disp, dataout, tmp;\n\
\n\
# Transform by concatenation of the\n\
# MODELVIEW and PROJECTION matrices.\n\
DP4 p.x, mat[0], pos;\n\
DP4 p.y, mat[1], pos;\n\
DP4 p.z, mat[2], pos;\n\
DP4 p.w, mat[3], pos;\n\
#MOV p.w, 1; \n\
\n\
MOV dataout, dataA;\n\
MOV dataout.z, dataB.y;\n\
", vp);
sprintf(vp,"%s\
\n\
MUL disp, dataA, dataB.x; \n\
MUL disp, disp, program.env[0].x; \n\
#MUL disp.x, disp.x, matP[0].x;\n\
#MUL disp.y, disp.y, matP[1].y;\n\
MAD p, {1,1,0,0}, disp, p;\n\
", vp);
sprintf(vp,"%sMOV result.position, p;\n",vp);
sprintf(vp,"%sMOV result.texcoord, dataout;\n",vp);
sprintf(vp,"%s\nEND\n", vp);
glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(vp), vp);
//printf("\n--------<vp ball>---------\n%s",vp);
//if(!checkProgramError(vp)) return -1;
//return true;
}
void GPUProgram::loadProgram(const std::string& code) const {
switch (extension) {
case NVIDIA:
glLoadProgramNV(unit, glProgram, code.size(), (const unsigned char*)code.c_str());
break;
case ARB:
glProgramStringARB(unit, GL_PROGRAM_FORMAT_ASCII_ARB, code.size(), code.c_str());
break;
}
}
//-------------------------------------------------------------
// ARBProgram::loadShader() load shader
//-------------------------------------------------------------
bool ARBProgram::loadShader(char *source, CGLShader *shader){
shader->setActive();
shader->bind();
glProgramStringARB (shader->getProgramType(), GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(source), source);
if (glGetError () == GL_INVALID_OPERATION ){
//String errorString = gl.glGetString ( GL.GL_PROGRAM_ERROR_STRING_ARB );
// System.out.println("GPU shader error >> " + errorString);
return false;
}
return true;
}
void
setup_arb_program()
{
char vert[] =
"!!ARBvp1.0\n"
"OPTION ARB_position_invariant;\n"
"MOV result.color, { 1.0, 1.0, 1.0, 1.0 };"
"END";
GLuint vert_prog;
glGenProgramsARB(1, &vert_prog);
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, vert_prog);
glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(vert), vert);
glEnable(GL_VERTEX_PROGRAM_ARB);
}
GLuint compileASMShader(GLenum program_type, const char *code)
{
GLuint program_id;
glGenProgramsARB(1, &program_id);
glBindProgramARB(program_type, program_id);
glProgramStringARB(program_type, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei) strlen(code), (GLubyte *) code);
GLint error_pos;
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &error_pos);
if (error_pos != -1) {
const GLubyte *error_string;
error_string = glGetString(GL_PROGRAM_ERROR_STRING_ARB);
shrLog("Program error at position: %d\n%s\n", (int)error_pos, error_string);
return 0;
}
return program_id;
}
static void Init( void )
{
static const char *modulate2D =
"!!ARBfp1.0\n"
"TEMP R0;\n"
"TEX R0, fragment.texcoord[0], texture[0], 2D; \n"
"MUL result.color, R0, fragment.color; \n"
"END"
;
GLuint modulateProg;
GLuint Texture;
if (!glutExtensionSupported("GL_ARB_fragment_program")) {
printf("Error: GL_ARB_fragment_program not supported!\n");
exit(1);
}
printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
/* Setup the fragment program */
glGenProgramsARB(1, &modulateProg);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, modulateProg);
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(modulate2D), (const GLubyte *)modulate2D);
printf("glGetError = 0x%x\n", (int) glGetError());
printf("glError(GL_PROGRAM_ERROR_STRING_ARB) = %s\n",
(char *) glGetString(GL_PROGRAM_ERROR_STRING_ARB));
assert(glIsProgramARB(modulateProg));
glEnable(GL_FRAGMENT_PROGRAM_ARB);
/* Load texture */
glGenTextures(1, &Texture);
glBindTexture(GL_TEXTURE_2D, Texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
if (!LoadRGBMipmaps(TEXTURE_FILE, GL_RGB)) {
printf("Error: couldn't load texture image file %s\n", TEXTURE_FILE);
exit(1);
}
/* XXX this enable shouldn't really be needed!!! */
glEnable(GL_TEXTURE_2D);
glClearColor(.3, .3, .3, 0);
}