/**
* Generate a program that samples two textures into a pair of temporaries
* over and over.
*
* This should excersize case (1) of question (24) of the ARB_fragment_program
* spec without hitting case (2) at the same time.
*
* Note that the compiler could optimize out our inner TEX instructions
* since they've got the same coordinates. Assume the compiler isn't
* for now.
*/
static char *gen_temporary_source_indirections(int sample_count,
GLuint *progname)
{
char *prog;
char *pre =
"!!ARBfp1.0\n"
"TEMP val, val2, sample, sample2;\n"
"MOV val, fragment.color;\n"
"MOV val2, fragment.color;\n";
char *sample =
"TEX sample, val, texture[0], 2D;\n"
"TEX sample2, val2, texture[1], 2D;\n"
"MUL val, sample, sample2;\n"
"MUL val2, val2, val;\n";
char *post =
"MOV result.color, val;\n"
"END";
int i, instr_count;
instr_count = 2 + 4 * (sample_count - 1) + 1;
if (get_program_i(GL_MAX_PROGRAM_INSTRUCTIONS_ARB) < instr_count) {
printf("indirection count %d too low to generate program with "
"%d indirections and %d instructions\n",
get_program_i(GL_MAX_PROGRAM_INSTRUCTIONS_ARB),
sample_count, instr_count);
return NULL;
}
prog = malloc(strlen(pre) + strlen(sample) * (sample_count - 1) +
strlen(post) + 1);
if (prog == 0) {
printf("malloc failed.\n");
piglit_report_result(PIGLIT_FAIL);
exit(1);
}
sprintf(prog, "%s", pre);
for (i = 0; i < sample_count - 1; i++)
strcat(prog, sample);
strcat(prog, post);
*progname = piglit_compile_program(GL_FRAGMENT_PROGRAM_ARB, prog);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, *progname);
return prog;
}
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 ;
}
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);
}
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 )
{
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;
}
}
void tmu_isr(struct tmu_td *td)
{
unsigned int hmesh_idx,vmesh_idx;
int i;
struct tmu_vertex * srcmesh;
struct tmu_vertex * dstmesh;
srcmesh = td->srcmesh;
dstmesh = td->dstmesh;
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, td->srchres, td->srcvres, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, td->srcfbuf);
// glClear (GL_COLOR_BUFFER_BIT); /* Clear Screen */
glMatrixMode (GL_MODELVIEW); /* Select The Modelview Matrix */
glLoadIdentity (); /* Reset The Modelview Matrix */
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
if (td->chromakey != 0) {
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, shader_num);
}
glBegin(GL_TRIANGLE_STRIP);
for (hmesh_idx=0; hmesh_idx<=td->hmeshlast;hmesh_idx++)
{
for (vmesh_idx=0; vmesh_idx<=td->vmeshlast;vmesh_idx++)
{
glTexCoord2f((float) (srcmesh[index(hmesh_idx,vmesh_idx)].x)/1024.0 , (float) (srcmesh[index(hmesh_idx,vmesh_idx)].y)/512.0 );
// printf("POUET %d %d : %d %d\n" , hmesh_idx, vmesh_idx ,dstmesh[index(hmesh_idx,vmesh_idx)].x , dstmesh[index(hmesh_idx,vmesh_idx)].y);
glVertex2i( dstmesh[index(hmesh_idx,vmesh_idx)].x , dstmesh[index(hmesh_idx,vmesh_idx)].y);
}
}
glEnd();
glDisable(GL_FRAGMENT_PROGRAM_ARB);
}
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;
}
enum piglit_result
piglit_display(void)
{
static const GLfloat color[4] = { 0.0, 0.5, 0.0, 0.5 };
static const GLfloat good_color[4] = { 0.0, 1.0, 0.0, 1.0 };
static const GLfloat bad_color[4] = { 1.0, 0.0, 0.0, 1.0 };
enum piglit_result result = PIGLIT_PASS;
unsigned i;
glClear(GL_COLOR_BUFFER_BIT);
glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 0, bad_color);
glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 1, color);
glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 2, bad_color);
glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 3, bad_color);
for (i = 0; i < ARRAY_SIZE(progs); i++) {
const int x = 1 + (i * (BOX_SIZE + 1));
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, progs[i]);
glVertexAttrib2fvARB(1, & attrib[i * 2]);
piglit_draw_rect(x, 1, BOX_SIZE, BOX_SIZE);
if (!piglit_probe_pixel_rgb(x + (BOX_SIZE / 2),
1 + (BOX_SIZE / 2),
good_color)) {
if (! piglit_automatic)
printf("shader %u failed with attributes "
"%.1f, %.1f\n",
i,
attrib[(i * 2) + 0],
attrib[(i * 2) + 1]);
result = PIGLIT_FAIL;
}
}
piglit_present_results();
return result;
}
void
piglit_init(int argc, char **argv)
{
GLuint fs;
GLuint vp;
GLuint prog;
GLenum err;
if (piglit_get_gl_version() < 20) {
printf("Requires OpenGL 2.0\n");
piglit_report_result(PIGLIT_SKIP);
}
piglit_require_extension("GL_ARB_vertex_program");
fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_text);
prog = piglit_link_simple_program(fs, 0);
glUseProgram(prog);
glGenProgramsARB(1, &vp);
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, vp);
glProgramStringARB(GL_VERTEX_PROGRAM_ARB,
GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(vp_text),
(const GLubyte *) vp_text);
err = glGetError();
if (err != GL_INVALID_OPERATION) {
printf("Unexpected OpenGL error state 0x%04x with bad "
"vertex program (expected 0x%04x).\n",
err, GL_INVALID_OPERATION);
piglit_report_result(PIGLIT_FAIL);
}
glEnable(GL_VERTEX_PROGRAM_ARB);
/* Clear all GL error state.
*/
while (glGetError() != 0)
/* empty */ ;
}
static void Init( void )
{
GLint errnum;
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));
errnum = glGetError();
printf("glGetError = %d\n", errnum);
if (errnum != 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 );
glGenBuffersARB(1, &arrayObj);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, arrayObj);
glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts), verts, GL_STATIC_DRAW_ARB);
glVertexPointer( 4, GL_FLOAT, sizeof(verts[0]), 0 );
glColorPointer( 4, GL_FLOAT, sizeof(verts[0]), (void *)(4*sizeof(float)) );
}
void send_set_brush_vert_param(int i, int p, const float v[4])
{
struct brush *b = get_brush(i);
b->vert_param[p][0] = v[0];
b->vert_param[p][1] = v[1];
b->vert_param[p][2] = v[2];
b->vert_param[p][3] = v[3];
send_event(EVENT_SET_BRUSH_VERT_PARAM);
send_index(i);
send_index(p);
send_array(b->vert_param[p], 4, sizeof (float));
if (b->vert_prog && GL_has_vertex_program)
{
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, b->vert_prog);
glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB,
p, b->vert_param[p]);
}
}
GLRenderWidgetImplementation::GLRenderWidgetImplementation(VideoWidget*videoWidget, const QGLFormat &format) :
QGLWidget(format, videoWidget)
, m_program(0)
, m_yuvSupport(false)
, m_videoWidget(videoWidget)
{
makeCurrent();
glGenTextures(3, m_texture);
glProgramStringARB = (_glProgramStringARB) context()->getProcAddress(QLatin1String("glProgramStringARB"));
glBindProgramARB = (_glBindProgramARB) context()->getProcAddress(QLatin1String("glBindProgramARB"));
glDeleteProgramsARB = (_glDeleteProgramsARB) context()->getProcAddress(QLatin1String("glDeleteProgramsARB"));
glGenProgramsARB = (_glGenProgramsARB) context()->getProcAddress(QLatin1String("glGenProgramsARB"));
glActiveTexture = (_glActiveTexture) context()->getProcAddress(QLatin1String("glActiveTexture"));
m_hasPrograms = glProgramStringARB && glBindProgramARB && glDeleteProgramsARB && glGenProgramsARB && glActiveTexture;
if (m_hasPrograms) {
glGenProgramsARB(1, &m_program);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, m_program);
const GLbyte *gl_src = reinterpret_cast<const GLbyte *>(yuvToRgb);
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
int(strlen(yuvToRgb)), gl_src);
if (glGetError() != GL_NO_ERROR) {
glDeleteProgramsARB(1, &m_program);
m_hasPrograms = false;
} else {
m_yuvSupport = true;
}
}
QPalette palette;
palette.setColor(QPalette::Background, Qt::black);
setPalette(palette);
setAutoFillBackground(true);
// Videowidget always have this property to allow hiding the mouse cursor
setMouseTracking(true);
}
enum piglit_result
piglit_display(void)
{
static const GLfloat color[4] = { 0.0, 1.0, 0.0, 1.0 };
static const GLfloat bad_color[4] = { 1.0, 0.0, 0.0, 1.0 };
enum piglit_result result = PIGLIT_PASS;
unsigned i;
glClear(GL_COLOR_BUFFER_BIT);
glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 0, bad_color);
glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 1, color);
glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 2, color);
glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 3, color);
for (i = 0; i < ARRAY_SIZE(progs); i++) {
const int x = 1 + (i * (BOX_SIZE + 1));
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, progs[i]);
glEnable(GL_CLIP_PLANE0 + i);
piglit_draw_rect_tex(x, 1, BOX_SIZE, BOX_SIZE,
1.0, 1.0, -2.0, 0.0);
glDisable(GL_CLIP_PLANE0 + i);
if (!piglit_probe_pixel_rgb(x + (BOX_SIZE / 2) - 2,
1 + (BOX_SIZE / 2),
color)) {
result = PIGLIT_FAIL;
}
if (!piglit_probe_pixel_rgb(x + (BOX_SIZE / 2) + 2,
1 + (BOX_SIZE / 2),
clear_color)) {
result = PIGLIT_FAIL;
}
}
piglit_present_results();
return result;
}
GPUProgram *GPU_program_shader_create(GPUProgramType type, const char *code)
{
/* TODO(merwin): remove ARB program support (recode smoke shader in GLSL) */
GPUProgram *program;
GLint error_pos, is_native;
if (!(GLEW_ARB_fragment_program && type == GPU_PROGRAM_TYPE_FRAGMENT))
return NULL;
program = MEM_callocN(sizeof(GPUProgram), "GPUProgram");
switch (type) {
case GPU_PROGRAM_TYPE_FRAGMENT:
program->type = GL_FRAGMENT_PROGRAM_ARB;
break;
}
/* create the object and set its code string */
glGenProgramsARB(1, &program->prog);
glBindProgramARB(program->type, program->prog);
glProgramStringARB(program->type, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)strlen(code), code);
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &error_pos);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB, &is_native);
if ((error_pos == -1) && (is_native == 1)) {
return program;
}
else {
/* glGetError is set before that, clear it */
while (glGetError() != GL_NO_ERROR)
;
shader_print_errors("compile", (const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB), &code, 1);
MEM_freeN(program);
}
return NULL;
}
enum piglit_result
piglit_display(void)
{
static const GLfloat color[4] = { 0.0, 0.5, 0.0, 0.5 };
static const GLfloat bad_color[4] = { 1.0, 0.0, 0.0, 1.0 };
static const GLfloat good_color[4] = { 0.0, 1.0, 0.0, 1.0 };
static const GLfloat attrib[4][4] = {
{ 1.0, -37.0, 1.0, 68.2 },
{ -37.0, 1.0, 68.2, 1.0 },
};
enum piglit_result result = PIGLIT_PASS;
unsigned i;
glClear(GL_COLOR_BUFFER_BIT);
glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 0, bad_color);
glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 1, bad_color);
glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 2, color);
glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 3, bad_color);
for (i = 0; i < ARRAY_SIZE(progs); i++) {
const int x = 1 + (i * (BOX_SIZE + 1));
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, progs[i]);
glVertexAttrib4fvARB(1, attrib[i]);
piglit_draw_rect(x, 1, BOX_SIZE, BOX_SIZE);
if (!piglit_probe_pixel_rgb(x + (BOX_SIZE / 2),
1 + (BOX_SIZE / 2),
good_color)) {
result = PIGLIT_FAIL;
}
}
glutSwapBuffers();
return result;
}
enum piglit_result
piglit_display(void)
{
enum piglit_result result = PIGLIT_PASS;
const GLfloat expected[4] = { 0.5, 0.0, 0.0, 0.0 };
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, progs[0]);
glClear(GL_COLOR_BUFFER_BIT);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
piglit_draw_rect(0, 0, piglit_width, piglit_height);
if (!piglit_probe_pixel_rgb(piglit_width / 2,
piglit_height / 2,
expected))
result = PIGLIT_FAIL;
piglit_present_results();
return result;
}
/**
* Check that the constant parameter \name is equal to \val.
*
* Since we also test for derived state involving floating point computation
* don't test for strict equality but rather only check if the parameter's
* components are within and epsilon of their expected values.
*/
static bool
check_prg_param_(const float *val, const char *name)
{
char *vp_text;
const float green[3] = {0.0, 1.0, 0.0};
asprintf(&vp_text, vp_template, val[0], val[1], val[2], val[3], name);
GLuint prog = piglit_compile_program(GL_VERTEX_PROGRAM_ARB, vp_text);
free(vp_text);
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prog);
glClear(GL_COLOR_BUFFER_BIT);
piglit_draw_rect(-1, -1, 2, 2);
glDeleteProgramsARB(1, &prog);
if (piglit_probe_pixel_rgb_silent(piglit_width / 2, piglit_height / 2,
green, NULL))
return true;
printf("Failed parameter: '%s'.\n", name);
return false;
}
// 載入OpenGL ARB Fragment Program規格的組合語言
GLuint GutLoadFragmentProgramOpenGL_ASM(const char *filename)
{
char filename_fullpath[256];
sprintf(filename_fullpath, "%s%s", GutGetShaderPath(), filename);
unsigned int size = 0;
// 讀入檔案
unsigned char *buffer = (unsigned char *) GutLoadBinaryStream(filename_fullpath, &size);
if ( buffer==NULL )
{
return 0;
}
GLuint shader_id = 0;
// 產生一個shader物件
glGenProgramsARB(1, &shader_id);
// 使用新的shader物件, 並把它設定成fragment program物件
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, shader_id );
// 把組合語言指令載入shader物件中
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, size, buffer);
// 如果Shader中出現了任何錯誤
if ( GL_INVALID_OPERATION == glGetError() )
{
// Find the error position
GLint errPos;
glGetIntegerv( GL_PROGRAM_ERROR_POSITION_ARB, &errPos );
// errors and warnings string.
GLubyte *errString = (GLubyte *) glGetString(GL_PROGRAM_ERROR_STRING_ARB);
fprintf( stderr, "error at position: %d\n%s\n", errPos, errString );
// 讀取失敗, 釋放shader物件
glDeleteProgramsARB(1, &shader_id);
shader_id = 0;
}
// 把載入檔案的記憶體釋放
GutReleaseBinaryStream(buffer);
// shader_id代表新的shader物件
return shader_id;
}
GLuint GLProgramFactory::createARBProgram(const std::string& filename,
GLenum type)
{
// Get the file contents without NULL terminator
CharBufPtr buffer = getFileAsBuffer(filename, false);
// Bind the program data into OpenGL
GlobalOpenGL().assertNoErrors();
GLuint programID;
glGenProgramsARB(1, &programID);
glBindProgramARB(type, programID);
glProgramStringARB(
type,
GL_PROGRAM_FORMAT_ASCII_ARB,
GLsizei(buffer->size()),
&buffer->front()
);
// Check for GL errors and throw exception if there is a problem
if (GL_INVALID_OPERATION == glGetError())
{
GLint errPos;
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errPos);
const GLubyte* errString = glGetString(GL_PROGRAM_ERROR_STRING_ARB);
// Construct user-readable error string
std::string error("GL program error: ");
error += filename + "(" + string::to_string(errPos) + "): \n\n";
error += std::string(reinterpret_cast<const char*>(errString));
rConsoleError() << error << std::endl;
}
// Return the new program
return programID;
}
enum piglit_result
piglit_display(void)
{
static const GLfloat color[4] = { 0.0, 1.0, 0.0, 1.0 };
static const GLfloat bad_color[4] = { 1.0, 0.0, 0.0, 1.0 };
enum piglit_result result = PIGLIT_PASS;
unsigned i;
glClear(GL_COLOR_BUFFER_BIT);
glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 0, bad_color);
glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 1, color);
glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 2, color);
glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 3, color);
for (i = 0; i < ARRAY_SIZE(progs); i++) {
const int x = 1 + (i * (BOX_SIZE + 1));
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, progs[i]);
if (i == 0) {
glVertexAttrib4fARB(1, 1.0, 0.0, 0.0, 0.0);
} else {
glVertexAttrib4fARB(1, 0.0, 1.0, 2.0, 3.0);
}
piglit_draw_rect(x, 1, BOX_SIZE, BOX_SIZE);
if (!piglit_probe_pixel_rgb(x + (BOX_SIZE / 2),
1 + (BOX_SIZE / 2),
color)) {
result = PIGLIT_FAIL;
}
}
piglit_present_results();
return result;
}
static void Init(void)
{
GLint errnum;
GLuint prognum;
static const char *prog1 =
"!!ARBfp1.0\n"
"TEMP R1;\n"
"MOV R1, state.material.emission;\n"
"MUL R1, R1, {0.9}.x;\n"
"MOV result.color, R1;\n"
"END\n";
fprintf(stderr, "GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
fprintf(stderr, "GL_VERSION = %s\n", (char *) glGetString(GL_VERSION));
fprintf(stderr, "GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR));
fflush(stderr);
/* Setup the fragment program */
glGenProgramsARB(1, &prognum);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, prognum);
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(prog1), (const GLubyte *)prog1);
errnum = glGetError();
printf("glGetError = 0x%x\n", errnum);
if (errnum != GL_NO_ERROR) {
GLint errorpos;
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errorpos);
printf("errorpos: %d\n", errorpos);
printf("glError(GL_PROGRAM_ERROR_STRING_ARB) = %s\n",
(char *) glGetString(GL_PROGRAM_ERROR_STRING_ARB));
}
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glClearColor(0.0, 0.0, 1.0, 0.0);
}
/**
* Enable the shader.
*/
void GLShader::enable(void)
{
switch (shaderType()) {
case ST_GL_ARB_FRAGMENT_PROGRAM:
#ifdef ENABLE_ATI_TEXT_FRAGMENT_SHADER
case ST_GL_ATI_TEXT_FRAGMENT_SHADER:
#endif /* ENABLE_ATI_TEXT_FRAGMENT_SHADER */
{
if (m_ARB_program == 0)
break;
#ifdef ENABLE_ATI_TEXT_FRAGMENT_SHADER
const GLenum prgType = (shaderType() == ST_GL_ARB_FRAGMENT_PROGRAM
? GL_FRAGMENT_PROGRAM_ARB
: GL_TEXT_FRAGMENT_SHADER_ATI
);
#else /* !ENABLE_ATI_TEXT_FRAGMENT_SHADER */
const GLenum prgType = GL_FRAGMENT_PROGRAM_ARB;
#endif /* ENABLE_ATI_TEXT_FRAGMENT_SHADER */
// Enable the shader.
glEnable(prgType);
glBindProgramARB(prgType, m_ARB_program);
break;
}
case ST_GL_ATI_FRAGMENT_SHADER:
if (m_ATI_fragment_shader == 0)
break;
glEnable(GL_FRAGMENT_SHADER_ATI);
glBindFragmentShaderATI(m_ATI_fragment_shader);
break;
default:
break;
}
}
static void DoFrame(void)
{
int i;
glClearColor(0.3, 0.3, 0.3, 0.3);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
for(i = 0; i < NUM_PROGRAMS; ++i) {
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, FragProg[i]);
glPushMatrix();
glTranslatef(i/2, i%2, 0);
glBegin(GL_QUADS);
glVertex2f(0, 0);
glVertex2f(1, 0);
glVertex2f(1, 1);
glVertex2f(0, 1);
glEnd();
glPopMatrix();
}
}
bool ATITShader::loadFragmentShaderFromFile(const char* fragPath)
{
char fileNameBufferPix[512];
Con::expandScriptFilename(fileNameBufferPix, sizeof(fileNameBufferPix), fragPath);
const char* ps;
Stream *p = ResourceManager->openStream(fileNameBufferPix);
if(!p)
{
AssertWarn(false, avar("Failed to find ATIT fragment shader file: %s", fileNameBufferPix));
return false;
}
mPixelSourceStringLength = ResourceManager->getSize(fileNameBufferPix);
mPixelSourceString = (char *)dMalloc((mPixelSourceStringLength + 1) * sizeof(U8));
p->read(mPixelSourceStringLength, mPixelSourceString);
ResourceManager->closeStream(p);
glEnable(GL_TEXT_FRAGMENT_SHADER_ATI);
glGenProgramsARB(1, &mFragmentProgram);
glBindProgramARB(GL_TEXT_FRAGMENT_SHADER_ATI, mFragmentProgram);
glProgramStringARB(GL_TEXT_FRAGMENT_SHADER_ATI, GL_PROGRAM_FORMAT_ASCII_ARB, mPixelSourceStringLength, mPixelSourceString);
#if defined(TORQUE_DEBUG) || defined(SHADER_MANAGER_DEBUG)
const char* errorString = NULL;
errorString = (const char*)glGetString(GL_PROGRAM_ERROR_STRING_ARB);
Con::printf("Error string for %s is %s", fileNameBufferPix, errorString);
if(errorString && errorString[0] != '\0')
return false;
#endif
glDisable(GL_TEXT_FRAGMENT_SHADER_ATI);
mFragFilepath = StringTable->insert(fileNameBufferPix);
return true;
}
static void DoFrame(void)
{
int mask;
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glEnable(GL_FRAGMENT_PROGRAM_ARB);
for(mask = 1; mask < 16; ++mask) {
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, FragProg[mask-1]);
glPushMatrix();
glTranslatef((mask % 4), (mask / 4), 0.0);
glBegin(GL_QUADS);
glVertex2f(0, 0);
glVertex2f(1, 0);
glVertex2f(1, 1);
glVertex2f(0, 1);
glEnd();
glPopMatrix();
}
}
void GLRenderWidgetImplementation::paintEvent(QPaintEvent *)
{
QPainter painter(this);
m_drawFrameRect = m_videoWidget->calculateDrawFrameRect();
if (m_yuvSupport && frameIsSet()) {
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, m_program);
const float tx_array[] = { 0, 0, 1, 0, 1, 1, 0, 1};
const QRectF r = drawFrameRect();
const float v_array[] = { float(r.left()), float(r.top()), float(r.right()), float(r.top()), float(r.right()), float(r.bottom()), float(r.left()), float(r.bottom()) };
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, m_texture[0]);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, m_texture[1]);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, m_texture[2]);
glActiveTexture(GL_TEXTURE0);
glVertexPointer(2, GL_FLOAT, 0, v_array);
glTexCoordPointer(2, GL_FLOAT, 0, tx_array);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glDrawArrays(GL_QUADS, 0, 4);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glDisable(GL_FRAGMENT_PROGRAM_ARB);
} else {
painter.setRenderHint(QPainter::SmoothPixmapTransform);
painter.drawImage(drawFrameRect(), currentFrame());
}
frameRendered();
}
void PaletteRenderer::resetGLState(GLContextData& contextData) const
{
/* Get pointer to data item: */
DataItem* dataItem=contextData.retrieveDataItem<DataItem>(this);
if(dataItem->renderingPath==FragmentProgram)
{
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB,0);
glDisable(GL_FRAGMENT_PROGRAM_ARB);
}
else if(dataItem->renderingPath==TextureShader)
glDisable(GL_TEXTURE_SHADER_NV);
else
{
#ifdef __SGI_IRIX__
glDisable(GL_TEXTURE_COLOR_TABLE_SGI);
#endif
if(sharePalette)
glDisable(GL_SHARED_TEXTURE_PALETTE_EXT);
}
/* Call base class method: */
VolumeRenderer::resetGLState(contextData);
}
int main(void)
{
GLuint pid;
ALLEGRO_DISPLAY *d;
ALLEGRO_EVENT_QUEUE *queue;
ALLEGRO_EVENT event;
int frames = 0;
double start;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
return 1;
}
al_set_new_display_flags(ALLEGRO_OPENGL);
al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 1, ALLEGRO_SUGGEST);
al_set_new_display_option(ALLEGRO_SAMPLES, 4, ALLEGRO_SUGGEST);
d = al_create_display(WINDOW_W, WINDOW_H);
if (!d) {
abort_example("Unable to open a OpenGL display.\n");
return -1;
}
if (al_get_display_option(ALLEGRO_SAMPLE_BUFFERS)) {
printf("With multisampling, level %i\n", al_get_display_option(ALLEGRO_SAMPLES));
}
else {
printf("Without multisampling.\n");
}
al_install_keyboard();
queue = al_create_event_queue();
al_register_event_source(queue, al_get_keyboard_event_source());
al_register_event_source(queue, al_get_display_event_source(d));
if (al_get_opengl_extension_list()->ALLEGRO_GL_ARB_multisample) {
glEnable(GL_MULTISAMPLE_ARB);
}
if (!al_get_opengl_extension_list()->ALLEGRO_GL_ARB_vertex_program) {
abort_example("This example requires a video card that supports "
" the ARB_vertex_program extension.\n");
return -1;
}
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glDisable(GL_CULL_FACE);
/* Setup projection and modelview matrices */
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0, WINDOW_W/(float)WINDOW_H, 0.1, 100.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
/* Position the camera to look at our mesh from a distance */
gluLookAt(0.0f, 20.0f, -45.0f, 0.0f, 0.0f, 0.0f, 0, 1, 0);
create_mesh();
/* Define the vertex program */
glEnable(GL_VERTEX_PROGRAM_ARB);
glGenProgramsARB(1, &pid);
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, pid);
glGetError();
if (al_get_opengl_extension_list()->ALLEGRO_GL_NV_vertex_program2_option) {
glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(program_nv), program_nv);
}
else {
glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(program), program);
}
/* Check for errors */
if (glGetError()) {
const char *pgm = al_get_opengl_extension_list()->ALLEGRO_GL_NV_vertex_program2_option
? program_nv : program;
GLint error_pos;
const GLubyte *error_str = glGetString(GL_PROGRAM_ERROR_STRING_ARB);
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &error_pos);
abort_example("Error compiling the vertex program:\n%s\n\nat "
"character: %i\n%s\n", error_str, (int)error_pos,
pgm + error_pos);
return -1;
}
start = al_current_time();
while (1) {
if (!al_event_queue_is_empty(queue)) {
while (al_get_next_event(queue, &event)) {
switch (event.type) {
case ALLEGRO_EVENT_DISPLAY_CLOSE:
goto done;
case ALLEGRO_EVENT_KEY_DOWN:
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
goto done;
break;
}
}
}
draw_mesh();
al_flip_display();
frames++;
}
done:
printf("%.1f FPS\n", frames / (al_current_time() - start));
glDeleteProgramsARB(1, &pid);
al_destroy_event_queue(queue);
return 0;
}
//////////////////////////////////////////////////////////////////////
// renderQuad (sourced from FBO, assume the binding has already taken place)
//
//////////////////////////////////////////////////////////////////////
void CFrameBufferObject::renderQuad(int width, int height, GLenum eTarget)
{
#if 1
float width_norm = (float)width/(float)m_Width,
height_norm = (float)height/(float)m_Height;
// Bind the FBO texture for the display path
glBindTexture(eTarget, m_fboData.colorTex);
glGenerateMipmapEXT( GL_TEXTURE_2D );
glBindTexture(eTarget, 0);
// now render to the full screen using this texture
glClearColor(0.2f, 0.2f, 0.2f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, m_textureProgram );
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glDisable(GL_DEPTH_TEST);
glBegin(GL_QUADS);
{
glVertex2f(0.0f , 0.0f ); glTexCoord2f(0.0f , 0.0f );
glVertex2f(0.0f , height_norm); glTexCoord2f(width_norm, 0.0f );
glVertex2f(width_norm, height_norm); glTexCoord2f(width_norm, height_norm);
glVertex2f(width_norm, 0.0f ); glTexCoord2f(0.0f , height_norm);
}
glEnd();
// Release the FBO texture (finished rendering)
glBindTexture(eTarget, 0);
#else
// Bind the FBO texture for the display path
glBindTexture(eTarget, m_fboData.colorTex);
// render a screen sized quad
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glEnable(eTarget);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
glMatrixMode( GL_MODELVIEW);
glLoadIdentity();
glViewport(0, 0, width, height);
if (m_bUseFloat) {
// fragment program is required to display floating point texture
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, m_textureProgram );
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glDisable(GL_DEPTH_TEST);
}
glBegin(GL_QUADS);
if (eTarget == GL_TEXTURE_2D) {
glTexCoord2f(0.0f , 0.0f ); glVertex3f(-1.0f, -1.0f, 0.5f);
glTexCoord2f(1.0f , 0.0f ); glVertex3f( 1.0f, -1.0f, 0.5f);
glTexCoord2f(1.0f , 1.0f ); glVertex3f( 1.0f, 1.0f, 0.5f);
glTexCoord2f(0.0f , 1.0f ); glVertex3f(-1.0f, 1.0f, 0.5f);
} else {
glTexCoord2f(0.0f , 0.0f ); glVertex3f(-1.0f, -1.0f, 0.5f);
glTexCoord2f(width, 0.0f ); glVertex3f( 1.0f, -1.0f, 0.5f);
glTexCoord2f(width, height); glVertex3f( 1.0f, 1.0f, 0.5f);
glTexCoord2f(0.0f , height); glVertex3f(-1.0f, 1.0f, 0.5f);
}
glEnd();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glDisable(eTarget);
// Release the FBO texture (finished rendering)
glBindTexture(eTarget, 0);
#endif
}
// display results using OpenGL (called by GLUT)
void display()
{
sdkStartTimer(&timer);
// map PBO to get CUDA device pointer
uchar4 *d_output;
checkCudaErrors(cudaGraphicsMapResources(1, &cuda_pbo_resource, 0));
size_t num_bytes;
checkCudaErrors(cudaGraphicsResourceGetMappedPointer((void **)&d_output, &num_bytes,
cuda_pbo_resource));
render(imageWidth, imageHeight, tx, ty, scale, cx, cy,
blockSize, gridSize, g_FilterMode, d_output);
checkCudaErrors(cudaGraphicsUnmapResources(1, &cuda_pbo_resource, 0));
// Common display path
{
// display results
glClear(GL_COLOR_BUFFER_BIT);
#if USE_BUFFER_TEX
// display using buffer texture
glBindTexture(GL_TEXTURE_BUFFER_EXT, bufferTex);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, fprog);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glProgramLocalParameterI4iNV(GL_FRAGMENT_PROGRAM_ARB, 0, width, 0, 0, 0);
#else
// download image from PBO to OpenGL texture
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo);
glBindTexture(GL_TEXTURE_TYPE, displayTex);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexSubImage2D(GL_TEXTURE_TYPE,
0, 0, 0, width, height, GL_BGRA, GL_UNSIGNED_BYTE, 0);
glEnable(GL_TEXTURE_TYPE);
#endif
// draw textured quad
glDisable(GL_DEPTH_TEST);
glBegin(GL_QUADS);
glTexCoord2f(0.0f , (GLfloat)height);
glVertex2f(0.0f, 0.0f);
glTexCoord2f((GLfloat)width, (GLfloat)height);
glVertex2f(1.0f, 0.0f);
glTexCoord2f((GLfloat)width, 0.0f);
glVertex2f(1.0f, 1.0f);
glTexCoord2f(0.0f , 0.0f);
glVertex2f(0.0f, 1.0f);
glEnd();
glDisable(GL_TEXTURE_TYPE);
glDisable(GL_FRAGMENT_PROGRAM_ARB);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
if (drawCurves)
{
// draw spline curves
glPushMatrix();
glScalef(0.25, 0.25, 1.0);
glTranslatef(0.0, 2.0, 0.0);
glColor3f(1.0, 0.0, 0.0);
plotCurve(bspline_w3);
glTranslatef(1.0, 0.0, 0.0);
glColor3f(0.0, 1.0, 0.0);
plotCurve(bspline_w2);
glTranslatef(1.0, 0.0, 0.0);
glColor3f(0.0, 0.0, 1.0);
plotCurve(bspline_w1);
glTranslatef(1.0, 0.0, 0.0);
glColor3f(1.0, 0.0, 1.0);
plotCurve(bspline_w0);
glPopMatrix();
glColor3f(1.0, 1.0, 1.0);
}
}
glutSwapBuffers();
glutReportErrors();
sdkStopTimer(&timer);
computeFPS();
}
