OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Re-org and clean-up of vertx/fragment program limits (instructions,

Browse Source 
temporaries, parameters, etc).
glGetProgramivARB() now returns all the right things.
Updated i915 and r300 code to initialize program native limits and
current program's native instruction/temporary/etc counts.
This commit is contained in:
Brian Paul
2005-11-01 04:36:33 +00:00
parent ffec105109
commit 0505103710
14 changed files with 290 additions and 245 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
src/mesa/drivers/dri/i915/i915_context.c
View File

@@ -154,16 +154,15 @@ GLboolean i915CreateContext( const __GLcontextModes *mesaVis,
* we'll still have to check and fallback each time.
*/
ctx->Const.MaxFragmentProgramTemps = I915_MAX_TEMPORARY;
ctx->Const.MaxFragmentProgramAttribs = 11; /* 8 tex, 2 color, fog */
ctx->Const.MaxFragmentProgramLocalParams = I915_MAX_CONSTANT;
ctx->Const.MaxFragmentProgramEnvParams = I915_MAX_CONSTANT;
ctx->Const.MaxFragmentProgramAluInstructions = I915_MAX_ALU_INSN;
ctx->Const.MaxFragmentProgramTexInstructions = I915_MAX_TEX_INSN;
ctx->Const.MaxFragmentProgramInstructions = (I915_MAX_ALU_INSN +
ctx->Const.FragmentProgram.MaxNativeTemps = I915_MAX_TEMPORARY;
ctx->Const.FragmentProgram.MaxNativeAttribs = 11; /* 8 tex, 2 color, fog */
ctx->Const.FragmentProgram.MaxNativeParameters = I915_MAX_CONSTANT;
ctx->Const.FragmentProgram.MaxNativeAluInstructions = I915_MAX_ALU_INSN;
ctx->Const.FragmentProgram.MaxNativeTexInstructions = I915_MAX_TEX_INSN;
ctx->Const.FragmentProgram.MaxNativeInstructions = (I915_MAX_ALU_INSN +
I915_MAX_TEX_INSN);
ctx->Const.MaxFragmentProgramTexIndirections = I915_MAX_TEX_INDIRECT;
ctx->Const.MaxFragmentProgramAddressRegs = 0; /* I don't think we have one */
ctx->Const.FragmentProgram.MaxNativeTexIndirections = I915_MAX_TEX_INDIRECT;
ctx->Const.FragmentProgram.MaxNativeAddressRegs = 0; /* I don't think we have one */
driInitExtensions( ctx, i915_extensions, GL_FALSE );

18
src/mesa/drivers/dri/i915/i915_program.c
View File

@@ -351,6 +351,9 @@ GLuint i915_emit_param4fv( struct i915_fragment_program *p,
void i915_program_error( struct i915_fragment_program *p, const char *msg )
{
/* XXX we shouldn't print anything to stdout, record GL error or
* call _mesa_problem()
*/
fprintf(stderr, "%s\n", msg);
p->error = 1;
}
@@ -410,6 +413,21 @@ void i915_fini_program( struct i915_fragment_program *p )
if (p->nr_decl_insn > I915_MAX_DECL_INSN)
i915_program_error(p, "Exceeded max DECL instructions");
if (p->error) {
p->FragProg.Base.NumNativeInstructions = 0;
p->FragProg.NumNativeAluInstructions = 0;
p->FragProg.NumNativeTexInstructions = 0;
p->FragProg.NumNativeTexIndirections = 0;
}
else {
p->FragProg.Base.NumNativeInstructions = (p->nr_alu_insn +
p->nr_tex_insn +
p->nr_decl_insn);
p->FragProg.NumNativeAluInstructions = p->nr_alu_insn;
p->FragProg.NumNativeTexInstructions = p->nr_tex_insn;
p->FragProg.NumNativeTexIndirections = p->nr_tex_indirect;
}
p->declarations[0] |= program_size + decl_size - 2;
}

32
src/mesa/drivers/dri/r300/r300_context.c
View File

@@ -269,7 +269,9 @@ GLboolean r300CreateContext(const __GLcontextModes * glVisual,
#ifdef USER_BUFFERS
/* Needs further modifications */
//ctx->Const.MaxArrayLockSize = (/*512*/RADEON_BUFFER_SIZE*16*1024) / (4*4);
#if 0
ctx->Const.MaxArrayLockSize = (/*512*/RADEON_BUFFER_SIZE*16*1024) / (4*4);
#endif
#endif
/* Initialize the software rasterizer and helper modules.
@@ -298,23 +300,21 @@ GLboolean r300CreateContext(const __GLcontextModes * glVisual,
_tnl_allow_vertex_fog(ctx, GL_TRUE);
/* currently bogus data */
ctx->Const.MaxVertexProgramInstructions=VSF_MAX_FRAGMENT_LENGTH;
ctx->Const.MaxVertexProgramAttribs=16; // r420
ctx->Const.MaxVertexProgramTemps=VSF_MAX_FRAGMENT_TEMPS;
ctx->Const.MaxVertexProgramLocalParams=256; // r420
ctx->Const.MaxVertexProgramEnvParams=256; // r420
ctx->Const.MaxVertexProgramAddressRegs=1;
ctx->Const.VertexProgram.MaxNativeInstructions=VSF_MAX_FRAGMENT_LENGTH;
ctx->Const.VertexProgram.MaxNativeAttribs=16; /* r420 */
ctx->Const.VertexProgram.MaxNativeTemps=VSF_MAX_FRAGMENT_TEMPS;
ctx->Const.VertexProgram.MaxNativeParameters=256; /* r420 */
ctx->Const.VertexProgram.MaxNativeAddressRegs=1;
#if USE_ARB_F_P
ctx->Const.MaxFragmentProgramTemps = PFS_NUM_TEMP_REGS;
ctx->Const.MaxFragmentProgramAttribs = 11; /* copy i915... */
ctx->Const.MaxFragmentProgramLocalParams = PFS_NUM_CONST_REGS;
ctx->Const.MaxFragmentProgramEnvParams = PFS_NUM_CONST_REGS;
ctx->Const.MaxFragmentProgramAluInstructions = PFS_MAX_ALU_INST;
ctx->Const.MaxFragmentProgramTexInstructions = PFS_MAX_TEX_INST;
ctx->Const.MaxFragmentProgramInstructions = PFS_MAX_ALU_INST+PFS_MAX_TEX_INST;
ctx->Const.MaxFragmentProgramTexIndirections = PFS_MAX_TEX_INDIRECT;
ctx->Const.MaxFragmentProgramAddressRegs = 0; /* and these are?? */
ctx->Const.FragmentProgram.MaxNativeTemps = PFS_NUM_TEMP_REGS;
ctx->Const.FragmentProgram.MaxNativeAttribs = 11; /* copy i915... */
ctx->Const.FragmentProgram.MaxNativeParameters = PFS_NUM_CONST_REGS;
ctx->Const.FragmentProgram.MaxNativeAluInstructions = PFS_MAX_ALU_INST;
ctx->Const.FragmentProgram.MaxNativeTexInstructions = PFS_MAX_TEX_INST;
ctx->Const.FragmentProgram.MaxNativeInstructions = PFS_MAX_ALU_INST+PFS_MAX_TEX_INST;
ctx->Const.FragmentProgram.MaxNativeTexIndirections = PFS_MAX_TEX_INDIRECT;
ctx->Const.FragmentProgram.MaxNativeAddressRegs = 0; /* and these are?? */
ctx->_MaintainTexEnvProgram = GL_TRUE;
#endif

2
src/mesa/main/config.h
View File

@@ -183,7 +183,7 @@
/** For GL_ARB_fragment_program */
/*@{*/
#define MAX_FRAGMENT_PROGRAM_ADDRESS_REGS 1
#define MAX_FRAGMENT_PROGRAM_ADDRESS_REGS 0
#define MAX_FRAGMENT_PROGRAM_ALU_INSTRUCTIONS 48
#define MAX_FRAGMENT_PROGRAM_TEX_INSTRUCTIONS 24
#define MAX_FRAGMENT_PROGRAM_TEX_INDIRECTIONS 4

58
src/mesa/main/context.c
View File

@@ -911,6 +911,23 @@ _mesa_init_current( GLcontext *ctx )
}
/**
* Init vertex/fragment program native limits from logical limits.
*/
static void
init_natives(struct gl_program_constants *prog)
{
prog->MaxNativeInstructions = prog->MaxInstructions;
prog->MaxNativeAluInstructions = prog->MaxAluInstructions;
prog->MaxNativeTexInstructions = prog->MaxTexInstructions;
prog->MaxNativeTexIndirections = prog->MaxTexIndirections;
prog->MaxNativeAttribs = prog->MaxAttribs;
prog->MaxNativeTemps = prog->MaxTemps;
prog->MaxNativeAddressRegs = prog->MaxAddressRegs;
prog->MaxNativeParameters = prog->MaxParameters;
}
/**
* Initialize fields of gl_constants (aka ctx->Const.*).
* Use defaults from config.h. The device drivers will often override
@@ -956,25 +973,31 @@ _mesa_init_constants( GLcontext *ctx )
ctx->Const.MaxViewportWidth = MAX_WIDTH;
ctx->Const.MaxViewportHeight = MAX_HEIGHT;
#if FEATURE_ARB_vertex_program
ctx->Const.MaxVertexProgramInstructions = MAX_NV_VERTEX_PROGRAM_INSTRUCTIONS;
ctx->Const.MaxVertexProgramAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;
ctx->Const.MaxVertexProgramTemps = MAX_NV_VERTEX_PROGRAM_TEMPS;
ctx->Const.MaxVertexProgramLocalParams = MAX_NV_VERTEX_PROGRAM_PARAMS;
ctx->Const.MaxVertexProgramEnvParams = MAX_NV_VERTEX_PROGRAM_PARAMS;/*XXX*/
ctx->Const.MaxVertexProgramAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
ctx->Const.VertexProgram.MaxInstructions = MAX_NV_VERTEX_PROGRAM_INSTRUCTIONS;
ctx->Const.VertexProgram.MaxAluInstructions = 0;
ctx->Const.VertexProgram.MaxTexInstructions = 0;
ctx->Const.VertexProgram.MaxTexIndirections = 0;
ctx->Const.VertexProgram.MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;
ctx->Const.VertexProgram.MaxTemps = MAX_NV_VERTEX_PROGRAM_TEMPS;
ctx->Const.VertexProgram.MaxParameters = MAX_NV_VERTEX_PROGRAM_PARAMS;
ctx->Const.VertexProgram.MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
ctx->Const.VertexProgram.MaxEnvParams = MAX_NV_VERTEX_PROGRAM_PARAMS;
ctx->Const.VertexProgram.MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
init_natives(&ctx->Const.VertexProgram);
#endif
#if FEATURE_ARB_fragment_program
ctx->Const.MaxFragmentProgramInstructions = MAX_NV_FRAGMENT_PROGRAM_INSTRUCTIONS;
ctx->Const.MaxFragmentProgramAttribs = MAX_NV_FRAGMENT_PROGRAM_INPUTS;
ctx->Const.MaxFragmentProgramTemps = MAX_NV_FRAGMENT_PROGRAM_TEMPS;
ctx->Const.MaxFragmentProgramLocalParams = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
ctx->Const.MaxFragmentProgramEnvParams = MAX_NV_FRAGMENT_PROGRAM_PARAMS;/*XXX*/
ctx->Const.MaxFragmentProgramAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;
ctx->Const.MaxFragmentProgramAluInstructions = MAX_FRAGMENT_PROGRAM_ALU_INSTRUCTIONS;
ctx->Const.MaxFragmentProgramTexInstructions = MAX_FRAGMENT_PROGRAM_TEX_INSTRUCTIONS;
ctx->Const.MaxFragmentProgramTexIndirections = MAX_FRAGMENT_PROGRAM_TEX_INDIRECTIONS;
ctx->Const.FragmentProgram.MaxInstructions = MAX_NV_FRAGMENT_PROGRAM_INSTRUCTIONS;
ctx->Const.FragmentProgram.MaxAluInstructions = MAX_FRAGMENT_PROGRAM_ALU_INSTRUCTIONS;
ctx->Const.FragmentProgram.MaxTexInstructions = MAX_FRAGMENT_PROGRAM_TEX_INSTRUCTIONS;
ctx->Const.FragmentProgram.MaxTexIndirections = MAX_FRAGMENT_PROGRAM_TEX_INDIRECTIONS;
ctx->Const.FragmentProgram.MaxAttribs = MAX_NV_FRAGMENT_PROGRAM_INPUTS;
ctx->Const.FragmentProgram.MaxTemps = MAX_NV_FRAGMENT_PROGRAM_TEMPS;
ctx->Const.FragmentProgram.MaxParameters = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
ctx->Const.FragmentProgram.MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
ctx->Const.FragmentProgram.MaxEnvParams = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
ctx->Const.FragmentProgram.MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;
init_natives(&ctx->Const.FragmentProgram);
#endif
ctx->Const.MaxProgramMatrices = MAX_PROGRAM_MATRICES;
ctx->Const.MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;
@@ -987,6 +1010,7 @@ _mesa_init_constants( GLcontext *ctx )
ctx->Const.CheckArrayBounds = GL_FALSE;
#endif
/* GL_ARB_draw_buffers */
ctx->Const.MaxDrawBuffers = MAX_DRAW_BUFFERS;
/* GL_OES_read_format */
@@ -1000,6 +1024,8 @@ _mesa_init_constants( GLcontext *ctx )
/* sanity checks */
ASSERT(ctx->Const.MaxTextureUnits == MAX2(ctx->Const.MaxTextureImageUnits, ctx->Const.MaxTextureCoordUnits));
ASSERT(ctx->Const.FragmentProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
ASSERT(ctx->Const.VertexProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
}

6
src/mesa/main/get.c
View File

@@ -1707,7 +1707,7 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
break;
case GL_MAX_VERTEX_ATTRIBS_ARB:
CHECK_EXTENSION_B(ARB_vertex_program, pname);
params[0] = INT_TO_BOOLEAN(ctx->Const.MaxVertexProgramAttribs);
params[0] = INT_TO_BOOLEAN(ctx->Const.VertexProgram.MaxAttribs);
break;
case GL_FRAGMENT_PROGRAM_ARB:
CHECK_EXTENSION_B(ARB_fragment_program, pname);
@@ -3537,7 +3537,7 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
break;
case GL_MAX_VERTEX_ATTRIBS_ARB:
CHECK_EXTENSION_F(ARB_vertex_program, pname);
params[0] = (GLfloat)(ctx->Const.MaxVertexProgramAttribs);
params[0] = (GLfloat)(ctx->Const.VertexProgram.MaxAttribs);
break;
case GL_FRAGMENT_PROGRAM_ARB:
CHECK_EXTENSION_F(ARB_fragment_program, pname);
@@ -5367,7 +5367,7 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
break;
case GL_MAX_VERTEX_ATTRIBS_ARB:
CHECK_EXTENSION_I(ARB_vertex_program, pname);
params[0] = ctx->Const.MaxVertexProgramAttribs;
params[0] = ctx->Const.VertexProgram.MaxAttribs;
break;
case GL_FRAGMENT_PROGRAM_ARB:
CHECK_EXTENSION_I(ARB_fragment_program, pname);

2
src/mesa/main/get_gen.py
View File

@@ -869,7 +869,7 @@ StateVars = [
# GL_ARB_vertex_program
( "GL_MAX_VERTEX_ATTRIBS_ARB", GLint,
["ctx->Const.MaxVertexProgramAttribs"], "", "ARB_vertex_program" ),
["ctx->Const.VertexProgram.MaxAttribs"], "", "ARB_vertex_program" ),
# GL_ARB_fragment_program
( "GL_FRAGMENT_PROGRAM_ARB", GLboolean,

58
src/mesa/main/mtypes.h
View File

@@ -1752,6 +1752,12 @@ struct program
GLuint NumParameters;
GLuint NumAttributes;
GLuint NumAddressRegs;
/* native, h/w counts */
GLuint NumNativeInstructions;
GLuint NumNativeTemporaries;
GLuint NumNativeParameters;
GLuint NumNativeAttributes;
GLuint NumNativeAddressRegs;
};
@@ -1780,6 +1786,9 @@ struct fragment_program
GLuint NumAluInstructions; /**< GL_ARB_fragment_program */
GLuint NumTexInstructions;
GLuint NumTexIndirections;
GLuint NumNativeAluInstructions; /**< GL_ARB_fragment_program */
GLuint NumNativeTexInstructions;
GLuint NumNativeTexIndirections;
GLenum FogOption;
struct program_parameter_list *Parameters; /**< array [NumParameters] */
@@ -2214,6 +2223,34 @@ struct gl_framebuffer
};
/**
* Limits for vertex and fragment programs.
*/
struct gl_program_constants
{
/* logical limits */
GLuint MaxInstructions;
GLuint MaxAluInstructions; /* fragment programs only, for now */
GLuint MaxTexInstructions; /* fragment programs only, for now */
GLuint MaxTexIndirections; /* fragment programs only, for now */
GLuint MaxAttribs;
GLuint MaxTemps;
GLuint MaxAddressRegs; /* vertex program only, for now */
GLuint MaxParameters;
GLuint MaxLocalParams;
GLuint MaxEnvParams;
/* native/hardware limits */
GLuint MaxNativeInstructions;
GLuint MaxNativeAluInstructions; /* fragment programs only, for now */
GLuint MaxNativeTexInstructions; /* fragment programs only, for now */
GLuint MaxNativeTexIndirections; /* fragment programs only, for now */
GLuint MaxNativeAttribs;
GLuint MaxNativeTemps;
GLuint MaxNativeAddressRegs; /* vertex program only, for now */
GLuint MaxNativeParameters;
};
/**
* Constants which may be overridden by device driver during context creation
* but are never changed after that.
@@ -2245,24 +2282,9 @@ struct gl_constants
GLfloat MaxShininess; /* GL_NV_light_max_exponent */
GLfloat MaxSpotExponent; /* GL_NV_light_max_exponent */
GLuint MaxViewportWidth, MaxViewportHeight;
/* GL_ARB_vertex_program */
GLuint MaxVertexProgramInstructions;
GLuint MaxVertexProgramAttribs;
GLuint MaxVertexProgramTemps;
GLuint MaxVertexProgramLocalParams;
GLuint MaxVertexProgramEnvParams;
GLuint MaxVertexProgramAddressRegs;
/* GL_ARB_fragment_program */
GLuint MaxFragmentProgramInstructions;
GLuint MaxFragmentProgramAttribs;
GLuint MaxFragmentProgramTemps;
GLuint MaxFragmentProgramLocalParams;
GLuint MaxFragmentProgramEnvParams;
GLuint MaxFragmentProgramAddressRegs;
GLuint MaxFragmentProgramAluInstructions;
GLuint MaxFragmentProgramTexInstructions;
GLuint MaxFragmentProgramTexIndirections;
/* vertex or fragment program */
struct gl_program_constants VertexProgram; /* GL_ARB_vertex_program */
struct gl_program_constants FragmentProgram; /* GL_ARB_fragment_program */
/* shared by vertex and fragment program: */
GLuint MaxProgramMatrices;
GLuint MaxProgramMatrixStackDepth;
/* vertex array / buffer object bounds checking */

8
src/mesa/main/texenvprogram.c
View File

@@ -400,7 +400,7 @@ static struct ureg get_tex_temp( struct texenv_fragment_program *p )
static void release_temps( struct texenv_fragment_program *p )
{
GLuint max_temp = p->ctx->Const.MaxFragmentProgramTemps;
GLuint max_temp = p->ctx->Const.FragmentProgram.MaxTemps;
/* KW: To support tex_env_crossbar, don't release the registers in
* temps_output.
@@ -1058,13 +1058,13 @@ static void create_new_program(struct state_key *key, GLcontext *ctx,
} else
p.program->FogOption = GL_NONE;
if (p.program->NumTexIndirections > ctx->Const.MaxFragmentProgramTexIndirections)
if (p.program->NumTexIndirections > ctx->Const.FragmentProgram.MaxTexIndirections)
program_error(&p, "Exceeded max nr indirect texture lookups");
if (p.program->NumTexInstructions > ctx->Const.MaxFragmentProgramTexInstructions)
if (p.program->NumTexInstructions > ctx->Const.FragmentProgram.MaxTexInstructions)
program_error(&p, "Exceeded max TEX instructions");
if (p.program->NumAluInstructions > ctx->Const.MaxFragmentProgramAluInstructions)
if (p.program->NumAluInstructions > ctx->Const.FragmentProgram.MaxAluInstructions)
program_error(&p, "Exceeded max ALU instructions");

2
src/mesa/main/varray.c
View File

@@ -499,7 +499,7 @@ _mesa_VertexAttribPointerARB(GLuint index, GLint size, GLenum type,
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
if (index >= ctx->Const.MaxVertexProgramAttribs) {
if (index >= ctx->Const.VertexProgram.MaxAttribs) {
_mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribPointerARB(index)");
return;
}

42
src/mesa/shader/arbprogparse.c
View File

@@ -1324,10 +1324,10 @@ parse_program_single_item (GLcontext * ctx, GLubyte ** inst,
/* Check state_tokens[2] against the number of ENV parameters available */
if (((Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) &&
(state_tokens[2] >= (GLint) ctx->Const.MaxFragmentProgramEnvParams))
(state_tokens[2] >= (GLint) ctx->Const.FragmentProgram.MaxEnvParams))
||
((Program->Base.Target == GL_VERTEX_PROGRAM_ARB) &&
(state_tokens[2] >= (GLint) ctx->Const.MaxVertexProgramEnvParams))) {
(state_tokens[2] >= (GLint) ctx->Const.VertexProgram.MaxEnvParams))) {
_mesa_set_program_error (ctx, Program->Position,
"Invalid Program Env Parameter");
_mesa_error (ctx, GL_INVALID_OPERATION,
@@ -1344,10 +1344,10 @@ parse_program_single_item (GLcontext * ctx, GLubyte ** inst,
/* Check state_tokens[2] against the number of LOCAL parameters available */
if (((Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) &&
(state_tokens[2] >= (GLint) ctx->Const.MaxFragmentProgramLocalParams))
(state_tokens[2] >= (GLint) ctx->Const.FragmentProgram.MaxLocalParams))
||
((Program->Base.Target == GL_VERTEX_PROGRAM_ARB) &&
(state_tokens[2] >= (GLint) ctx->Const.MaxVertexProgramLocalParams))) {
(state_tokens[2] >= (GLint) ctx->Const.VertexProgram.MaxLocalParams))) {
_mesa_set_program_error (ctx, Program->Position,
"Invalid Program Local Parameter");
_mesa_error (ctx, GL_INVALID_OPERATION,
@@ -1742,18 +1742,18 @@ parse_param_elements (GLcontext * ctx, GLubyte ** inst,
out_of_range = 0;
if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
if (((state_tokens[1] == STATE_ENV)
&& (end_idx >= ctx->Const.MaxFragmentProgramEnvParams))
&& (end_idx >= ctx->Const.FragmentProgram.MaxEnvParams))
|| ((state_tokens[1] == STATE_LOCAL)
&& (end_idx >=
ctx->Const.MaxFragmentProgramLocalParams)))
ctx->Const.FragmentProgram.MaxLocalParams)))
out_of_range = 1;
}
else {
if (((state_tokens[1] == STATE_ENV)
&& (end_idx >= ctx->Const.MaxVertexProgramEnvParams))
&& (end_idx >= ctx->Const.VertexProgram.MaxEnvParams))
|| ((state_tokens[1] == STATE_LOCAL)
&& (end_idx >=
ctx->Const.MaxVertexProgramLocalParams)))
ctx->Const.VertexProgram.MaxLocalParams)))
out_of_range = 1;
}
if (out_of_range) {
@@ -1800,10 +1800,10 @@ parse_param_elements (GLcontext * ctx, GLubyte ** inst,
/* Make sure we haven't blown past our parameter limits */
if (((Program->Base.Target == GL_VERTEX_PROGRAM_ARB) &&
(Program->Base.NumParameters >=
ctx->Const.MaxVertexProgramLocalParams))
ctx->Const.VertexProgram.MaxLocalParams))
|| ((Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB)
&& (Program->Base.NumParameters >=
ctx->Const.MaxFragmentProgramLocalParams))) {
ctx->Const.FragmentProgram.MaxLocalParams))) {
_mesa_set_program_error (ctx, Program->Position,
"Too many parameter variables");
_mesa_error (ctx, GL_INVALID_OPERATION, "Too many parameter variables");
@@ -1958,10 +1958,10 @@ parse_temp (GLcontext * ctx, GLubyte ** inst, struct var_cache **vc_head,
if (((Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) &&
(Program->Base.NumTemporaries >=
ctx->Const.MaxFragmentProgramTemps))
ctx->Const.FragmentProgram.MaxTemps))
|| ((Program->Base.Target == GL_VERTEX_PROGRAM_ARB)
&& (Program->Base.NumTemporaries >=
ctx->Const.MaxVertexProgramTemps))) {
ctx->Const.VertexProgram.MaxTemps))) {
_mesa_set_program_error (ctx, Program->Position,
"Too many TEMP variables declared");
_mesa_error (ctx, GL_INVALID_OPERATION,
@@ -2091,7 +2091,7 @@ parse_address (GLcontext * ctx, GLubyte ** inst, struct var_cache **vc_head,
temp_var->type = vt_address;
if (Program->Base.NumAddressRegs >=
ctx->Const.MaxVertexProgramAddressRegs) {
ctx->Const.VertexProgram.MaxAddressRegs) {
const char *msg = "Too many ADDRESS variables declared";
_mesa_set_program_error(ctx, Program->Position, msg);
@@ -3760,6 +3760,22 @@ parse_arb_program(GLcontext * ctx, GLubyte * inst, struct var_cache **vc_head,
}
Program->Base.NumInstructions++;
/*
* Initialize native counts to logical counts. The device driver may
* change them if program is translated into a hardware program.
*/
Program->Base.NumNativeInstructions = Program->Base.NumInstructions;
Program->Base.NumNativeTemporaries = Program->Base.NumTemporaries;
Program->Base.NumNativeParameters = Program->Base.NumParameters;
Program->Base.NumNativeAttributes = Program->Base.NumAttributes;
Program->Base.NumNativeAddressRegs = Program->Base.NumAddressRegs;
if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
struct fragment_program *fp = (struct fragment_program *) Program;
fp->NumNativeAluInstructions = fp->NumAluInstructions;
fp->NumNativeTexInstructions = fp->NumTexInstructions;
fp->NumNativeTexIndirections = fp->NumTexIndirections;
}
return err;
}

234
src/mesa/shader/arbprogram.c
View File

@@ -1,8 +1,8 @@
/*
* Mesa 3-D graphics library
* Version: 5.1
* Version: 6.5
*
* Copyright (C) 1999-2003 Brian Paul All Rights Reserved.
* Copyright (C) 1999-2005 Brian Paul All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
@@ -50,7 +50,7 @@ _mesa_EnableVertexAttribArrayARB(GLuint index)
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
if (index >= ctx->Const.MaxVertexProgramAttribs) {
if (index >= ctx->Const.VertexProgram.MaxAttribs) {
_mesa_error(ctx, GL_INVALID_VALUE,
"glEnableVertexAttribArrayARB(index)");
return;
@@ -69,7 +69,7 @@ _mesa_DisableVertexAttribArrayARB(GLuint index)
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
if (index >= ctx->Const.MaxVertexProgramAttribs) {
if (index >= ctx->Const.VertexProgram.MaxAttribs) {
_mesa_error(ctx, GL_INVALID_VALUE,
"glEnableVertexAttribArrayARB(index)");
return;
@@ -173,7 +173,7 @@ _mesa_GetVertexAttribPointervARB(GLuint index, GLenum pname, GLvoid **pointer)
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
if (index >= ctx->Const.MaxVertexProgramAttribs) {
if (index >= ctx->Const.VertexProgram.MaxAttribs) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetVertexAttribPointerARB(index)");
return;
}
@@ -259,7 +259,7 @@ _mesa_ProgramEnvParameter4fARB(GLenum target, GLuint index,
if (target == GL_FRAGMENT_PROGRAM_ARB
&& ctx->Extensions.ARB_fragment_program) {
if (index >= ctx->Const.MaxFragmentProgramEnvParams) {
if (index >= ctx->Const.FragmentProgram.MaxEnvParams) {
_mesa_error(ctx, GL_INVALID_VALUE, "glProgramEnvParameter(index)");
return;
}
@@ -267,7 +267,7 @@ _mesa_ProgramEnvParameter4fARB(GLenum target, GLuint index,
}
else if (target == GL_VERTEX_PROGRAM_ARB
&& ctx->Extensions.ARB_vertex_program) {
if (index >= ctx->Const.MaxVertexProgramEnvParams) {
if (index >= ctx->Const.VertexProgram.MaxEnvParams) {
_mesa_error(ctx, GL_INVALID_VALUE, "glProgramEnvParameter(index)");
return;
}
@@ -319,7 +319,7 @@ _mesa_GetProgramEnvParameterfvARB(GLenum target, GLuint index,
if (target == GL_FRAGMENT_PROGRAM_ARB
&& ctx->Extensions.ARB_fragment_program) {
if (index >= ctx->Const.MaxFragmentProgramEnvParams) {
if (index >= ctx->Const.FragmentProgram.MaxEnvParams) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramEnvParameter(index)");
return;
}
@@ -327,7 +327,7 @@ _mesa_GetProgramEnvParameterfvARB(GLenum target, GLuint index,
}
else if (target == GL_VERTEX_PROGRAM_ARB
&& ctx->Extensions.ARB_vertex_program) {
if (index >= ctx->Const.MaxVertexProgramEnvParams) {
if (index >= ctx->Const.VertexProgram.MaxEnvParams) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramEnvParameter(index)");
return;
}
@@ -357,7 +357,7 @@ _mesa_ProgramLocalParameter4fARB(GLenum target, GLuint index,
&& ctx->Extensions.NV_fragment_program) ||
(target == GL_FRAGMENT_PROGRAM_ARB
&& ctx->Extensions.ARB_fragment_program)) {
if (index >= ctx->Const.MaxFragmentProgramLocalParams) {
if (index >= ctx->Const.FragmentProgram.MaxLocalParams) {
_mesa_error(ctx, GL_INVALID_VALUE, "glProgramLocalParameterARB");
return;
}
@@ -365,7 +365,7 @@ _mesa_ProgramLocalParameter4fARB(GLenum target, GLuint index,
}
else if (target == GL_VERTEX_PROGRAM_ARB
&& ctx->Extensions.ARB_vertex_program) {
if (index >= ctx->Const.MaxVertexProgramLocalParams) {
if (index >= ctx->Const.VertexProgram.MaxLocalParams) {
_mesa_error(ctx, GL_INVALID_VALUE, "glProgramLocalParameterARB");
return;
}
@@ -437,12 +437,12 @@ _mesa_GetProgramLocalParameterfvARB(GLenum target, GLuint index,
if (target == GL_VERTEX_PROGRAM_ARB
&& ctx->Extensions.ARB_vertex_program) {
prog = &(ctx->VertexProgram.Current->Base);
maxParams = ctx->Const.MaxVertexProgramLocalParams;
maxParams = ctx->Const.VertexProgram.MaxLocalParams;
}
else if (target == GL_FRAGMENT_PROGRAM_ARB
&& ctx->Extensions.ARB_fragment_program) {
prog = &(ctx->FragmentProgram.Current->Base);
maxParams = ctx->Const.MaxFragmentProgramLocalParams;
maxParams = ctx->Const.FragmentProgram.MaxLocalParams;
}
else if (target == GL_FRAGMENT_PROGRAM_NV
&& ctx->Extensions.NV_fragment_program) {
@@ -486,6 +486,7 @@ _mesa_GetProgramLocalParameterdvARB(GLenum target, GLuint index,
void GLAPIENTRY
_mesa_GetProgramivARB(GLenum target, GLenum pname, GLint *params)
{
const struct gl_program_constants *limits;
struct program *prog;
GET_CURRENT_CONTEXT(ctx);
@@ -495,10 +496,12 @@ _mesa_GetProgramivARB(GLenum target, GLenum pname, GLint *params)
if (target == GL_VERTEX_PROGRAM_ARB
&& ctx->Extensions.ARB_vertex_program) {
prog = &(ctx->VertexProgram.Current->Base);
limits = &ctx->Const.VertexProgram;
}
else if (target == GL_FRAGMENT_PROGRAM_ARB
&& ctx->Extensions.ARB_fragment_program) {
prog = &(ctx->FragmentProgram.Current->Base);
limits = &ctx->Const.FragmentProgram;
}
else {
_mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramivARB(target)");
@@ -506,196 +509,158 @@ _mesa_GetProgramivARB(GLenum target, GLenum pname, GLint *params)
}
ASSERT(prog);
ASSERT(limits);
/* Queries supported for both vertex and fragment programs */
switch (pname) {
case GL_PROGRAM_LENGTH_ARB:
*params = prog->String ? (GLint)_mesa_strlen((char *) prog->String) : 0;
break;
*params
= prog->String ? (GLint) _mesa_strlen((char *) prog->String) : 0;
return;
case GL_PROGRAM_FORMAT_ARB:
*params = prog->Format;
break;
return;
case GL_PROGRAM_BINDING_ARB:
*params = prog->Id;
break;
return;
case GL_PROGRAM_INSTRUCTIONS_ARB:
*params = prog->NumInstructions;
break;
return;
case GL_MAX_PROGRAM_INSTRUCTIONS_ARB:
if (target == GL_VERTEX_PROGRAM_ARB)
*params = ctx->Const.MaxVertexProgramInstructions;
else
*params = ctx->Const.MaxFragmentProgramInstructions;
break;
*params = limits->MaxInstructions;
return;
case GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB:
*params = prog->NumInstructions;
break;
*params = prog->NumNativeInstructions;
return;
case GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB:
if (target == GL_VERTEX_PROGRAM_ARB)
*params = ctx->Const.MaxVertexProgramInstructions;
else
*params = ctx->Const.MaxFragmentProgramInstructions;
break;
*params = limits->MaxNativeInstructions;
return;
case GL_PROGRAM_TEMPORARIES_ARB:
*params = prog->NumTemporaries;
break;
return;
case GL_MAX_PROGRAM_TEMPORARIES_ARB:
if (target == GL_VERTEX_PROGRAM_ARB)
*params = ctx->Const.MaxVertexProgramTemps;
else
*params = ctx->Const.MaxFragmentProgramTemps;
break;
*params = limits->MaxTemps;
return;
case GL_PROGRAM_NATIVE_TEMPORARIES_ARB:
/* XXX same as GL_PROGRAM_TEMPORARIES_ARB? */
*params = prog->NumTemporaries;
break;
*params = prog->NumNativeTemporaries;
return;
case GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB:
/* XXX same as GL_MAX_PROGRAM_TEMPORARIES_ARB? */
if (target == GL_VERTEX_PROGRAM_ARB)
*params = ctx->Const.MaxVertexProgramTemps;
else
*params = ctx->Const.MaxFragmentProgramTemps;
break;
*params = limits->MaxNativeTemps;
return;
case GL_PROGRAM_PARAMETERS_ARB:
*params = prog->NumParameters;
break;
return;
case GL_MAX_PROGRAM_PARAMETERS_ARB:
if (target == GL_VERTEX_PROGRAM_ARB)
*params = ctx->Const.MaxVertexProgramLocalParams;
else
*params = ctx->Const.MaxFragmentProgramLocalParams;
break;
*params = limits->MaxParameters;
return;
case GL_PROGRAM_NATIVE_PARAMETERS_ARB:
/* XXX same as GL_MAX_PROGRAM_PARAMETERS_ARB? */
*params = prog->NumParameters;
break;
*params = prog->NumNativeParameters;
return;
case GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB:
/* XXX same as GL_MAX_PROGRAM_PARAMETERS_ARB? */
if (target == GL_VERTEX_PROGRAM_ARB)
*params = ctx->Const.MaxVertexProgramLocalParams;
else
*params = ctx->Const.MaxFragmentProgramLocalParams;
break;
*params = limits->MaxNativeParameters;
return;
case GL_PROGRAM_ATTRIBS_ARB:
*params = prog->NumAttributes;
break;
return;
case GL_MAX_PROGRAM_ATTRIBS_ARB:
if (target == GL_VERTEX_PROGRAM_ARB)
*params = ctx->Const.MaxVertexProgramAttribs;
else
*params = ctx->Const.MaxFragmentProgramAttribs;
break;
*params = limits->MaxAttribs;
return;
case GL_PROGRAM_NATIVE_ATTRIBS_ARB:
/* XXX same as GL_PROGRAM_ATTRIBS_ARB? */
*params = prog->NumAttributes;
break;
*params = prog->NumNativeAttributes;
return;
case GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB:
/* XXX same as GL_MAX_PROGRAM_ATTRIBS_ARB? */
if (target == GL_VERTEX_PROGRAM_ARB)
*params = ctx->Const.MaxVertexProgramAttribs;
else
*params = ctx->Const.MaxFragmentProgramAttribs;
break;
*params = limits->MaxNativeAttribs;
return;
case GL_PROGRAM_ADDRESS_REGISTERS_ARB:
*params = prog->NumAddressRegs;
break;
return;
case GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB:
if (target == GL_VERTEX_PROGRAM_ARB)
*params = ctx->Const.MaxVertexProgramAddressRegs;
else
*params = ctx->Const.MaxFragmentProgramAddressRegs;
break;
*params = limits->MaxAddressRegs;
return;
case GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB:
/* XXX same as GL_PROGRAM_ADDRESS_REGISTERS_ARB? */
*params = prog->NumAddressRegs;
break;
*params = prog->NumNativeAddressRegs;
return;
case GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB:
/* XXX same as GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB? */
if (target == GL_VERTEX_PROGRAM_ARB)
*params = ctx->Const.MaxVertexProgramAddressRegs;
else
*params = ctx->Const.MaxFragmentProgramAddressRegs;
break;
*params = limits->MaxNativeAddressRegs;
return;
case GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB:
if (target == GL_VERTEX_PROGRAM_ARB)
*params = ctx->Const.MaxVertexProgramLocalParams;
else
*params = ctx->Const.MaxFragmentProgramLocalParams;
break;
*params = limits->MaxLocalParams;
return;
case GL_MAX_PROGRAM_ENV_PARAMETERS_ARB:
if (target == GL_VERTEX_PROGRAM_ARB)
*params = ctx->Const.MaxVertexProgramEnvParams;
else
*params = ctx->Const.MaxFragmentProgramEnvParams;
break;
*params = limits->MaxEnvParams;
return;
case GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB:
/*
* XXX we may not really need a driver callback here.
* If the number of native instructions, registers, etc. used
* are all below the maximums, we could return true.
* The spec says that even if this query returns true, there's
* no guarantee that the program will run in hardware.
*/
if (ctx->Driver.IsProgramNative)
*params = ctx->Driver.IsProgramNative( ctx, target, prog );
else
*params = GL_TRUE;
return;
default:
/* continue with fragment-program only queries below */
break;
}
/*
* The following apply to fragment programs only.
* The following apply to fragment programs only (at this time)
*/
if (target == GL_FRAGMENT_PROGRAM_ARB) {
const struct fragment_program *fp = ctx->FragmentProgram.Current;
switch (pname) {
case GL_PROGRAM_ALU_INSTRUCTIONS_ARB:
*params = fp->NumNativeAluInstructions;
return;
case GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB:
if (target != GL_FRAGMENT_PROGRAM_ARB) {
_mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramivARB(target)");
*params = fp->NumAluInstructions;
return;
}
*params = ctx->FragmentProgram.Current->NumAluInstructions;
break;
case GL_PROGRAM_TEX_INSTRUCTIONS_ARB:
*params = fp->NumTexInstructions;
return;
case GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB:
if (target != GL_FRAGMENT_PROGRAM_ARB) {
_mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramivARB(target)");
*params = fp->NumNativeTexInstructions;
return;
}
*params = ctx->FragmentProgram.Current->NumTexInstructions;
break;
case GL_PROGRAM_TEX_INDIRECTIONS_ARB:
*params = fp->NumTexIndirections;
return;
case GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB:
if (target != GL_FRAGMENT_PROGRAM_ARB) {
_mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramivARB(target)");
*params = fp->NumNativeTexIndirections;
return;
}
*params = ctx->FragmentProgram.Current->NumTexIndirections;
break;
case GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB:
*params = limits->MaxAluInstructions;
return;
case GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB:
if (target != GL_FRAGMENT_PROGRAM_ARB) {
_mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramivARB(target)");
*params = limits->MaxNativeAluInstructions;
return;
}
*params = ctx->Const.MaxFragmentProgramAluInstructions;
break;
case GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB:
*params = limits->MaxTexInstructions;
return;
case GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB:
if (target != GL_FRAGMENT_PROGRAM_ARB) {
_mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramivARB(target)");
*params = limits->MaxNativeTexInstructions;
return;
}
*params = ctx->Const.MaxFragmentProgramTexInstructions;
break;
case GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB:
case GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB:
if (target != GL_FRAGMENT_PROGRAM_ARB) {
_mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramivARB(target)");
*params = limits->MaxTexIndirections;
return;
case GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB:
*params = limits->MaxNativeTexIndirections;
return;
}
*params = ctx->Const.MaxFragmentProgramTexIndirections;
break;
default:
_mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramivARB(pname)");
return;
}
}
}
void GLAPIENTRY
_mesa_GetProgramStringARB(GLenum target, GLenum pname, GLvoid *string)
{
struct program *prog;
const struct program *prog;
GET_CURRENT_CONTEXT(ctx);
if (!ctx->_CurrentProgram)
@@ -719,6 +684,5 @@ _mesa_GetProgramStringARB(GLenum target, GLenum pname, GLvoid *string)
return;
}
MEMCPY(string, prog->String, _mesa_strlen((char *) prog->String));
_mesa_memcpy(string, prog->String, _mesa_strlen((char *) prog->String));
}

8
src/mesa/shader/program.c
View File

@@ -1291,7 +1291,7 @@ _mesa_GetProgramRegisterfvMESA(GLenum target,
if (reg[0] == 'R') {
/* Temp register */
GLint i = _mesa_atoi(reg + 1);
if (i >= (GLint)ctx->Const.MaxVertexProgramTemps) {
if (i >= (GLint)ctx->Const.VertexProgram.MaxTemps) {
_mesa_error(ctx, GL_INVALID_VALUE,
"glGetProgramRegisterfvMESA(registerName)");
return;
@@ -1301,7 +1301,7 @@ _mesa_GetProgramRegisterfvMESA(GLenum target,
else if (reg[0] == 'v' && reg[1] == '[') {
/* Vertex Input attribute */
GLuint i;
for (i = 0; i < ctx->Const.MaxVertexProgramAttribs; i++) {
for (i = 0; i < ctx->Const.VertexProgram.MaxAttribs; i++) {
const char *name = _mesa_nv_vertex_input_register_name(i);
char number[10];
_mesa_sprintf(number, "%d", i);
@@ -1355,7 +1355,7 @@ _mesa_GetProgramRegisterfvMESA(GLenum target,
if (reg[0] == 'R') {
/* Temp register */
GLint i = _mesa_atoi(reg + 1);
if (i >= (GLint)ctx->Const.MaxFragmentProgramTemps) {
if (i >= (GLint)ctx->Const.FragmentProgram.MaxTemps) {
_mesa_error(ctx, GL_INVALID_VALUE,
"glGetProgramRegisterfvMESA(registerName)");
return;
@@ -1365,7 +1365,7 @@ _mesa_GetProgramRegisterfvMESA(GLenum target,
else if (reg[0] == 'f' && reg[1] == '[') {
/* Fragment input attribute */
GLuint i;
for (i = 0; i < ctx->Const.MaxFragmentProgramAttribs; i++) {
for (i = 0; i < ctx->Const.FragmentProgram.MaxAttribs; i++) {
const char *name = _mesa_nv_fragment_input_register_name(i);
if (_mesa_strncmp(reg + 2, name, 4) == 0) {
COPY_4V(v, ctx->FragmentProgram.Machine.Inputs[i]);

2
src/mesa/tnl/t_vp_build.c
View File

@@ -1504,7 +1504,7 @@ void _tnl_UpdateFixedFunctionProgram( GLcontext *ctx )
ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0);
create_new_program( key, ctx->_TnlProgram,
ctx->Const.MaxVertexProgramTemps );
ctx->Const.VertexProgram.MaxTemps );
cache_item(tnl->vp_cache, hash, key, ctx->_TnlProgram );
}