-#if FEATURE_MESA_program_debug
-static struct gl_program_machine *CurrentMachine = NULL;
-
-/**
- * For GL_MESA_program_debug.
- * Return current value (4*GLfloat) of a program register.
- * Called via ctx->Driver.GetFragmentProgramRegister().
- */
-void
-_mesa_get_program_register(GLcontext *ctx, enum register_file file,
- GLuint index, GLfloat val[4])
-{
- if (CurrentMachine) {
- switch (file) {
- case PROGRAM_INPUT:
- if (CurrentMachine->CurProgram->Target == GL_VERTEX_PROGRAM_ARB) {
- COPY_4V(val, CurrentMachine->VertAttribs[index]);
- }
- else {
- COPY_4V(val,
- CurrentMachine->Attribs[index][CurrentMachine->CurElement]);
- }
- break;
- case PROGRAM_OUTPUT:
- COPY_4V(val, CurrentMachine->Outputs[index]);
- break;
- case PROGRAM_TEMPORARY:
- COPY_4V(val, CurrentMachine->Temporaries[index]);
- break;
- default:
- _mesa_problem(NULL,
- "bad register file in _swrast_get_program_register");
- }
- }
-}
-#endif /* FEATURE_MESA_program_debug */
-
-
-
/**
* Return a pointer to the 4-element float vector specified by the given
* source register.
*/
static INLINE const GLfloat *
-get_register_pointer(GLcontext * ctx,
- const struct prog_src_register *source,
+get_register_pointer(const struct prog_src_register *source,
const struct gl_program_machine *machine)
{
if (source->RelAddr) {
const GLint reg = source->Index + machine->AddressReg[0][0];
- ASSERT( (source->File == PROGRAM_ENV_PARAM) ||
- (source->File == PROGRAM_STATE_VAR) );
- if (reg < 0 || reg > MAX_NV_VERTEX_PROGRAM_PARAMS)
- return ZeroVec;
- else if (source->File == PROGRAM_ENV_PARAM)
- return ctx->VertexProgram.Parameters[reg];
+ if (source->File == PROGRAM_ENV_PARAM)
+ if (reg < 0 || reg >= MAX_PROGRAM_ENV_PARAMS)
+ return ZeroVec;
+ else
+ return machine->EnvParams[reg];
else {
+ const struct gl_program_parameter_list *params;
ASSERT(source->File == PROGRAM_LOCAL_PARAM ||
source->File == PROGRAM_STATE_VAR);
- return machine->CurProgram->Parameters->ParameterValues[reg];
+ params = machine->CurProgram->Parameters;
+ if (reg < 0 || reg >= params->NumParameters)
+ return ZeroVec;
+ else
+ return params->ParameterValues[reg];
}
}
}
case PROGRAM_OUTPUT:
- /* This is only for PRINT */
- ASSERT(source->Index < FRAG_RESULT_MAX);
+ ASSERT(source->Index < MAX_PROGRAM_OUTPUTS);
return machine->Outputs[source->Index];
case PROGRAM_LOCAL_PARAM:
case PROGRAM_ENV_PARAM:
ASSERT(source->Index < MAX_PROGRAM_ENV_PARAMS);
- if (machine->CurProgram->Target == GL_VERTEX_PROGRAM_ARB)
- return ctx->VertexProgram.Parameters[source->Index];
- else
- return ctx->FragmentProgram.Parameters[source->Index];
+ return machine->EnvParams[source->Index];
case PROGRAM_STATE_VAR:
/* Fallthrough */
return machine->CurProgram->Parameters->ParameterValues[source->Index];
default:
- _mesa_problem(ctx,
+ _mesa_problem(NULL,
"Invalid input register file %d in get_register_pointer()",
source->File);
return NULL;
}
+#if FEATURE_MESA_program_debug
+static struct gl_program_machine *CurrentMachine = NULL;
+
+/**
+ * For GL_MESA_program_debug.
+ * Return current value (4*GLfloat) of a program register.
+ * Called via ctx->Driver.GetProgramRegister().
+ */
+void
+_mesa_get_program_register(GLcontext *ctx, enum register_file file,
+ GLuint index, GLfloat val[4])
+{
+ if (CurrentMachine) {
+ struct prog_src_register src;
+ const GLfloat *reg;
+ src.File = file;
+ src.Index = index;
+ reg = get_register_pointer(&src, CurrentMachine);
+ COPY_4V(val, reg);
+ }
+}
+#endif /* FEATURE_MESA_program_debug */
+
+
/**
* Fetch a 4-element float vector from the given source register.
* Apply swizzling and negating as needed.
*/
static void
-fetch_vector4(GLcontext * ctx,
- const struct prog_src_register *source,
+fetch_vector4(const struct prog_src_register *source,
const struct gl_program_machine *machine, GLfloat result[4])
{
- const GLfloat *src = get_register_pointer(ctx, source, machine);
+ const GLfloat *src = get_register_pointer(source, machine);
ASSERT(src);
if (source->Swizzle == SWIZZLE_NOOP) {
* As above, but only return result[0] element.
*/
static void
-fetch_vector1(GLcontext * ctx,
- const struct prog_src_register *source,
+fetch_vector1(const struct prog_src_register *source,
const struct gl_program_machine *machine, GLfloat result[4])
{
- const GLfloat *src = get_register_pointer(ctx, source, machine);
+ const GLfloat *src = get_register_pointer(source, machine);
ASSERT(src);
result[0] = src[GET_SWZ(source->Swizzle, 0)];
switch (dest->File) {
case PROGRAM_OUTPUT:
+ ASSERT(dest->Index < MAX_PROGRAM_OUTPUTS);
dstReg = machine->Outputs[dest->Index];
break;
case PROGRAM_TEMPORARY:
+ ASSERT(dest->Index < MAX_PROGRAM_TEMPS);
dstReg = machine->Temporaries[dest->Index];
break;
case PROGRAM_WRITE_ONLY:
* \param ctx - rendering context
* \param program - the fragment program to execute
* \param machine - machine state (register file)
- * \param maxInst - max number of instructions to execute
* \return GL_TRUE if program completed or GL_FALSE if program executed KIL.
*/
GLboolean
_mesa_execute_program(GLcontext * ctx,
- const struct gl_program *program, GLuint maxInst,
- struct gl_program_machine *machine, GLuint element)
+ const struct gl_program *program,
+ struct gl_program_machine *machine)
{
- const GLuint MAX_EXEC = 10000;
- GLint pc, total = 0;
+ const GLuint numInst = program->NumInstructions;
+ const GLuint maxExec = 10000;
+ GLint pc, numExec = 0;
machine->CurProgram = program;
CurrentMachine = machine;
#endif
- for (pc = 0; pc < maxInst; pc++) {
+ if (program->Target == GL_VERTEX_PROGRAM_ARB) {
+ machine->EnvParams = ctx->VertexProgram.Parameters;
+ }
+ else {
+ machine->EnvParams = ctx->FragmentProgram.Parameters;
+ }
+
+ for (pc = 0; pc < numInst; pc++) {
const struct prog_instruction *inst = program->Instructions + pc;
#if FEATURE_MESA_program_debug
case OPCODE_ABS:
{
GLfloat a[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
result[0] = FABSF(a[0]);
result[1] = FABSF(a[1]);
result[2] = FABSF(a[2]);
case OPCODE_ADD:
{
GLfloat a[4], b[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
- fetch_vector4(ctx, &inst->SrcReg[1], machine, b);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[1], machine, b);
result[0] = a[0] + b[0];
result[1] = a[1] + b[1];
result[2] = a[2] + b[2];
case OPCODE_ARL:
{
GLfloat t[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, t);
+ fetch_vector4(&inst->SrcReg[0], machine, t);
machine->AddressReg[0][0] = (GLint) FLOORF(t[0]);
}
break;
case OPCODE_CMP:
{
GLfloat a[4], b[4], c[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
- fetch_vector4(ctx, &inst->SrcReg[1], machine, b);
- fetch_vector4(ctx, &inst->SrcReg[2], machine, c);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[1], machine, b);
+ fetch_vector4(&inst->SrcReg[2], machine, c);
result[0] = a[0] < 0.0F ? b[0] : c[0];
result[1] = a[1] < 0.0F ? b[1] : c[1];
result[2] = a[2] < 0.0F ? b[2] : c[2];
case OPCODE_COS:
{
GLfloat a[4], result[4];
- fetch_vector1(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector1(&inst->SrcReg[0], machine, a);
result[0] = result[1] = result[2] = result[3]
= (GLfloat) _mesa_cos(a[0]);
store_vector4(inst, machine, result);
* Finally, find the difference in the register values for
* the original and derivative runs.
*/
- fetch_vector4(ctx, &inst->SrcReg[0], machine, program, a);
+ fetch_vector4(&inst->SrcReg[0], machine, program, a);
init_machine_deriv(ctx, machine, program, span,
'X', &dMachine);
execute_program(ctx, program, pc, &dMachine, span, column);
- fetch_vector4(ctx, &inst->SrcReg[0], &dMachine, program,
+ fetch_vector4(&inst->SrcReg[0], &dMachine, program,
aNext);
result[0] = aNext[0] - a[0];
result[1] = aNext[1] - a[1];
column, result)) {
init_machine_deriv(ctx, machine, program, span,
'Y', &dMachine);
- fetch_vector4(ctx, &inst->SrcReg[0], machine, program, a);
+ fetch_vector4(&inst->SrcReg[0], machine, program, a);
execute_program(ctx, program, pc, &dMachine, span, column);
- fetch_vector4(ctx, &inst->SrcReg[0], &dMachine, program,
+ fetch_vector4(&inst->SrcReg[0], &dMachine, program,
aNext);
result[0] = aNext[0] - a[0];
result[1] = aNext[1] - a[1];
case OPCODE_DP3:
{
GLfloat a[4], b[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
- fetch_vector4(ctx, &inst->SrcReg[1], machine, b);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[1], machine, b);
result[0] = result[1] = result[2] = result[3] = DOT3(a, b);
store_vector4(inst, machine, result);
if (DEBUG_PROG) {
case OPCODE_DP4:
{
GLfloat a[4], b[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
- fetch_vector4(ctx, &inst->SrcReg[1], machine, b);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[1], machine, b);
result[0] = result[1] = result[2] = result[3] = DOT4(a, b);
store_vector4(inst, machine, result);
if (DEBUG_PROG) {
case OPCODE_DPH:
{
GLfloat a[4], b[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
- fetch_vector4(ctx, &inst->SrcReg[1], machine, b);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[1], machine, b);
result[0] = result[1] = result[2] = result[3] =
a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + b[3];
store_vector4(inst, machine, result);
case OPCODE_DST: /* Distance vector */
{
GLfloat a[4], b[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
- fetch_vector4(ctx, &inst->SrcReg[1], machine, b);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[1], machine, b);
result[0] = 1.0F;
result[1] = a[1] * b[1];
result[2] = a[2];
case OPCODE_EXP:
{
GLfloat t[4], q[4], floor_t0;
- fetch_vector1(ctx, &inst->SrcReg[0], machine, t);
+ fetch_vector1(&inst->SrcReg[0], machine, t);
floor_t0 = FLOORF(t[0]);
if (floor_t0 > FLT_MAX_EXP) {
SET_POS_INFINITY(q[0]);
case OPCODE_EX2: /* Exponential base 2 */
{
GLfloat a[4], result[4];
- fetch_vector1(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector1(&inst->SrcReg[0], machine, a);
result[0] = result[1] = result[2] = result[3] =
(GLfloat) _mesa_pow(2.0, a[0]);
store_vector4(inst, machine, result);
case OPCODE_FLR:
{
GLfloat a[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
result[0] = FLOORF(a[0]);
result[1] = FLOORF(a[1]);
result[2] = FLOORF(a[2]);
case OPCODE_FRC:
{
GLfloat a[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
result[0] = a[0] - FLOORF(a[0]);
result[1] = a[1] - FLOORF(a[1]);
result[2] = a[2] - FLOORF(a[2]);
case OPCODE_INT: /* float to int */
{
GLfloat a[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
result[0] = (GLfloat) (GLint) a[0];
result[1] = (GLfloat) (GLint) a[1];
result[2] = (GLfloat) (GLint) a[2];
case OPCODE_KIL: /* ARB_f_p only */
{
GLfloat a[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
if (a[0] < 0.0F || a[1] < 0.0F || a[2] < 0.0F || a[3] < 0.0F) {
return GL_FALSE;
}
case OPCODE_LG2: /* log base 2 */
{
GLfloat a[4], result[4];
- fetch_vector1(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector1(&inst->SrcReg[0], machine, a);
result[0] = result[1] = result[2] = result[3] = LOG2(a[0]);
store_vector4(inst, machine, result);
}
{
const GLfloat epsilon = 1.0F / 256.0F; /* from NV VP spec */
GLfloat a[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
a[0] = MAX2(a[0], 0.0F);
a[1] = MAX2(a[1], 0.0F);
/* XXX ARB version clamps a[3], NV version doesn't */
case OPCODE_LOG:
{
GLfloat t[4], q[4], abs_t0;
- fetch_vector1(ctx, &inst->SrcReg[0], machine, t);
+ fetch_vector1(&inst->SrcReg[0], machine, t);
abs_t0 = FABSF(t[0]);
if (abs_t0 != 0.0F) {
/* Since we really can't handle infinite values on VMS
case OPCODE_LRP:
{
GLfloat a[4], b[4], c[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
- fetch_vector4(ctx, &inst->SrcReg[1], machine, b);
- fetch_vector4(ctx, &inst->SrcReg[2], machine, c);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[1], machine, b);
+ fetch_vector4(&inst->SrcReg[2], machine, c);
result[0] = a[0] * b[0] + (1.0F - a[0]) * c[0];
result[1] = a[1] * b[1] + (1.0F - a[1]) * c[1];
result[2] = a[2] * b[2] + (1.0F - a[2]) * c[2];
case OPCODE_MAD:
{
GLfloat a[4], b[4], c[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
- fetch_vector4(ctx, &inst->SrcReg[1], machine, b);
- fetch_vector4(ctx, &inst->SrcReg[2], machine, c);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[1], machine, b);
+ fetch_vector4(&inst->SrcReg[2], machine, c);
result[0] = a[0] * b[0] + c[0];
result[1] = a[1] * b[1] + c[1];
result[2] = a[2] * b[2] + c[2];
case OPCODE_MAX:
{
GLfloat a[4], b[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
- fetch_vector4(ctx, &inst->SrcReg[1], machine, b);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[1], machine, b);
result[0] = MAX2(a[0], b[0]);
result[1] = MAX2(a[1], b[1]);
result[2] = MAX2(a[2], b[2]);
case OPCODE_MIN:
{
GLfloat a[4], b[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
- fetch_vector4(ctx, &inst->SrcReg[1], machine, b);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[1], machine, b);
result[0] = MIN2(a[0], b[0]);
result[1] = MIN2(a[1], b[1]);
result[2] = MIN2(a[2], b[2]);
case OPCODE_MOV:
{
GLfloat result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, result);
+ fetch_vector4(&inst->SrcReg[0], machine, result);
store_vector4(inst, machine, result);
if (DEBUG_PROG) {
printf("MOV (%g %g %g %g)\n",
case OPCODE_MUL:
{
GLfloat a[4], b[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
- fetch_vector4(ctx, &inst->SrcReg[1], machine, b);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[1], machine, b);
result[0] = a[0] * b[0];
result[1] = a[1] * b[1];
result[2] = a[2] * b[2];
case OPCODE_NOISE1:
{
GLfloat a[4], result[4];
- fetch_vector1(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector1(&inst->SrcReg[0], machine, a);
result[0] =
result[1] =
result[2] = result[3] = _slang_library_noise1(a[0]);
case OPCODE_NOISE2:
{
GLfloat a[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
result[0] =
result[1] =
result[2] = result[3] = _slang_library_noise2(a[0], a[1]);
case OPCODE_NOISE3:
{
GLfloat a[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
result[0] =
result[1] =
result[2] =
case OPCODE_NOISE4:
{
GLfloat a[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
result[0] =
result[1] =
result[2] =
GLhalfNV hx, hy;
GLuint *rawResult = (GLuint *) result;
GLuint twoHalves;
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
hx = _mesa_float_to_half(a[0]);
hy = _mesa_float_to_half(a[1]);
twoHalves = hx | (hy << 16);
{
GLfloat a[4], result[4];
GLuint usx, usy, *rawResult = (GLuint *) result;
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
a[0] = CLAMP(a[0], 0.0F, 1.0F);
a[1] = CLAMP(a[1], 0.0F, 1.0F);
usx = IROUND(a[0] * 65535.0F);
{
GLfloat a[4], result[4];
GLuint ubx, uby, ubz, ubw, *rawResult = (GLuint *) result;
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
a[0] = CLAMP(a[0], -128.0F / 127.0F, 1.0F);
a[1] = CLAMP(a[1], -128.0F / 127.0F, 1.0F);
a[2] = CLAMP(a[2], -128.0F / 127.0F, 1.0F);
{
GLfloat a[4], result[4];
GLuint ubx, uby, ubz, ubw, *rawResult = (GLuint *) result;
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
a[0] = CLAMP(a[0], 0.0F, 1.0F);
a[1] = CLAMP(a[1], 0.0F, 1.0F);
a[2] = CLAMP(a[2], 0.0F, 1.0F);
case OPCODE_POW:
{
GLfloat a[4], b[4], result[4];
- fetch_vector1(ctx, &inst->SrcReg[0], machine, a);
- fetch_vector1(ctx, &inst->SrcReg[1], machine, b);
+ fetch_vector1(&inst->SrcReg[0], machine, a);
+ fetch_vector1(&inst->SrcReg[1], machine, b);
result[0] = result[1] = result[2] = result[3]
= (GLfloat) _mesa_pow(a[0], b[0]);
store_vector4(inst, machine, result);
case OPCODE_RCP:
{
GLfloat a[4], result[4];
- fetch_vector1(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector1(&inst->SrcReg[0], machine, a);
if (DEBUG_PROG) {
if (a[0] == 0)
printf("RCP(0)\n");
case OPCODE_RFL: /* reflection vector */
{
GLfloat axis[4], dir[4], result[4], tmpX, tmpW;
- fetch_vector4(ctx, &inst->SrcReg[0], machine, axis);
- fetch_vector4(ctx, &inst->SrcReg[1], machine, dir);
+ fetch_vector4(&inst->SrcReg[0], machine, axis);
+ fetch_vector4(&inst->SrcReg[1], machine, dir);
tmpW = DOT3(axis, axis);
tmpX = (2.0F * DOT3(axis, dir)) / tmpW;
result[0] = tmpX * axis[0] - dir[0];
case OPCODE_RSQ: /* 1 / sqrt() */
{
GLfloat a[4], result[4];
- fetch_vector1(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector1(&inst->SrcReg[0], machine, a);
a[0] = FABSF(a[0]);
result[0] = result[1] = result[2] = result[3] = INV_SQRTF(a[0]);
store_vector4(inst, machine, result);
case OPCODE_SCS: /* sine and cos */
{
GLfloat a[4], result[4];
- fetch_vector1(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector1(&inst->SrcReg[0], machine, a);
result[0] = (GLfloat) _mesa_cos(a[0]);
result[1] = (GLfloat) _mesa_sin(a[0]);
result[2] = 0.0; /* undefined! */
case OPCODE_SEQ: /* set on equal */
{
GLfloat a[4], b[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
- fetch_vector4(ctx, &inst->SrcReg[1], machine, b);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[1], machine, b);
result[0] = (a[0] == b[0]) ? 1.0F : 0.0F;
result[1] = (a[1] == b[1]) ? 1.0F : 0.0F;
result[2] = (a[2] == b[2]) ? 1.0F : 0.0F;
case OPCODE_SGE: /* set on greater or equal */
{
GLfloat a[4], b[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
- fetch_vector4(ctx, &inst->SrcReg[1], machine, b);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[1], machine, b);
result[0] = (a[0] >= b[0]) ? 1.0F : 0.0F;
result[1] = (a[1] >= b[1]) ? 1.0F : 0.0F;
result[2] = (a[2] >= b[2]) ? 1.0F : 0.0F;
case OPCODE_SGT: /* set on greater */
{
GLfloat a[4], b[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
- fetch_vector4(ctx, &inst->SrcReg[1], machine, b);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[1], machine, b);
result[0] = (a[0] > b[0]) ? 1.0F : 0.0F;
result[1] = (a[1] > b[1]) ? 1.0F : 0.0F;
result[2] = (a[2] > b[2]) ? 1.0F : 0.0F;
case OPCODE_SIN:
{
GLfloat a[4], result[4];
- fetch_vector1(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector1(&inst->SrcReg[0], machine, a);
result[0] = result[1] = result[2] = result[3]
= (GLfloat) _mesa_sin(a[0]);
store_vector4(inst, machine, result);
case OPCODE_SLE: /* set on less or equal */
{
GLfloat a[4], b[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
- fetch_vector4(ctx, &inst->SrcReg[1], machine, b);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[1], machine, b);
result[0] = (a[0] <= b[0]) ? 1.0F : 0.0F;
result[1] = (a[1] <= b[1]) ? 1.0F : 0.0F;
result[2] = (a[2] <= b[2]) ? 1.0F : 0.0F;
case OPCODE_SLT: /* set on less */
{
GLfloat a[4], b[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
- fetch_vector4(ctx, &inst->SrcReg[1], machine, b);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[1], machine, b);
result[0] = (a[0] < b[0]) ? 1.0F : 0.0F;
result[1] = (a[1] < b[1]) ? 1.0F : 0.0F;
result[2] = (a[2] < b[2]) ? 1.0F : 0.0F;
case OPCODE_SNE: /* set on not equal */
{
GLfloat a[4], b[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
- fetch_vector4(ctx, &inst->SrcReg[1], machine, b);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[1], machine, b);
result[0] = (a[0] != b[0]) ? 1.0F : 0.0F;
result[1] = (a[1] != b[1]) ? 1.0F : 0.0F;
result[2] = (a[2] != b[2]) ? 1.0F : 0.0F;
case OPCODE_SUB:
{
GLfloat a[4], b[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
- fetch_vector4(ctx, &inst->SrcReg[1], machine, b);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[1], machine, b);
result[0] = a[0] - b[0];
result[1] = a[1] - b[1];
result[2] = a[2] - b[2];
case OPCODE_SWZ: /* extended swizzle */
{
const struct prog_src_register *source = &inst->SrcReg[0];
- const GLfloat *src = get_register_pointer(ctx, source, machine);
+ const GLfloat *src = get_register_pointer(source, machine);
GLfloat result[4];
GLuint i;
for (i = 0; i < 4; i++) {
else
#endif
lambda = 0.0;
- fetch_vector4(ctx, &inst->SrcReg[0], machine, coord);
+ fetch_vector4(&inst->SrcReg[0], machine, coord);
machine->FetchTexelLod(ctx, coord, lambda, inst->TexSrcUnit,
color);
if (DEBUG_PROG) {
else
#endif
lambda = 0.0;
- fetch_vector4(ctx, &inst->SrcReg[0], machine, coord);
+ fetch_vector4(&inst->SrcReg[0], machine, coord);
/* coord[3] is the bias to add to lambda */
bias = texUnit->LodBias + coord[3];
if (texUnit->_Current)
/* Texture lookup w/ partial derivatives for LOD */
{
GLfloat texcoord[4], dtdx[4], dtdy[4], color[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, texcoord);
- fetch_vector4(ctx, &inst->SrcReg[1], machine, dtdx);
- fetch_vector4(ctx, &inst->SrcReg[2], machine, dtdy);
+ fetch_vector4(&inst->SrcReg[0], machine, texcoord);
+ fetch_vector4(&inst->SrcReg[1], machine, dtdx);
+ fetch_vector4(&inst->SrcReg[2], machine, dtdy);
machine->FetchTexelDeriv(ctx, texcoord, dtdx, dtdy,
inst->TexSrcUnit, color);
store_vector4(inst, machine, color);
else
#endif
lambda = 0.0;
- fetch_vector4(ctx, &inst->SrcReg[0], machine, texcoord);
+ fetch_vector4(&inst->SrcReg[0], machine, texcoord);
/* Not so sure about this test - if texcoord[3] is
* zero, we'd probably be fine except for an ASSERT in
* IROUND_POS() which gets triggered by the inf values created.
else
#endif
lambda = 0.0;
- fetch_vector4(ctx, &inst->SrcReg[0], machine, texcoord);
+ fetch_vector4(&inst->SrcReg[0], machine, texcoord);
if (inst->TexSrcTarget != TEXTURE_CUBE_INDEX &&
texcoord[3] != 0.0) {
texcoord[0] /= texcoord[3];
GLfloat a[4], result[4];
const GLuint *rawBits = (const GLuint *) a;
GLhalfNV hx, hy;
- fetch_vector1(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector1(&inst->SrcReg[0], machine, a);
hx = rawBits[0] & 0xffff;
hy = rawBits[0] >> 16;
result[0] = result[2] = _mesa_half_to_float(hx);
GLfloat a[4], result[4];
const GLuint *rawBits = (const GLuint *) a;
GLushort usx, usy;
- fetch_vector1(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector1(&inst->SrcReg[0], machine, a);
usx = rawBits[0] & 0xffff;
usy = rawBits[0] >> 16;
result[0] = result[2] = usx * (1.0f / 65535.0f);
{
GLfloat a[4], result[4];
const GLuint *rawBits = (const GLuint *) a;
- fetch_vector1(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector1(&inst->SrcReg[0], machine, a);
result[0] = (((rawBits[0] >> 0) & 0xff) - 128) / 127.0F;
result[1] = (((rawBits[0] >> 8) & 0xff) - 128) / 127.0F;
result[2] = (((rawBits[0] >> 16) & 0xff) - 128) / 127.0F;
{
GLfloat a[4], result[4];
const GLuint *rawBits = (const GLuint *) a;
- fetch_vector1(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector1(&inst->SrcReg[0], machine, a);
result[0] = ((rawBits[0] >> 0) & 0xff) / 255.0F;
result[1] = ((rawBits[0] >> 8) & 0xff) / 255.0F;
result[2] = ((rawBits[0] >> 16) & 0xff) / 255.0F;
case OPCODE_XPD: /* cross product */
{
GLfloat a[4], b[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
- fetch_vector4(ctx, &inst->SrcReg[1], machine, b);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[1], machine, b);
result[0] = a[1] * b[2] - a[2] * b[1];
result[1] = a[2] * b[0] - a[0] * b[2];
result[2] = a[0] * b[1] - a[1] * b[0];
case OPCODE_X2D: /* 2-D matrix transform */
{
GLfloat a[4], b[4], c[4], result[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
- fetch_vector4(ctx, &inst->SrcReg[1], machine, b);
- fetch_vector4(ctx, &inst->SrcReg[2], machine, c);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[1], machine, b);
+ fetch_vector4(&inst->SrcReg[2], machine, c);
result[0] = a[0] + b[0] * c[0] + b[1] * c[1];
result[1] = a[1] + b[0] * c[2] + b[1] * c[3];
result[2] = a[2] + b[0] * c[0] + b[1] * c[1];
{
if (inst->SrcReg[0].File != -1) {
GLfloat a[4];
- fetch_vector4(ctx, &inst->SrcReg[0], machine, a);
+ fetch_vector4(&inst->SrcReg[0], machine, a);
_mesa_printf("%s%g, %g, %g, %g\n", (const char *) inst->Data,
a[0], a[1], a[2], a[3]);
}
}
- total++;
- if (total > MAX_EXEC) {
+ numExec++;
+ if (numExec > maxExec) {
_mesa_problem(ctx, "Infinite loop detected in fragment program");
return GL_TRUE;
- abort();
}
} /* for pc */
projects / mesa.git / blobdiff