void GLAPIENTRY
_mesa_ProgramStringARB(GLenum target, GLenum format, GLsizei len,
const GLvoid *string)
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
FLUSH_VERTICES(ctx, _NEW_PROGRAM);
if (target == GL_VERTEX_PROGRAM_ARB
&& ctx->Extensions.ARB_vertex_program) {
struct vertex_program *prog = ctx->VertexProgram.Current;
if (format != GL_PROGRAM_FORMAT_ASCII_ARB) {
_mesa_error(ctx, GL_INVALID_ENUM, "glProgramStringARB(format)");
return;
}
_mesa_parse_arb_vertex_program(ctx, target, (const GLubyte *) string,
len, prog);
if (ctx->Driver.ProgramStringNotify)
ctx->Driver.ProgramStringNotify( ctx, target, &prog->Base );
}
else if (target == GL_FRAGMENT_PROGRAM_ARB
&& ctx->Extensions.ARB_fragment_program) {
struct fragment_program *prog = ctx->FragmentProgram.Current;
if (format != GL_PROGRAM_FORMAT_ASCII_ARB) {
_mesa_error(ctx, GL_INVALID_ENUM, "glProgramStringARB(format)");
return;
}
_mesa_parse_arb_fragment_program(ctx, target, (const GLubyte *) string,
len, prog);
if (ctx->Driver.ProgramStringNotify)
ctx->Driver.ProgramStringNotify( ctx, target, &prog->Base );
}
else {
_mesa_error(ctx, GL_INVALID_ENUM, "glProgramStringARB(target)");
return;
}
}
/* Derived values of importance:
*
* FragmentProgram->_Current
* VertexProgram->_Enabled
* brw->vertex_program
* DrawBuffer->_ColorDrawBufferMask[0]
*
*
* More if drawpixels-through-texture is added.
*/
static void init_metaops_state( struct brw_context *brw )
{
GLcontext *ctx = &brw->intel.ctx;
brw->metaops.vbo = ctx->Driver.NewBufferObject(ctx, 1, GL_ARRAY_BUFFER_ARB);
ctx->Driver.BufferData(ctx,
GL_ARRAY_BUFFER_ARB,
4096,
NULL,
GL_DYNAMIC_DRAW_ARB,
brw->metaops.vbo);
brw->metaops.fp = (struct gl_fragment_program *)
ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 1 );
brw->metaops.fp_tex = (struct gl_fragment_program *)
ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 1 );
brw->metaops.vp = (struct gl_vertex_program *)
ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 1 );
_mesa_parse_arb_fragment_program(ctx, GL_FRAGMENT_PROGRAM_ARB,
fp_prog, strlen(fp_prog),
brw->metaops.fp);
_mesa_parse_arb_fragment_program(ctx, GL_FRAGMENT_PROGRAM_ARB,
fp_tex_prog, strlen(fp_tex_prog),
brw->metaops.fp_tex);
_mesa_parse_arb_vertex_program(ctx, GL_VERTEX_PROGRAM_ARB,
vp_prog, strlen(vp_prog),
brw->metaops.vp);
brw->metaops.attribs.VertexProgram->Current = brw->metaops.vp;
brw->metaops.attribs.VertexProgram->_Enabled = GL_TRUE;
brw->metaops.attribs.FragmentProgram->_Current = brw->metaops.fp;
}
void GLAPIENTRY
_mesa_ProgramStringARB(GLenum target, GLenum format, GLsizei len,
const GLvoid *string)
{
struct gl_program *base;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
FLUSH_VERTICES(ctx, _NEW_PROGRAM);
if (!ctx->Extensions.ARB_vertex_program
&& !ctx->Extensions.ARB_fragment_program) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glProgramStringARB()");
return;
}
if (format != GL_PROGRAM_FORMAT_ASCII_ARB) {
_mesa_error(ctx, GL_INVALID_ENUM, "glProgramStringARB(format)");
return;
}
/* The first couple cases are complicated. The same enum value is used for
* ARB and NV vertex programs. If the target is a vertex program, parse it
* using the ARB grammar if the string starts with "!!ARB" or if
* NV_vertex_program is not supported.
*/
if (target == GL_VERTEX_PROGRAM_ARB
&& ctx->Extensions.ARB_vertex_program
&& ((strncmp(string, "!!ARB", 5) == 0)
|| !ctx->Extensions.NV_vertex_program)) {
struct gl_vertex_program *prog = ctx->VertexProgram.Current;
_mesa_parse_arb_vertex_program(ctx, target, string, len, prog);
base = & prog->Base;
}
else if ((target == GL_VERTEX_PROGRAM_ARB
|| target == GL_VERTEX_STATE_PROGRAM_NV)
&& ctx->Extensions.NV_vertex_program) {
struct gl_vertex_program *prog = ctx->VertexProgram.Current;
_mesa_parse_nv_vertex_program(ctx, target, string, len, prog);
base = & prog->Base;
}
else if (target == GL_FRAGMENT_PROGRAM_ARB
&& ctx->Extensions.ARB_fragment_program) {
struct gl_fragment_program *prog = ctx->FragmentProgram.Current;
_mesa_parse_arb_fragment_program(ctx, target, string, len, prog);
base = & prog->Base;
}
else if (target == GL_FRAGMENT_PROGRAM_NV
&& ctx->Extensions.NV_fragment_program) {
struct gl_fragment_program *prog = ctx->FragmentProgram.Current;
_mesa_parse_nv_fragment_program(ctx, target, string, len, prog);
base = & prog->Base;
}
else {
_mesa_error(ctx, GL_INVALID_ENUM, "glProgramStringARB(target)");
return;
}
if (ctx->Program.ErrorPos == -1 && ctx->Driver.ProgramStringNotify)
ctx->Driver.ProgramStringNotify( ctx, target, base );
}
/**
* Load/parse/compile a program.
* \note Called from the GL API dispatcher.
*/
void GLAPIENTRY
_mesa_LoadProgramNV(GLenum target, GLuint id, GLsizei len,
const GLubyte *program)
{
struct gl_program *prog;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
if (!ctx->Extensions.NV_vertex_program
&& !ctx->Extensions.NV_fragment_program) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glLoadProgramNV()");
return;
}
if (id == 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "glLoadProgramNV(id)");
return;
}
if (len < 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "glLoadProgramNV(len)");
return;
}
FLUSH_VERTICES(ctx, _NEW_PROGRAM);
prog = _mesa_lookup_program(ctx, id);
if (prog && prog->Target != 0 && prog->Target != target) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glLoadProgramNV(target)");
return;
}
if ((target == GL_VERTEX_PROGRAM_NV ||
target == GL_VERTEX_STATE_PROGRAM_NV)
&& ctx->Extensions.NV_vertex_program) {
struct gl_vertex_program *vprog = gl_vertex_program(prog);
if (!vprog || prog == &_mesa_DummyProgram) {
vprog = gl_vertex_program(ctx->Driver.NewProgram(ctx, target, id));
if (!vprog) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glLoadProgramNV");
return;
}
_mesa_HashInsert(ctx->Shared->Programs, id, vprog);
}
if (ctx->Extensions.ARB_vertex_program
&& (strncmp((char *) program, "!!ARB", 5) == 0)) {
_mesa_parse_arb_vertex_program(ctx, target, program, len, vprog);
} else {
_mesa_parse_nv_vertex_program(ctx, target, program, len, vprog);
}
}
else if (target == GL_FRAGMENT_PROGRAM_NV
&& ctx->Extensions.NV_fragment_program) {
struct gl_fragment_program *fprog = gl_fragment_program(prog);
if (!fprog || prog == &_mesa_DummyProgram) {
fprog = gl_fragment_program(ctx->Driver.NewProgram(ctx, target, id));
if (!fprog) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glLoadProgramNV");
return;
}
_mesa_HashInsert(ctx->Shared->Programs, id, fprog);
}
_mesa_parse_nv_fragment_program(ctx, target, program, len, fprog);
}
else if (target == GL_FRAGMENT_PROGRAM_ARB
&& ctx->Extensions.ARB_fragment_program) {
struct gl_fragment_program *fprog = gl_fragment_program(prog);
if (!fprog || prog == &_mesa_DummyProgram) {
fprog = gl_fragment_program(ctx->Driver.NewProgram(ctx, target, id));
if (!fprog) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glLoadProgramNV");
return;
}
_mesa_HashInsert(ctx->Shared->Programs, id, fprog);
}
_mesa_parse_arb_fragment_program(ctx, target, program, len, fprog);
}
else {
_mesa_error(ctx, GL_INVALID_ENUM, "glLoadProgramNV(target)");
}
}
void GLAPIENTRY
_mesa_ProgramStringARB(GLenum target, GLenum format, GLsizei len,
const GLvoid *string)
{
struct gl_program *base;
bool failed;
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, _NEW_PROGRAM);
if (!ctx->Extensions.ARB_vertex_program
&& !ctx->Extensions.ARB_fragment_program) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glProgramStringARB()");
return;
}
if (format != GL_PROGRAM_FORMAT_ASCII_ARB) {
_mesa_error(ctx, GL_INVALID_ENUM, "glProgramStringARB(format)");
return;
}
if (target == GL_VERTEX_PROGRAM_ARB && ctx->Extensions.ARB_vertex_program) {
struct gl_vertex_program *prog = ctx->VertexProgram.Current;
_mesa_parse_arb_vertex_program(ctx, target, string, len, prog);
base = & prog->Base;
}
else if (target == GL_FRAGMENT_PROGRAM_ARB
&& ctx->Extensions.ARB_fragment_program) {
struct gl_fragment_program *prog = ctx->FragmentProgram.Current;
_mesa_parse_arb_fragment_program(ctx, target, string, len, prog);
base = & prog->Base;
}
else {
_mesa_error(ctx, GL_INVALID_ENUM, "glProgramStringARB(target)");
return;
}
failed = ctx->Program.ErrorPos != -1;
if (!failed) {
/* finally, give the program to the driver for translation/checking */
if (!ctx->Driver.ProgramStringNotify(ctx, target, base)) {
failed = true;
_mesa_error(ctx, GL_INVALID_OPERATION,
"glProgramStringARB(rejected by driver");
}
}
if (ctx->_Shader->Flags & GLSL_DUMP) {
const char *shader_type =
target == GL_FRAGMENT_PROGRAM_ARB ? "fragment" : "vertex";
fprintf(stderr, "ARB_%s_program source for program %d:\n",
shader_type, base->Id);
fprintf(stderr, "%s\n", (const char *) string);
if (failed) {
fprintf(stderr, "ARB_%s_program %d failed to compile.\n",
shader_type, base->Id);
} else {
fprintf(stderr, "Mesa IR for ARB_%s_program %d:\n",
shader_type, base->Id);
_mesa_print_program(base);
fprintf(stderr, "\n");
}
fflush(stderr);
}
/* Capture vp-*.shader_test/fp-*.shader_test files. */
const char *capture_path = _mesa_get_shader_capture_path();
if (capture_path != NULL) {
FILE *file;
const char *shader_type =
target == GL_FRAGMENT_PROGRAM_ARB ? "fragment" : "vertex";
char *filename =
ralloc_asprintf(NULL, "%s/%cp-%u.shader_test",
capture_path, shader_type[0], base->Id);
file = fopen(filename, "w");
if (file) {
fprintf(file,
"[require]\nGL_ARB_%s_program\n\n[%s program]\n%s\n",
shader_type, shader_type, (const char *) string);
fclose(file);
} else {
_mesa_warning(ctx, "Failed to open %s", filename);
}
ralloc_free(filename);
}
}
