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 ;
}
}
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 );
}
bool CgUtil::BindHaloShader(int pow) {
if (idfHalo[pow]==666) glGenProgramsARB(1, &(idfHalo[pow]));
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, idfHalo[pow]);
if (!loadedHalo[pow]) MakeHaloShader(pow);
if (idvHalo==666) glGenProgramsARB(1, &idvHalo);
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, idvHalo);
if (!loadedVertexHalo) LoadVertexHaloShader();
loadedHalo[pow]=true;
loadedVertexHalo=true;
return true;
}
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;
}
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 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 )
{
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 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);
}
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
}
GLArbGpuProgram::GLArbGpuProgram(ResourceManager* creator, const String& name,
ResourceHandle handle, const String& group, bool isManual,
ManualResourceLoader* loader)
: GLGpuProgram(creator, name, handle, group, isManual, loader)
{
glGenProgramsARB(1, &mProgramID);
}
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);
}
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;
}
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);
}
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;
}
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;
}
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;
}
CGLMProgram::CGLMProgram( GLMContext *ctx, EGLMProgramType type )
{
m_ctx = ctx;
m_ctx->CheckCurrent();
m_type = type;
m_serial = g_shader_serial++;
m_text = NULL; // no text yet
#if GLMDEBUG
m_editable = NULL;
#endif
memset( &m_descs, 0, sizeof( m_descs ) );
m_samplerMask = 0; // dxabstract sets this field later
// create an ARB vp/fp program object name. No need to bind it yet.
GLMShaderDesc *arbDesc = &m_descs[ kGLMARB ];
glGenProgramsARB( 1, &arbDesc->m_object.arb );
// create a GLSL shader object.
GLMShaderDesc *glslDesc = &m_descs[ kGLMGLSL ];
GLenum glslStage = GLMProgTypeToGLSLEnum( m_type );
glslDesc->m_object.glsl = glCreateShaderObjectARB( glslStage );;
// no text has arrived yet. That's done in SetProgramText.
}
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);
}
ARBShaderObject::ARBShaderObject(
unsigned int shType,
const std::string& shSrc,
const std::string& shSrcDefs
): IShaderObject(shType, shSrc)
{
assert(globalRendering->haveARB); // non-debug check is done in ShaderHandler
glGenProgramsARB(1, &objID);
}
void GPUProgram::genPrograms(int num, unsigned int* id) const {
switch (extension) {
case NVIDIA:
alwaysAssertM(glGenProgramsNV != NULL, "Requires an NVIDIA card with the GL_NV_vertex_program extension");
glGenProgramsNV(num, id);
break;
case ARB:
glGenProgramsARB(num, id);
break;
}
}
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 loadProgramARB(GLenum target, const GLubyte *code) {
GLuint program_id ;
glGenProgramsARB(1, &program_id) ;
glBindProgramARB(target,program_id) ;
glProgramStringARB(
GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)strlen((const char*)code), (const char*)code
) ;
GLint errpos ;
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errpos) ;
bool ok = ( errpos == -1) ;
if(!ok) {
const char* s = (const char*)(glGetString(GL_PROGRAM_ERROR_STRING_ARB)) ;
std::cerr << "pixel_program_ARB error"
<< ":" << errpos << ": " << s << std::endl ;
}
return program_id ;
}
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);
}
static void Init( void )
{
GLint errno;
GLuint prognum;
GLint i;
static const char *prog1 =
"!!ARBvp1.0\n"
"MOV result.color, {1.0}.xxxx;\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 );
for (i = 0; i < NR_VERTS; i++) {
verts[i][0] = cos(i / (float)NR_VERTS * 2.0 * 3.141592);
verts[i][1] = sin(i / (float)NR_VERTS * 2.0 * 3.141592);
verts[i][2] = 0.0;
verts[i][3] = 1.0;
indices[2*i+0] = i;
indices[2*i+1] = (i+1 == NR_VERTS) ? 0 : i+1;
}
}
Shader::Shader(GLenum _target, const char *program, bool fromFile):id(0),target(_target)
{
if (!program || !strlen(program)) {
ok = true;
return;
}
const char *progtext;
if (fromFile) {
char *buf;
FILE *f = fopen(program, "rb");
if (!f) {
ok = false;
return;
}
fseek(f, 0, SEEK_END);
size_t len = ftell(f);
fseek(f, 0, SEEK_SET);
buf = new char[len+1];
progtext = buf;
fread(buf, len, 1, f);
buf[len]=0;
fclose(f);
//gLog("Len: %d\nShader text:\n[%s]\n",len,progtext);
if( buf )
{
delete[] buf;
buf = NULL;
}
} else progtext = program;
glGenProgramsARB(1, &id);
glBindProgramARB(target, id);
glProgramStringARB(target, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)strlen(progtext), progtext);
if (glGetError() != 0) {
int errpos;
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errpos);
LogError << "Error loading shader: " << glGetString(GL_PROGRAM_ERROR_STRING_ARB) << std::endl;
LogError << "Error position: " << errpos << std::endl;
ok = false;
} else ok = true;
}
