summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/mesa/drivers/dri/i915/i915_fragprog.c80
-rw-r--r--src/mesa/drivers/dri/r300/r300_fragprog.c86
-rw-r--r--src/mesa/drivers/dri/r300/r300_fragprog.h2
-rw-r--r--src/mesa/drivers/dri/r300/r300_shader.c2
-rw-r--r--src/mesa/drivers/dri/r300/r300_vertexprog.c86
-rw-r--r--src/mesa/drivers/glide/fxtris.c2
-rw-r--r--src/mesa/main/mtypes.h7
-rw-r--r--src/mesa/main/texenvprogram.c60
-rw-r--r--src/mesa/shader/arbfragparse.c10
-rw-r--r--src/mesa/shader/arbfragparse.h2
-rw-r--r--src/mesa/shader/arbprogparse.c171
-rw-r--r--src/mesa/shader/arbprogparse.h7
-rw-r--r--src/mesa/shader/arbprogram.c3
-rw-r--r--src/mesa/shader/arbvertparse.c24
-rw-r--r--src/mesa/shader/arbvertparse.h2
-rw-r--r--src/mesa/shader/nvfragparse.c179
-rw-r--r--src/mesa/shader/nvfragprog.h168
-rw-r--r--src/mesa/shader/nvprogram.c3
-rw-r--r--src/mesa/shader/nvvertexec.c82
-rw-r--r--src/mesa/shader/nvvertparse.c191
-rw-r--r--src/mesa/shader/nvvertparse.h2
-rw-r--r--src/mesa/shader/nvvertprog.h115
-rw-r--r--src/mesa/shader/program.c3
-rw-r--r--src/mesa/shader/program_instruction.h344
-rw-r--r--src/mesa/swrast/s_fragprog_to_c.c163
-rw-r--r--src/mesa/swrast/s_nvfragprog.c134
-rw-r--r--src/mesa/swrast/s_tcc.c2
-rw-r--r--src/mesa/tnl/t_vb_arbprogram.c107
-rw-r--r--src/mesa/tnl/t_vb_arbprogram.h6
-rw-r--r--src/mesa/tnl/t_vb_program.c2
-rw-r--r--src/mesa/tnl/t_vp_build.c192
31 files changed, 1170 insertions, 1067 deletions
diff --git a/src/mesa/drivers/dri/i915/i915_fragprog.c b/src/mesa/drivers/dri/i915/i915_fragprog.c
index 77a72d6182..4602b3260e 100644
--- a/src/mesa/drivers/dri/i915/i915_fragprog.c
+++ b/src/mesa/drivers/dri/i915/i915_fragprog.c
@@ -36,7 +36,7 @@
#include "i915_context.h"
#include "i915_program.h"
-#include "nvfragprog.h"
+#include "program_instruction.h"
#include "program.h"
#include "arbfragparse.h"
@@ -63,7 +63,7 @@ static const GLfloat cos_constants[4] = { 1.0,
* constants, apply swizzling and negation as needed.
*/
static GLuint src_vector( struct i915_fragment_program *p,
- const struct fp_src_register *source,
+ const struct prog_src_register *source,
const struct fragment_program *program )
{
GLuint src;
@@ -156,7 +156,7 @@ static GLuint src_vector( struct i915_fragment_program *p,
static GLuint get_result_vector( struct i915_fragment_program *p,
- const struct fp_instruction *inst )
+ const struct prog_instruction *inst )
{
switch (inst->DstReg.File) {
case PROGRAM_OUTPUT:
@@ -178,7 +178,7 @@ static GLuint get_result_vector( struct i915_fragment_program *p,
}
}
-static GLuint get_result_flags( const struct fp_instruction *inst )
+static GLuint get_result_flags( const struct prog_instruction *inst )
{
GLuint flags = 0;
@@ -250,7 +250,7 @@ do { \
static void upload_program( struct i915_fragment_program *p )
{
const struct fragment_program *program = p->ctx->FragmentProgram._Current;
- const struct fp_instruction *inst = program->Instructions;
+ const struct prog_instruction *inst = program->Instructions;
/* _mesa_debug_fp_inst(program->Base.NumInstructions, inst); */
@@ -258,7 +258,7 @@ static void upload_program( struct i915_fragment_program *p )
* loaded, as the flagging of an error isn't sufficient to stop
* this being uploaded to hardware.
*/
- if (inst[0].Opcode == FP_OPCODE_END) {
+ if (inst[0].Opcode == OPCODE_END) {
GLuint tmp = i915_get_utemp( p );
i915_emit_arith( p,
A0_MOV,
@@ -273,7 +273,7 @@ static void upload_program( struct i915_fragment_program *p )
GLuint tmp = 0;
switch (inst->Opcode) {
- case FP_OPCODE_ABS:
+ case OPCODE_ABS:
src0 = src_vector( p, &inst->SrcReg[0], program);
i915_emit_arith( p,
A0_MAX,
@@ -282,11 +282,11 @@ static void upload_program( struct i915_fragment_program *p )
src0, negate(src0, 1,1,1,1), 0);
break;
- case FP_OPCODE_ADD:
+ case OPCODE_ADD:
EMIT_2ARG_ARITH( A0_ADD );
break;
- case FP_OPCODE_CMP:
+ case OPCODE_CMP:
src0 = src_vector( p, &inst->SrcReg[0], program);
src1 = src_vector( p, &inst->SrcReg[1], program);
src2 = src_vector( p, &inst->SrcReg[2], program);
@@ -297,7 +297,7 @@ static void upload_program( struct i915_fragment_program *p )
src0, src2, src1); /* NOTE: order of src2, src1 */
break;
- case FP_OPCODE_COS:
+ case OPCODE_COS:
src0 = src_vector( p, &inst->SrcReg[0], program);
tmp = i915_get_utemp( p );
@@ -356,15 +356,15 @@ static void upload_program( struct i915_fragment_program *p )
break;
- case FP_OPCODE_DP3:
+ case OPCODE_DP3:
EMIT_2ARG_ARITH( A0_DP3 );
break;
- case FP_OPCODE_DP4:
+ case OPCODE_DP4:
EMIT_2ARG_ARITH( A0_DP4 );
break;
- case FP_OPCODE_DPH:
+ case OPCODE_DPH:
src0 = src_vector( p, &inst->SrcReg[0], program);
src1 = src_vector( p, &inst->SrcReg[1], program);
@@ -375,7 +375,7 @@ static void upload_program( struct i915_fragment_program *p )
swizzle(src0, X,Y,Z,ONE), src1, 0);
break;
- case FP_OPCODE_DST:
+ case OPCODE_DST:
src0 = src_vector( p, &inst->SrcReg[0], program);
src1 = src_vector( p, &inst->SrcReg[1], program);
@@ -393,7 +393,7 @@ static void upload_program( struct i915_fragment_program *p )
0);
break;
- case FP_OPCODE_EX2:
+ case OPCODE_EX2:
src0 = src_vector( p, &inst->SrcReg[0], program);
i915_emit_arith( p,
@@ -403,15 +403,15 @@ static void upload_program( struct i915_fragment_program *p )
swizzle(src0,X,X,X,X), 0, 0);
break;
- case FP_OPCODE_FLR:
+ case OPCODE_FLR:
EMIT_1ARG_ARITH( A0_FLR );
break;
- case FP_OPCODE_FRC:
+ case OPCODE_FRC:
EMIT_1ARG_ARITH( A0_FRC );
break;
- case FP_OPCODE_KIL:
+ case OPCODE_KIL:
src0 = src_vector( p, &inst->SrcReg[0], program);
tmp = i915_get_utemp( p );
@@ -422,7 +422,7 @@ static void upload_program( struct i915_fragment_program *p )
T0_TEXKILL );
break;
- case FP_OPCODE_LG2:
+ case OPCODE_LG2:
src0 = src_vector( p, &inst->SrcReg[0], program);
i915_emit_arith( p,
@@ -432,7 +432,7 @@ static void upload_program( struct i915_fragment_program *p )
swizzle(src0,X,X,X,X), 0, 0);
break;
- case FP_OPCODE_LIT:
+ case OPCODE_LIT:
src0 = src_vector( p, &inst->SrcReg[0], program);
tmp = i915_get_utemp( p );
@@ -465,7 +465,7 @@ static void upload_program( struct i915_fragment_program *p )
break;
- case FP_OPCODE_LRP:
+ case OPCODE_LRP:
src0 = src_vector( p, &inst->SrcReg[0], program);
src1 = src_vector( p, &inst->SrcReg[1], program);
src2 = src_vector( p, &inst->SrcReg[2], program);
@@ -489,15 +489,15 @@ static void upload_program( struct i915_fragment_program *p )
negate(src2, 1,1,1,1), src0, tmp );
break;
- case FP_OPCODE_MAD:
+ case OPCODE_MAD:
EMIT_3ARG_ARITH( A0_MAD );
break;
- case FP_OPCODE_MAX:
+ case OPCODE_MAX:
EMIT_2ARG_ARITH( A0_MAX );
break;
- case FP_OPCODE_MIN:
+ case OPCODE_MIN:
src0 = src_vector( p, &inst->SrcReg[0], program);
src1 = src_vector( p, &inst->SrcReg[1], program);
tmp = i915_get_utemp( p );
@@ -516,15 +516,15 @@ static void upload_program( struct i915_fragment_program *p )
negate(tmp, 1,1,1,1), 0, 0);
break;
- case FP_OPCODE_MOV:
+ case OPCODE_MOV:
EMIT_1ARG_ARITH( A0_MOV );
break;
- case FP_OPCODE_MUL:
+ case OPCODE_MUL:
EMIT_2ARG_ARITH( A0_MUL );
break;
- case FP_OPCODE_POW:
+ case OPCODE_POW:
src0 = src_vector( p, &inst->SrcReg[0], program);
src1 = src_vector( p, &inst->SrcReg[1], program);
tmp = i915_get_utemp( p );
@@ -551,7 +551,7 @@ static void upload_program( struct i915_fragment_program *p )
break;
- case FP_OPCODE_RCP:
+ case OPCODE_RCP:
src0 = src_vector( p, &inst->SrcReg[0], program);
i915_emit_arith( p,
@@ -561,7 +561,7 @@ static void upload_program( struct i915_fragment_program *p )
swizzle(src0,X,X,X,X), 0, 0);
break;
- case FP_OPCODE_RSQ:
+ case OPCODE_RSQ:
src0 = src_vector( p, &inst->SrcReg[0], program);
@@ -572,7 +572,7 @@ static void upload_program( struct i915_fragment_program *p )
swizzle(src0,X,X,X,X), 0, 0);
break;
- case FP_OPCODE_SCS:
+ case OPCODE_SCS:
src0 = src_vector( p, &inst->SrcReg[0], program);
tmp = i915_get_utemp( p );
@@ -634,11 +634,11 @@ static void upload_program( struct i915_fragment_program *p )
}
break;
- case FP_OPCODE_SGE:
+ case OPCODE_SGE:
EMIT_2ARG_ARITH( A0_SGE );
break;
- case FP_OPCODE_SIN:
+ case OPCODE_SIN:
src0 = src_vector( p, &inst->SrcReg[0], program);
tmp = i915_get_utemp( p );
@@ -696,11 +696,11 @@ static void upload_program( struct i915_fragment_program *p )
i915_emit_const4fv( p, sin_constants ), 0);
break;
- case FP_OPCODE_SLT:
+ case OPCODE_SLT:
EMIT_2ARG_ARITH( A0_SLT );
break;
- case FP_OPCODE_SUB:
+ case OPCODE_SUB:
src0 = src_vector( p, &inst->SrcReg[0], program);
src1 = src_vector( p, &inst->SrcReg[1], program);
@@ -711,23 +711,23 @@ static void upload_program( struct i915_fragment_program *p )
src0, negate(src1, 1,1,1,1), 0);
break;
- case FP_OPCODE_SWZ:
+ case OPCODE_SWZ:
EMIT_1ARG_ARITH( A0_MOV ); /* extended swizzle handled natively */
break;
- case FP_OPCODE_TEX:
+ case OPCODE_TEX:
EMIT_TEX( T0_TEXLD );
break;
- case FP_OPCODE_TXB:
+ case OPCODE_TXB:
EMIT_TEX( T0_TEXLDB );
break;
- case FP_OPCODE_TXP:
+ case OPCODE_TXP:
EMIT_TEX( T0_TEXLDP );
break;
- case FP_OPCODE_XPD:
+ case OPCODE_XPD:
/* Cross product:
* result.x = src0.y * src1.z - src0.z * src1.y;
* result.y = src0.z * src1.x - src0.x * src1.z;
@@ -753,7 +753,7 @@ static void upload_program( struct i915_fragment_program *p )
negate(tmp,1,1,1,0));
break;
- case FP_OPCODE_END:
+ case OPCODE_END:
return;
default:
diff --git a/src/mesa/drivers/dri/r300/r300_fragprog.c b/src/mesa/drivers/dri/r300/r300_fragprog.c
index 35b254616b..2d896c46e3 100644
--- a/src/mesa/drivers/dri/r300/r300_fragprog.c
+++ b/src/mesa/drivers/dri/r300/r300_fragprog.c
@@ -49,7 +49,7 @@
#include "arbfragparse.h"
#include "program.h"
-#include "nvfragprog.h"
+#include "program_instruction.h"
#include "r300_context.h"
#if USE_ARB_F_P == 1
#include "r300_fragprog.h"
@@ -400,7 +400,7 @@ static pfs_reg_t swizzle(struct r300_fragment_program *rp,
}
static pfs_reg_t t_src(struct r300_fragment_program *rp,
- struct fp_src_register fpsrc) {
+ struct prog_src_register fpsrc) {
pfs_reg_t r = pfs_default_reg;
switch (fpsrc.File) {
@@ -442,7 +442,7 @@ static pfs_reg_t t_src(struct r300_fragment_program *rp,
}
static pfs_reg_t t_dst(struct r300_fragment_program *rp,
- struct fp_dst_register dest) {
+ struct prog_dst_register dest) {
pfs_reg_t r = pfs_default_reg;
switch (dest.File) {
@@ -489,7 +489,7 @@ static void sync_streams(struct r300_fragment_program *rp) {
}
static void emit_tex(struct r300_fragment_program *rp,
- struct fp_instruction *fpi,
+ struct prog_instruction *fpi,
int opcode)
{
pfs_reg_t coord = t_src(rp, fpi->SrcReg[0]);
@@ -747,37 +747,37 @@ static void emit_arith(struct r300_fragment_program *rp, int op,
static GLboolean parse_program(struct r300_fragment_program *rp)
{
struct fragment_program *mp = &rp->mesa_program;
- const struct fp_instruction *inst = mp->Instructions;
- struct fp_instruction *fpi;
+ const struct prog_instruction *inst = mp->Instructions;
+ struct prog_instruction *fpi;
pfs_reg_t src0, src1, src2, dest, temp;
int flags = 0;
- if (!inst || inst[0].Opcode == FP_OPCODE_END) {
+ if (!inst || inst[0].Opcode == OPCODE_END) {
ERROR("empty program?\n");
return GL_FALSE;
}
- for (fpi=mp->Instructions; fpi->Opcode != FP_OPCODE_END; fpi++) {
+ for (fpi=mp->Instructions; fpi->Opcode != OPCODE_END; fpi++) {
if (fpi->Saturate) {
flags = PFS_FLAG_SAT;
}
switch (fpi->Opcode) {
- case FP_OPCODE_ABS:
+ case OPCODE_ABS:
ERROR("unknown fpi->Opcode %d\n", fpi->Opcode);
break;
- case FP_OPCODE_ADD:
+ case OPCODE_ADD:
emit_arith(rp, PFS_OP_MAD, t_dst(rp, fpi->DstReg), fpi->DstReg.WriteMask,
t_src(rp, fpi->SrcReg[0]),
pfs_one,
t_src(rp, fpi->SrcReg[1]),
flags);
break;
- case FP_OPCODE_CMP:
- case FP_OPCODE_COS:
+ case OPCODE_CMP:
+ case OPCODE_COS:
ERROR("unknown fpi->Opcode %d\n", fpi->Opcode);
break;
- case FP_OPCODE_DP3:
+ case OPCODE_DP3:
dest = t_dst(rp, fpi->DstReg);
if (fpi->DstReg.WriteMask & WRITEMASK_W) {
/* I assume these need to share the same alu slot */
@@ -792,18 +792,18 @@ static GLboolean parse_program(struct r300_fragment_program *rp)
t_src(rp, fpi->SrcReg[1]),
pfs_zero, flags);
break;
- case FP_OPCODE_DP4:
- case FP_OPCODE_DPH:
- case FP_OPCODE_DST:
- case FP_OPCODE_EX2:
- case FP_OPCODE_FLR:
- case FP_OPCODE_FRC:
- case FP_OPCODE_KIL:
- case FP_OPCODE_LG2:
- case FP_OPCODE_LIT:
+ case OPCODE_DP4:
+ case OPCODE_DPH:
+ case OPCODE_DST:
+ case OPCODE_EX2:
+ case OPCODE_FLR:
+ case OPCODE_FRC:
+ case OPCODE_KIL:
+ case OPCODE_LG2:
+ case OPCODE_LIT:
ERROR("unknown fpi->Opcode %d\n", fpi->Opcode);
break;
- case FP_OPCODE_LRP:
+ case OPCODE_LRP:
/* TODO: use the special LRP form if possible */
src0 = t_src(rp, fpi->SrcReg[0]);
src1 = t_src(rp, fpi->SrcReg[1]);
@@ -819,31 +819,31 @@ static GLboolean parse_program(struct r300_fragment_program *rp)
src0, src1, temp, flags);
free_temp(rp, temp);
break;
- case FP_OPCODE_MAD:
+ case OPCODE_MAD:
emit_arith(rp, PFS_OP_MAD, t_dst(rp, fpi->DstReg), fpi->DstReg.WriteMask,
t_src(rp, fpi->SrcReg[0]),
t_src(rp, fpi->SrcReg[1]),
t_src(rp, fpi->SrcReg[2]),
flags);
break;
- case FP_OPCODE_MAX:
- case FP_OPCODE_MIN:
+ case OPCODE_MAX:
+ case OPCODE_MIN:
ERROR("unknown fpi->Opcode %d\n", fpi->Opcode);
break;
- case FP_OPCODE_MOV:
- case FP_OPCODE_SWZ:
+ case OPCODE_MOV:
+ case OPCODE_SWZ:
emit_arith(rp, PFS_OP_MAD, t_dst(rp, fpi->DstReg), fpi->DstReg.WriteMask,
t_src(rp, fpi->SrcReg[0]), pfs_one, pfs_zero,
flags);
break;
- case FP_OPCODE_MUL:
+ case OPCODE_MUL:
emit_arith(rp, PFS_OP_MAD, t_dst(rp, fpi->DstReg), fpi->DstReg.WriteMask,
t_src(rp, fpi->SrcReg[0]),
t_src(rp, fpi->SrcReg[1]),
pfs_zero,
flags);
break;
- case FP_OPCODE_POW:
+ case OPCODE_POW:
src0 = t_src(rp, fpi->SrcReg[0]);
src1 = t_src(rp, fpi->SrcReg[1]);
dest = t_dst(rp, fpi->DstReg);
@@ -857,38 +857,38 @@ static GLboolean parse_program(struct r300_fragment_program *rp)
temp, pfs_zero, pfs_zero, 0);
free_temp(rp, temp);
break;
- case FP_OPCODE_RCP:
+ case OPCODE_RCP:
ERROR("unknown fpi->Opcode %d\n", fpi->Opcode);
break;
- case FP_OPCODE_RSQ:
+ case OPCODE_RSQ:
emit_arith(rp, PFS_OP_RSQ, t_dst(rp, fpi->DstReg),
fpi->DstReg.WriteMask,
t_src(rp, fpi->SrcReg[0]), pfs_zero, pfs_zero,
flags | PFS_FLAG_ABS);
break;
- case FP_OPCODE_SCS:
- case FP_OPCODE_SGE:
- case FP_OPCODE_SIN:
- case FP_OPCODE_SLT:
+ case OPCODE_SCS:
+ case OPCODE_SGE:
+ case OPCODE_SIN:
+ case OPCODE_SLT:
ERROR("unknown fpi->Opcode %d\n", fpi->Opcode);
break;
- case FP_OPCODE_SUB:
+ case OPCODE_SUB:
emit_arith(rp, PFS_OP_MAD, t_dst(rp, fpi->DstReg), fpi->DstReg.WriteMask,
t_src(rp, fpi->SrcReg[0]),
pfs_one,
negate(t_src(rp, fpi->SrcReg[1])),
flags);
break;
- case FP_OPCODE_TEX:
+ case OPCODE_TEX:
emit_tex(rp, fpi, R300_FPITX_OP_TEX);
break;
- case FP_OPCODE_TXB:
+ case OPCODE_TXB:
emit_tex(rp, fpi, R300_FPITX_OP_TXB);
break;
- case FP_OPCODE_TXP:
+ case OPCODE_TXP:
emit_tex(rp, fpi, R300_FPITX_OP_TXP);
break;
- case FP_OPCODE_XPD:
+ case OPCODE_XPD:
ERROR("unknown fpi->Opcode %d\n", fpi->Opcode);
break;
default:
@@ -909,7 +909,7 @@ static GLboolean parse_program(struct r300_fragment_program *rp)
static void init_program(struct r300_fragment_program *rp)
{
struct fragment_program *mp = &rp->mesa_program;
- struct fp_instruction *fpi;
+ struct prog_instruction *fpi;
GLuint InputsRead = mp->InputsRead;
GLuint temps_used = 0; /* for rp->temps[] */
int i;
@@ -983,7 +983,7 @@ static void init_program(struct r300_fragment_program *rp)
ERROR("No instructions found in program\n");
return;
}
- for (fpi=mp->Instructions;fpi->Opcode != FP_OPCODE_END; fpi++) {
+ for (fpi=mp->Instructions;fpi->Opcode != OPCODE_END; fpi++) {
for (i=0;i<3;i++) {
if (fpi->SrcReg[i].File == PROGRAM_TEMPORARY) {
if (!(temps_used & (1 << fpi->SrcReg[i].Index))) {
diff --git a/src/mesa/drivers/dri/r300/r300_fragprog.h b/src/mesa/drivers/dri/r300/r300_fragprog.h
index ed318eb6a7..fb9d067f71 100644
--- a/src/mesa/drivers/dri/r300/r300_fragprog.h
+++ b/src/mesa/drivers/dri/r300/r300_fragprog.h
@@ -7,7 +7,7 @@
#include "program.h"
#include "r300_context.h"
-#include "nvfragprog.h"
+#include "program_instruction.h"
/* representation of a register for emit_arith/swizzle */
typedef struct _pfs_reg_t {
diff --git a/src/mesa/drivers/dri/r300/r300_shader.c b/src/mesa/drivers/dri/r300/r300_shader.c
index b8e951d171..a5549947f9 100644
--- a/src/mesa/drivers/dri/r300/r300_shader.c
+++ b/src/mesa/drivers/dri/r300/r300_shader.c
@@ -4,7 +4,7 @@
#include "program.h"
#include "r300_context.h"
-#include "nvvertprog.h"
+#include "program_instruction.h"
#if USE_ARB_F_P == 1
#include "r300_fragprog.h"
#endif
diff --git a/src/mesa/drivers/dri/r300/r300_vertexprog.c b/src/mesa/drivers/dri/r300/r300_vertexprog.c
index 7b8ebe343a..5ebd100ed1 100644
--- a/src/mesa/drivers/dri/r300/r300_vertexprog.c
+++ b/src/mesa/drivers/dri/r300/r300_vertexprog.c
@@ -36,12 +36,12 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "program.h"
#include "r300_context.h"
#include "r300_program.h"
-#include "nvvertprog.h"
+#include "program_instruction.h"
#define SCALAR_FLAG (1<<31)
#define FLAG_MASK (1<<31)
#define OP_MASK (0xf) /* we are unlikely to have more than 15 */
-#define OPN(operator, ip, op) {#operator, VP_OPCODE_##operator, ip, op}
+#define OPN(operator, ip, op) {#operator, OPCODE_##operator, ip, op}
static struct{
char *name;
@@ -186,7 +186,7 @@ void dump_program_params(GLcontext *ctx, struct vertex_program *vp)
void debug_vp(GLcontext *ctx, struct vertex_program *vp)
{
- struct vp_instruction *vpi;
+ struct prog_instruction *vpi;
int i, operand_index;
int operator_index;
@@ -195,7 +195,7 @@ void debug_vp(GLcontext *ctx, struct vertex_program *vp)
vpi=vp->Instructions;
for(;; vpi++){
- if(vpi->Opcode == VP_OPCODE_END)
+ if(vpi->Opcode == OPCODE_END)
break;
for(i=0; i < sizeof(op_names) / sizeof(*op_names); i++){
@@ -315,7 +315,7 @@ static unsigned long t_dst_class(enum register_file file)
}
}
-static unsigned long t_dst_index(struct r300_vertex_program *vp, struct vp_dst_register *dst)
+static unsigned long t_dst_index(struct r300_vertex_program *vp, struct prog_dst_register *dst)
{
if(dst->File == PROGRAM_OUTPUT) {
if (vp->outputs[dst->Index] != -1)
@@ -385,7 +385,7 @@ static void vp_dump_inputs(struct r300_vertex_program *vp, char *caller)
}
-static unsigned long t_src_index(struct r300_vertex_program *vp, struct vp_src_register *src)
+static unsigned long t_src_index(struct r300_vertex_program *vp, struct prog_src_register *src)
{
int i;
int max_reg=-1;
@@ -408,7 +408,7 @@ static unsigned long t_src_index(struct r300_vertex_program *vp, struct vp_src_r
}
}
-static unsigned long t_src(struct r300_vertex_program *vp, struct vp_src_register *src)
+static unsigned long t_src(struct r300_vertex_program *vp, struct prog_src_register *src)
{
return MAKE_VSF_SOURCE(t_src_index(vp, src),
@@ -420,7 +420,7 @@ static unsigned long t_src(struct r300_vertex_program *vp, struct vp_src_registe
src->Negate ? VSF_FLAG_ALL : VSF_FLAG_NONE);
}
-static unsigned long t_src_scalar(struct r300_vertex_program *vp, struct vp_src_register *src)
+static unsigned long t_src_scalar(struct r300_vertex_program *vp, struct prog_src_register *src)
{
return MAKE_VSF_SOURCE(t_src_index(vp, src),
@@ -436,21 +436,21 @@ static unsigned long t_opcode(enum vp_opcode opcode)
{
switch(opcode){
- case VP_OPCODE_DST: return R300_VPI_OUT_OP_DST;
- case VP_OPCODE_EX2: return R300_VPI_OUT_OP_EX2;
- case VP_OPCODE_EXP: return R300_VPI_OUT_OP_EXP;
- case VP_OPCODE_FRC: return R300_VPI_OUT_OP_FRC;
- case VP_OPCODE_LG2: return R300_VPI_OUT_OP_LG2;
- case VP_OPCODE_LOG: return R300_VPI_OUT_OP_LOG;
- case VP_OPCODE_MAX: return R300_VPI_OUT_OP_MAX;
- case VP_OPCODE_MIN: return R300_VPI_OUT_OP_MIN;
- case VP_OPCODE_MUL: return R300_VPI_OUT_OP_MUL;
- case VP_OPCODE_POW: return R300_VPI_OUT_OP_POW;
- case VP_OPCODE_RCP: return R300_VPI_OUT_OP_RCP;
- case VP_OPCODE_RSQ: return R300_VPI_OUT_OP_RSQ;
- case VP_OPCODE_SGE: return R300_VPI_OUT_OP_SGE;
- case VP_OPCODE_SLT: return R300_VPI_OUT_OP_SLT;
- case VP_OPCODE_DP4: return R300_VPI_OUT_OP_DOT;
+ case OPCODE_DST: return R300_VPI_OUT_OP_DST;
+ case OPCODE_EX2: return R300_VPI_OUT_OP_EX2;
+ case OPCODE_EXP: return R300_VPI_OUT_OP_EXP;
+ case OPCODE_FRC: return R300_VPI_OUT_OP_FRC;
+ case OPCODE_LG2: return R300_VPI_OUT_OP_LG2;
+ case OPCODE_LOG: return R300_VPI_OUT_OP_LOG;
+ case OPCODE_MAX: return R300_VPI_OUT_OP_MAX;
+ case OPCODE_MIN: return R300_VPI_OUT_OP_MIN;
+ case OPCODE_MUL: return R300_VPI_OUT_OP_MUL;
+ case OPCODE_POW: return R300_VPI_OUT_OP_POW;
+ case OPCODE_RCP: return R300_VPI_OUT_OP_RCP;
+ case OPCODE_RSQ: return R300_VPI_OUT_OP_RSQ;
+ case OPCODE_SGE: return R300_VPI_OUT_OP_SGE;
+ case OPCODE_SLT: return R300_VPI_OUT_OP_SLT;
+ case OPCODE_DP4: return R300_VPI_OUT_OP_DOT;
default:
fprintf(stderr, "%s: Should not be called with opcode %d!", __FUNCTION__, opcode);
@@ -484,7 +484,7 @@ static unsigned long op_operands(enum vp_opcode opcode)
void translate_vertex_shader(struct r300_vertex_program *vp)
{
struct vertex_program *mesa_vp=(void *)vp;
- struct vp_instruction *vpi;
+ struct prog_instruction *vpi;
int i, cur_reg=0;
VERTEX_SHADER_INSTRUCTION *o_inst;
unsigned long operands;
@@ -495,7 +495,7 @@ void translate_vertex_shader(struct r300_vertex_program *vp)
Smart enough to realize that it doesnt need it? */
int u_temp_i=VSF_MAX_FRAGMENT_TEMPS-1;
#ifdef SRCS_WRITABLE
- struct vp_src_register src[3];
+ struct prog_src_register src[3];
#else
#define src vpi->SrcReg
#endif
@@ -541,7 +541,7 @@ void translate_vertex_shader(struct r300_vertex_program *vp)
vp->outputs[i] = cur_reg++;
o_inst=vp->program.body.i;
- for(vpi=mesa_vp->Instructions; vpi->Opcode != VP_OPCODE_END; vpi++, o_inst++){
+ for(vpi=mesa_vp->Instructions; vpi->Opcode != OPCODE_END; vpi++, o_inst++){
operands=op_operands(vpi->Opcode);
are_srcs_scalar=operands & SCALAR_FLAG;
@@ -599,7 +599,7 @@ void translate_vertex_shader(struct r300_vertex_program *vp)
/* these ops need special handling.
Ops that need temp vars should probably be given reg indexes starting at the end of tmp area. */
switch(vpi->Opcode){
- case VP_OPCODE_MOV://ADD RESULT 1.X Y Z W PARAM 0{} {X Y Z W} PARAM 0{} {ZERO ZERO ZERO ZERO}
+ case OPCODE_MOV://ADD RESULT 1.X Y Z W PARAM 0{} {X Y Z W} PARAM 0{} {ZERO ZERO ZERO ZERO}
#if 1
o_inst->op=MAKE_VSF_OP(R300_VPI_OUT_OP_ADD, t_dst_index(vp, &vpi->DstReg),
t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
@@ -630,7 +630,7 @@ void translate_vertex_shader(struct r300_vertex_program *vp)
goto next;
- case VP_OPCODE_ADD:
+ case OPCODE_ADD:
hw_op=(src[0].File == PROGRAM_TEMPORARY &&
src[1].File == PROGRAM_TEMPORARY) ? R300_VPI_OUT_OP_MAD_2 : R300_VPI_OUT_OP_MAD;
@@ -644,7 +644,7 @@ void translate_vertex_shader(struct r300_vertex_program *vp)
o_inst->src3=t_src(vp, &src[1]);
goto next;
- case VP_OPCODE_MAD:
+ case OPCODE_MAD:
hw_op=(src[0].File == PROGRAM_TEMPORARY &&
src[1].File == PROGRAM_TEMPORARY &&
src[2].File == PROGRAM_TEMPORARY) ? R300_VPI_OUT_OP_MAD_2 : R300_VPI_OUT_OP_MAD;
@@ -656,7 +656,7 @@ void translate_vertex_shader(struct r300_vertex_program *vp)
o_inst->src3=t_src(vp, &src[2]);
goto next;
- case VP_OPCODE_MUL: /* HW mul can take third arg but appears to have some other limitations. */
+ case OPCODE_MUL: /* HW mul can take third arg but appears to have some other limitations. */
hw_op=(src[0].File == PROGRAM_TEMPORARY &&
src[1].File == PROGRAM_TEMPORARY) ? R300_VPI_OUT_OP_MAD_2 : R300_VPI_OUT_OP_MAD;
@@ -671,7 +671,7 @@ void translate_vertex_shader(struct r300_vertex_program *vp)
t_src_class(src[1].File), VSF_FLAG_NONE);
goto next;
- case VP_OPCODE_DP3://DOT RESULT 1.X Y Z W PARAM 0{} {X Y Z ZERO} PARAM 0{} {X Y Z ZERO}
+ case OPCODE_DP3://DOT RESULT 1.X Y Z W PARAM 0{} {X Y Z ZERO} PARAM 0{} {X Y Z ZERO}
o_inst->op=MAKE_VSF_OP(R300_VPI_OUT_OP_DOT, t_dst_index(vp, &vpi->DstReg),
t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
@@ -694,7 +694,7 @@ void translate_vertex_shader(struct r300_vertex_program *vp)
o_inst->src3=0;
goto next;
- case VP_OPCODE_SUB://ADD RESULT 1.X Y Z W TMP 0{} {X Y Z W} PARAM 1{X Y Z W } {X Y Z W} neg Xneg Yneg Zneg W
+ case OPCODE_SUB://ADD RESULT 1.X Y Z W TMP 0{} {X Y Z W} PARAM 1{X Y Z W } {X Y Z W} neg Xneg Yneg Zneg W
#if 1
hw_op=(src[0].File == PROGRAM_TEMPORARY &&
src[1].File == PROGRAM_TEMPORARY) ? R300_VPI_OUT_OP_MAD_2 : R300_VPI_OUT_OP_MAD;
@@ -729,7 +729,7 @@ void translate_vertex_shader(struct r300_vertex_program *vp)
#endif
goto next;
- case VP_OPCODE_ABS://MAX RESULT 1.X Y Z W PARAM 0{} {X Y Z W} PARAM 0{X Y Z W } {X Y Z W} neg Xneg Yneg Zneg W
+ case OPCODE_ABS://MAX RESULT 1.X Y Z W PARAM 0{} {X Y Z W} PARAM 0{X Y Z W } {X Y Z W} neg Xneg Yneg Zneg W
o_inst->op=MAKE_VSF_OP(R300_VPI_OUT_OP_MAX, t_dst_index(vp, &vpi->DstReg),
t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
@@ -744,7 +744,7 @@ void translate_vertex_shader(struct r300_vertex_program *vp)
o_inst->src3=0;
goto next;
- case VP_OPCODE_FLR:
+ case OPCODE_FLR:
/* FRC TMP 0.X Y Z W PARAM 0{} {X Y Z W}
ADD RESULT 1.X Y Z W PARAM 0{} {X Y Z W} TMP 0{X Y Z W } {X Y Z W} neg Xneg Yneg Zneg W */
@@ -773,7 +773,7 @@ void translate_vertex_shader(struct r300_vertex_program *vp)
u_temp_i--;
goto next;
- case VP_OPCODE_LG2:// LG2 RESULT 1.X Y Z W PARAM 0{} {X X X X}
+ case OPCODE_LG2:// LG2 RESULT 1.X Y Z W PARAM 0{} {X X X X}
o_inst->op=MAKE_VSF_OP(R300_VPI_OUT_OP_LG2, t_dst_index(vp, &vpi->DstReg),
t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
@@ -788,7 +788,7 @@ void translate_vertex_shader(struct r300_vertex_program *vp)
o_inst->src3=0;
goto next;
- case VP_OPCODE_LIT://LIT TMP 1.Y Z TMP 1{} {X W Z Y} TMP 1{} {Y W Z X} TMP 1{} {Y X Z W}
+ case OPCODE_LIT://LIT TMP 1.Y Z TMP 1{} {X W Z Y} TMP 1{} {Y W Z X} TMP 1{} {Y X Z W}
o_inst->op=MAKE_VSF_OP(R300_VPI_OUT_OP_LIT, t_dst_index(vp, &vpi->DstReg),
t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
/* NOTE: Users swizzling might not work. */
@@ -815,7 +815,7 @@ void translate_vertex_shader(struct r300_vertex_program *vp)
src[0].Negate ? VSF_FLAG_ALL : VSF_FLAG_NONE);
goto next;
- case VP_OPCODE_DPH://DOT RESULT 1.X Y Z W PARAM 0{} {X Y Z ONE} PARAM 0{} {X Y Z W}
+ case OPCODE_DPH://DOT RESULT 1.X Y Z W PARAM 0{} {X Y Z ONE} PARAM 0{} {X Y Z W}
o_inst->op=MAKE_VSF_OP(R300_VPI_OUT_OP_DOT, t_dst_index(vp, &vpi->DstReg),
t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
@@ -830,7 +830,7 @@ void translate_vertex_shader(struct r300_vertex_program *vp)
o_inst->src3=0;
goto next;
- case VP_OPCODE_XPD:
+ case OPCODE_XPD:
/* mul r0, r1.yzxw, r2.zxyw
mad r0, -r2.yzxw, r1.zxyw, r0
NOTE: might need MAD_2
@@ -892,15 +892,15 @@ void translate_vertex_shader(struct r300_vertex_program *vp)
goto next;
- case VP_OPCODE_ARL:
- case VP_OPCODE_SWZ:
- case VP_OPCODE_RCC:
- case VP_OPCODE_PRINT:
+ case OPCODE_ARL:
+ case OPCODE_SWZ:
+ case OPCODE_RCC:
+ case OPCODE_PRINT:
//vp->num_temporaries++;
fprintf(stderr, "Dont know how to handle op %d yet\n", vpi->Opcode);
exit(-1);
break;
- case VP_OPCODE_END:
+ case OPCODE_END:
break;
default:
break;
diff --git a/src/mesa/drivers/glide/fxtris.c b/src/mesa/drivers/glide/fxtris.c
index 180637565c..0b9b3be582 100644
--- a/src/mesa/drivers/glide/fxtris.c
+++ b/src/mesa/drivers/glide/fxtris.c
@@ -35,8 +35,6 @@
#include "mtypes.h"
#include "macros.h"
#include "colormac.h"
-#include "nvfragprog.h"
-
#include "swrast/swrast.h"
#include "swrast_setup/swrast_setup.h"
#include "tnl/t_context.h"
diff --git a/src/mesa/main/mtypes.h b/src/mesa/main/mtypes.h
index 3271cb0772..2d08b11cc6 100644
--- a/src/mesa/main/mtypes.h
+++ b/src/mesa/main/mtypes.h
@@ -1744,8 +1744,7 @@ enum register_file
/** Vertex and fragment instructions */
-struct vp_instruction;
-struct fp_instruction;
+struct prog_instruction;
struct atifs_instruction;
struct atifs_setupinst;
struct program_parameter_list;
@@ -1781,7 +1780,7 @@ struct program
struct vertex_program
{
struct program Base; /* base class */
- struct vp_instruction *Instructions; /* Compiled instructions */
+ struct prog_instruction *Instructions; /* Compiled instructions */
GLboolean IsNVProgram; /* GL_NV_vertex_program ? */
GLboolean IsPositionInvariant; /* GL_NV_vertex_program1_1 */
GLbitfield InputsRead; /* Bitmask of which input regs are read */
@@ -1795,7 +1794,7 @@ struct vertex_program
struct fragment_program
{
struct program Base; /**< base class */
- struct fp_instruction *Instructions; /**< Compiled instructions */
+ struct prog_instruction *Instructions; /**< Compiled instructions */
GLbitfield InputsRead; /**< Bitmask of which input regs are read */
GLbitfield OutputsWritten; /**< Bitmask of which output regs are written to */
GLbitfield TexturesUsed[MAX_TEXTURE_IMAGE_UNITS]; /**< TEXTURE_x_INDEX bitmask */
diff --git a/src/mesa/main/texenvprogram.c b/src/mesa/main/texenvprogram.c
index 6197c15684..b4980747eb 100644
--- a/src/mesa/main/texenvprogram.c
+++ b/src/mesa/main/texenvprogram.c
@@ -31,7 +31,7 @@
#include "texenvprogram.h"
#include "shader/program.h"
-#include "shader/nvfragprog.h"
+#include "shader/program_instruction.h"
#include "shader/arbfragparse.h"
@@ -446,7 +446,7 @@ static struct ureg register_input( struct texenv_fragment_program *p, GLuint inp
}
-static void emit_arg( struct fp_src_register *reg,
+static void emit_arg( struct prog_src_register *reg,
struct ureg ureg )
{
reg->File = ureg.file;
@@ -457,7 +457,7 @@ static void emit_arg( struct fp_src_register *reg,
reg->NegateAbs = ureg.negateabs;
}
-static void emit_dst( struct fp_dst_register *dst,
+static void emit_dst( struct prog_dst_register *dst,
struct ureg ureg, GLuint mask )
{
dst->File = ureg.file;
@@ -467,7 +467,7 @@ static void emit_dst( struct fp_dst_register *dst,
dst->CondSwizzle = 0;
}
-static struct fp_instruction *
+static struct prog_instruction *
emit_op(struct texenv_fragment_program *p,
GLuint op,
struct ureg dest,
@@ -478,7 +478,7 @@ emit_op(struct texenv_fragment_program *p,
struct ureg src2 )
{
GLuint nr = p->program->Base.NumInstructions++;
- struct fp_instruction *inst = &p->program->Instructions[nr];
+ struct prog_instruction *inst = &p->program->Instructions[nr];
_mesa_memset(inst, 0, sizeof(*inst));
inst->Opcode = op;
@@ -537,14 +537,14 @@ static struct ureg emit_texld( struct texenv_fragment_program *p,
GLuint tex_idx,
struct ureg coord )
{
- struct fp_instruction *inst = emit_op( p, op,
+ struct prog_instruction *inst = emit_op( p, op,
dest, destmask,
0, /* don't saturate? */
coord, /* arg 0? */
undef,
undef);
- inst->TexSrcIdx = tex_idx;
+ inst->TexSrcTarget = tex_idx;
inst->TexSrcUnit = tex_unit;
p->program->NumTexInstructions++;
@@ -671,7 +671,7 @@ static struct ureg emit_combine_source( struct texenv_fragment_program *p,
*/
arg = get_temp( p );
one = get_one( p );
- return emit_arith( p, FP_OPCODE_SUB, arg, mask, 0, one, src, undef);
+ return emit_arith( p, OPCODE_SUB, arg, mask, 0, one, src, undef);
case OPR_SRC_ALPHA:
if (mask == WRITEMASK_W)
@@ -684,7 +684,7 @@ static struct ureg emit_combine_source( struct texenv_fragment_program *p,
*/
arg = get_temp(p);
one = get_one(p);
- return emit_arith(p, FP_OPCODE_SUB, arg, mask, 0,
+ return emit_arith(p, OPCODE_SUB, arg, mask, 0,
one, swizzle1(src, W), undef);
case OPR_ZERO:
return get_zero(p);
@@ -752,28 +752,28 @@ static struct ureg emit_combine( struct texenv_fragment_program *p,
if (mask == WRITEMASK_XYZW && !saturate)
return src[0];
else
- return emit_arith( p, FP_OPCODE_MOV, dest, mask, saturate, src[0], undef, undef );
+ return emit_arith( p, OPCODE_MOV, dest, mask, saturate, src[0], undef, undef );
case MODE_MODULATE:
- return emit_arith( p, FP_OPCODE_MUL, dest, mask, saturate,
+ return emit_arith( p, OPCODE_MUL, dest, mask, saturate,
src[0], src[1], undef );
case MODE_ADD:
- return emit_arith( p, FP_OPCODE_ADD, dest, mask, saturate,
+ return emit_arith( p, OPCODE_ADD, dest, mask, saturate,
src[0], src[1], undef );
case MODE_ADD_SIGNED:
/* tmp = arg0 + arg1
* result = tmp - .5
*/
half = get_half(p);
- emit_arith( p, FP_OPCODE_ADD, tmp, mask, 0, src[0], src[1], undef );
- emit_arith( p, FP_OPCODE_SUB, dest, mask, saturate, tmp, half, undef );
+ emit_arith( p, OPCODE_ADD, tmp, mask, 0, src[0], src[1], undef );
+ emit_arith( p, OPCODE_SUB, dest, mask, saturate, tmp, half, undef );
return dest;
case MODE_INTERPOLATE:
/* Arg0 * (Arg2) + Arg1 * (1-Arg2) -- note arguments are reordered:
*/
- return emit_arith( p, FP_OPCODE_LRP, dest, mask, saturate, src[2], src[0], src[1] );
+ return emit_arith( p, OPCODE_LRP, dest, mask, saturate, src[2], src[0], src[1] );
case MODE_SUBTRACT:
- return emit_arith( p, FP_OPCODE_SUB, dest, mask, saturate, src[0], src[1], undef );
+ return emit_arith( p, OPCODE_SUB, dest, mask, saturate, src[0], src[1], undef );
case MODE_DOT3_RGBA:
case MODE_DOT3_RGBA_EXT:
@@ -789,32 +789,32 @@ static struct ureg emit_combine( struct texenv_fragment_program *p,
*
* dst = tmp0 dot3 tmp1
*/
- emit_arith( p, FP_OPCODE_MAD, tmp0, WRITEMASK_XYZW, 0,
+ emit_arith( p, OPCODE_MAD, tmp0, WRITEMASK_XYZW, 0,
two, src[0], neg1);
if (_mesa_memcmp(&src[0], &src[1], sizeof(struct ureg)) == 0)
tmp1 = tmp0;
else
- emit_arith( p, FP_OPCODE_MAD, tmp1, WRITEMASK_XYZW, 0,
+ emit_arith( p, OPCODE_MAD, tmp1, WRITEMASK_XYZW, 0,
two, src[1], neg1);
- emit_arith( p, FP_OPCODE_DP3, dest, mask, saturate, tmp0, tmp1, undef);
+ emit_arith( p, OPCODE_DP3, dest, mask, saturate, tmp0, tmp1, undef);
return dest;
}
case MODE_MODULATE_ADD_ATI:
/* Arg0 * Arg2 + Arg1 */
- return emit_arith( p, FP_OPCODE_MAD, dest, mask, saturate,
+ return emit_arith( p, OPCODE_MAD, dest, mask, saturate,
src[0], src[2], src[1] );
case MODE_MODULATE_SIGNED_ADD_ATI: {
/* Arg0 * Arg2 + Arg1 - 0.5 */
struct ureg tmp0 = get_temp(p);
half = get_half(p);
- emit_arith( p, FP_OPCODE_MAD, tmp0, mask, 0, src[0], src[2], src[1] );
- emit_arith( p, FP_OPCODE_SUB, dest, mask, saturate, tmp0, half, undef );
+ emit_arith( p, OPCODE_MAD, tmp0, mask, 0, src[0], src[2], src[1] );
+ emit_arith( p, OPCODE_SUB, dest, mask, saturate, tmp0, half, undef );
return dest;
}
case MODE_MODULATE_SUBTRACT_ATI:
/* Arg0 * Arg2 - Arg1 */
- emit_arith( p, FP_OPCODE_MAD, dest, mask, 0, src[0], src[2], negate(src[1]) );
+ emit_arith( p, OPCODE_MAD, dest, mask, 0, src[0], src[2], negate(src[1]) );
return dest;
default:
return src[0];
@@ -907,7 +907,7 @@ static struct ureg emit_texenv( struct texenv_fragment_program *p, int unit )
1<<rgb_shift,
1<<alpha_shift);
}
- return emit_arith( p, FP_OPCODE_MUL, dest, WRITEMASK_XYZW,
+ return emit_arith( p, OPCODE_MUL, dest, WRITEMASK_XYZW,
saturate, out, shift, undef );
}
else
@@ -928,7 +928,7 @@ static void load_texture( struct texenv_fragment_program *p, GLuint unit )
/* TODO: Use D0_MASK_XY where possible.
*/
- p->src_texture[unit] = emit_texld( p, FP_OPCODE_TXP,
+ p->src_texture[unit] = emit_texld( p, OPCODE_TXP,
tmp, WRITEMASK_XYZW,
unit, dim, texcoord );
}
@@ -986,7 +986,7 @@ static void create_new_program(struct state_key *key, GLcontext *ctx,
p.state = key;
p.program = program;
- p.program->Instructions = MALLOC(sizeof(struct fp_instruction) * 100);
+ p.program->Instructions = MALLOC(sizeof(struct prog_instruction) * 100);
p.program->Base.NumInstructions = 0;
p.program->Base.Target = GL_FRAGMENT_PROGRAM_ARB;
p.program->NumTexIndirections = 1; /* correct? */
@@ -1036,19 +1036,19 @@ static void create_new_program(struct state_key *key, GLcontext *ctx,
/* Emit specular add.
*/
struct ureg s = register_input(&p, FRAG_ATTRIB_COL1);
- emit_arith( &p, FP_OPCODE_ADD, out, WRITEMASK_XYZ, 0, cf, s, undef );
- emit_arith( &p, FP_OPCODE_MOV, out, WRITEMASK_W, 0, cf, undef, undef );
+ emit_arith( &p, OPCODE_ADD, out, WRITEMASK_XYZ, 0, cf, s, undef );
+ emit_arith( &p, OPCODE_MOV, out, WRITEMASK_W, 0, cf, undef, undef );
}
else if (_mesa_memcmp(&cf, &out, sizeof(cf)) != 0) {
/* Will wind up in here if no texture enabled or a couple of
* other scenarios (GL_REPLACE for instance).
*/
- emit_arith( &p, FP_OPCODE_MOV, out, WRITEMASK_XYZW, 0, cf, undef, undef );
+ emit_arith( &p, OPCODE_MOV, out, WRITEMASK_XYZW, 0, cf, undef, undef );
}
/* Finish up:
*/
- emit_arith( &p, FP_OPCODE_END, undef, WRITEMASK_XYZW, 0, undef, undef, undef);
+ emit_arith( &p, OPCODE_END, undef, WRITEMASK_XYZW, 0, undef, undef, undef);
if (key->fog_enabled) {
/* Pull fog mode from GLcontext, the value in the state key is
diff --git a/src/mesa/shader/arbfragparse.c b/src/mesa/shader/arbfragparse.c
index 75c7b35e40..a4470cbcb1 100644
--- a/src/mesa/shader/arbfragparse.c
+++ b/src/mesa/shader/arbfragparse.c
@@ -40,7 +40,7 @@
#include "arbfragparse.h"
void
-_mesa_debug_fp_inst(GLint num, struct fp_instruction *fp)
+_mesa_debug_fp_inst(GLint num, struct prog_instruction *fp)
{
GLint a;
@@ -190,7 +190,7 @@ _mesa_parse_arb_fragment_program(GLcontext * ctx, GLenum target,
{
GLuint i;
struct arb_program ap;
- struct fp_instruction *newInstructions;
+ struct prog_instruction *newInstructions;
(void) target;
/* set the program target before parsing */
@@ -205,14 +205,14 @@ _mesa_parse_arb_fragment_program(GLcontext * ctx, GLenum target,
* fragment_program struct.
*/
/* copy instruction buffer */
- newInstructions = (struct fp_instruction *)
- _mesa_malloc(ap.Base.NumInstructions * sizeof(struct fp_instruction));
+ newInstructions = (struct prog_instruction *)
+ _mesa_malloc(ap.Base.NumInstructions * sizeof(struct prog_instruction));
if (!newInstructions) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramStringARB");
return;
}
_mesa_memcpy(newInstructions, ap.FPInstructions,
- ap.Base.NumInstructions * sizeof(struct fp_instruction));
+ ap.Base.NumInstructions * sizeof(struct prog_instruction));
if (program->Instructions)
_mesa_free(program->Instructions);
program->Instructions = newInstructions;
diff --git a/src/mesa/shader/arbfragparse.h b/src/mesa/shader/arbfragparse.h
index 0d3e69fa8e..09a01d944d 100644
--- a/src/mesa/shader/arbfragparse.h
+++ b/src/mesa/shader/arbfragparse.h
@@ -33,7 +33,7 @@ _mesa_parse_arb_fragment_program(GLcontext * ctx, GLenum target,
struct fragment_program *program);
extern void
-_mesa_debug_fp_inst(GLint num, struct fp_instruction *fp);
+_mesa_debug_fp_inst(GLint num, struct prog_instruction *fp);
#endif
diff --git a/src/mesa/shader/arbprogparse.c b/src/mesa/shader/arbprogparse.c
index 7b56b078a1..377b9bb862 100644
--- a/src/mesa/shader/arbprogparse.c
+++ b/src/mesa/shader/arbprogparse.c
@@ -37,8 +37,7 @@
#include "imports.h"
#include "macros.h"
#include "program.h"
-#include "nvvertprog.h"
-#include "nvfragprog.h"
+#include "program_instruction.h"
#include "arbprogparse.h"
#include "grammar_mesa.h"
#include "program.h"
@@ -2573,7 +2572,7 @@ static GLuint
parse_fp_vector_src_reg(GLcontext * ctx, GLubyte ** inst,
struct var_cache **vc_head,
struct arb_program *program,
- struct fp_src_register *reg)
+ struct prog_src_register *reg)
{
enum register_file file;
GLint index;
@@ -2604,7 +2603,7 @@ parse_fp_vector_src_reg(GLcontext * ctx, GLubyte ** inst,
static GLuint
parse_fp_dst_reg(GLcontext * ctx, GLubyte ** inst,
struct var_cache **vc_head, struct arb_program *Program,
- struct fp_dst_register *reg )
+ struct prog_dst_register *reg )
{
GLint mask;
GLuint idx;
@@ -2629,7 +2628,7 @@ static GLuint
parse_fp_scalar_src_reg (GLcontext * ctx, GLubyte ** inst,
struct var_cache **vc_head,
struct arb_program *Program,
- struct fp_src_register *reg )
+ struct prog_src_register *reg )
{
enum register_file File;
GLint Index;
@@ -2665,14 +2664,14 @@ parse_fp_scalar_src_reg (GLcontext * ctx, GLubyte ** inst,
static GLuint
parse_fp_instruction (GLcontext * ctx, GLubyte ** inst,
struct var_cache **vc_head, struct arb_program *Program,
- struct fp_instruction *fp)
+ struct prog_instruction *fp)
{
GLint a;
GLuint texcoord;
GLubyte instClass, type, code;
GLboolean rel;
- _mesa_init_fp_instruction(fp);
+ _mesa_init_instruction(fp);
/* Record the position in the program string for debugging */
fp->StringPos = Program->Position;
@@ -2704,31 +2703,31 @@ parse_fp_instruction (GLcontext * ctx, GLubyte ** inst,
case OP_ABS_SAT:
fp->Saturate = 1;
case OP_ABS:
- fp->Opcode = FP_OPCODE_ABS;
+ fp->Opcode = OPCODE_ABS;
break;
case OP_FLR_SAT:
fp->Saturate = 1;
case OP_FLR:
- fp->Opcode = FP_OPCODE_FLR;
+ fp->Opcode = OPCODE_FLR;
break;
case OP_FRC_SAT:
fp->Saturate = 1;
case OP_FRC:
- fp->Opcode = FP_OPCODE_FRC;
+ fp->Opcode = OPCODE_FRC;
break;
case OP_LIT_SAT:
fp->Saturate = 1;
case OP_LIT:
- fp->Opcode = FP_OPCODE_LIT;
+ fp->Opcode = OPCODE_LIT;
break;
case OP_MOV_SAT:
fp->Saturate = 1;
case OP_MOV:
- fp->Opcode = FP_OPCODE_MOV;
+ fp->Opcode = OPCODE_MOV;
break;
}
@@ -2744,44 +2743,44 @@ parse_fp_instruction (GLcontext * ctx, GLubyte ** inst,
case OP_COS_SAT:
fp->Saturate = 1;
case OP_COS:
- fp->Opcode = FP_OPCODE_COS;
+ fp->Opcode = OPCODE_COS;
break;
case OP_EX2_SAT:
fp->Saturate = 1;
case OP_EX2:
- fp->Opcode = FP_OPCODE_EX2;
+ fp->Opcode = OPCODE_EX2;
break;
case OP_LG2_SAT:
fp->Saturate = 1;
case OP_LG2:
- fp->Opcode = FP_OPCODE_LG2;
+ fp->Opcode = OPCODE_LG2;
break;
case OP_RCP_SAT:
fp->Saturate = 1;
case OP_RCP:
- fp->Opcode = FP_OPCODE_RCP;
+ fp->Opcode = OPCODE_RCP;
break;
case OP_RSQ_SAT:
fp->Saturate = 1;
case OP_RSQ:
- fp->Opcode = FP_OPCODE_RSQ;
+ fp->Opcode = OPCODE_RSQ;
break;
case OP_SIN_SAT:
fp->Saturate = 1;
case OP_SIN:
- fp->Opcode = FP_OPCODE_SIN;
+ fp->Opcode = OPCODE_SIN;
break;
case OP_SCS_SAT:
fp->Saturate = 1;
case OP_SCS:
- fp->Opcode = FP_OPCODE_SCS;
+ fp->Opcode = OPCODE_SCS;
break;
}
@@ -2797,7 +2796,7 @@ parse_fp_instruction (GLcontext * ctx, GLubyte ** inst,
case OP_POW_SAT:
fp->Saturate = 1;
case OP_POW:
- fp->Opcode = FP_OPCODE_POW;
+ fp->Opcode = OPCODE_POW;
break;
}
@@ -2816,73 +2815,73 @@ parse_fp_instruction (GLcontext * ctx, GLubyte ** inst,
case OP_ADD_SAT:
fp->Saturate = 1;
case OP_ADD:
- fp->Opcode = FP_OPCODE_ADD;
+ fp->Opcode = OPCODE_ADD;
break;
case OP_DP3_SAT:
fp->Saturate = 1;
case OP_DP3:
- fp->Opcode = FP_OPCODE_DP3;
+ fp->Opcode = OPCODE_DP3;
break;
case OP_DP4_SAT:
fp->Saturate = 1;
case OP_DP4:
- fp->Opcode = FP_OPCODE_DP4;
+ fp->Opcode = OPCODE_DP4;
break;
case OP_DPH_SAT:
fp->Saturate = 1;
case OP_DPH:
- fp->Opcode = FP_OPCODE_DPH;
+ fp->Opcode = OPCODE_DPH;
break;
case OP_DST_SAT:
fp->Saturate = 1;
case OP_DST:
- fp->Opcode = FP_OPCODE_DST;
+ fp->Opcode = OPCODE_DST;
break;
case OP_MAX_SAT:
fp->Saturate = 1;
case OP_MAX:
- fp->Opcode = FP_OPCODE_MAX;
+ fp->Opcode = OPCODE_MAX;
break;
case OP_MIN_SAT:
fp->Saturate = 1;
case OP_MIN:
- fp->Opcode = FP_OPCODE_MIN;
+ fp->Opcode = OPCODE_MIN;
break;
case OP_MUL_SAT:
fp->Saturate = 1;
case OP_MUL:
- fp->Opcode = FP_OPCODE_MUL;
+ fp->Opcode = OPCODE_MUL;
break;
case OP_SGE_SAT:
fp->Saturate = 1;
case OP_SGE:
- fp->Opcode = FP_OPCODE_SGE;
+ fp->Opcode = OPCODE_SGE;
break;
case OP_SLT_SAT:
fp->Saturate = 1;
case OP_SLT:
- fp->Opcode = FP_OPCODE_SLT;
+ fp->Opcode = OPCODE_SLT;
break;
case OP_SUB_SAT:
fp->Saturate = 1;
case OP_SUB:
- fp->Opcode = FP_OPCODE_SUB;
+ fp->Opcode = OPCODE_SUB;
break;
case OP_XPD_SAT:
fp->Saturate = 1;
case OP_XPD:
- fp->Opcode = FP_OPCODE_XPD;
+ fp->Opcode = OPCODE_XPD;
break;
}
@@ -2899,19 +2898,19 @@ parse_fp_instruction (GLcontext * ctx, GLubyte ** inst,
case OP_CMP_SAT:
fp->Saturate = 1;
case OP_CMP:
- fp->Opcode = FP_OPCODE_CMP;
+ fp->Opcode = OPCODE_CMP;
break;
case OP_LRP_SAT:
fp->Saturate = 1;
case OP_LRP:
- fp->Opcode = FP_OPCODE_LRP;
+ fp->Opcode = OPCODE_LRP;
break;
case OP_MAD_SAT:
fp->Saturate = 1;
case OP_MAD:
- fp->Opcode = FP_OPCODE_MAD;
+ fp->Opcode = OPCODE_MAD;
break;
}
@@ -2929,7 +2928,7 @@ parse_fp_instruction (GLcontext * ctx, GLubyte ** inst,
case OP_SWZ_SAT:
fp->Saturate = 1;
case OP_SWZ:
- fp->Opcode = FP_OPCODE_SWZ;
+ fp->Opcode = OPCODE_SWZ;
break;
}
if (parse_fp_dst_reg (ctx, inst, vc_head, Program, &fp->DstReg))
@@ -2959,19 +2958,19 @@ parse_fp_instruction (GLcontext * ctx, GLubyte ** inst,
case OP_TEX_SAT:
fp->Saturate = 1;
case OP_TEX:
- fp->Opcode = FP_OPCODE_TEX;
+ fp->Opcode = OPCODE_TEX;
break;
case OP_TXP_SAT:
fp->Saturate = 1;
case OP_TXP:
- fp->Opcode = FP_OPCODE_TXP;
+ fp->Opcode = OPCODE_TXP;
break;
case OP_TXB_SAT:
fp->Saturate = 1;
case OP_TXB:
- fp->Opcode = FP_OPCODE_TXB;
+ fp->Opcode = OPCODE_TXB;
break;
}
@@ -2989,19 +2988,19 @@ parse_fp_instruction (GLcontext * ctx, GLubyte ** inst,
/* texTarget */
switch (*(*inst)++) {
case TEXTARGET_1D:
- fp->TexSrcIdx = TEXTURE_1D_INDEX;
+ fp->TexSrcTarget = TEXTURE_1D_INDEX;
break;
case TEXTARGET_2D:
- fp->TexSrcIdx = TEXTURE_2D_INDEX;
+ fp->TexSrcTarget = TEXTURE_2D_INDEX;
break;
case TEXTARGET_3D:
- fp->TexSrcIdx = TEXTURE_3D_INDEX;
+ fp->TexSrcTarget = TEXTURE_3D_INDEX;
break;
case TEXTARGET_RECT:
- fp->TexSrcIdx = TEXTURE_RECT_INDEX;
+ fp->TexSrcTarget = TEXTURE_RECT_INDEX;
break;
case TEXTARGET_CUBE:
- fp->TexSrcIdx = TEXTURE_CUBE_INDEX;
+ fp->TexSrcTarget = TEXTURE_CUBE_INDEX;
break;
case TEXTARGET_SHADOW1D:
case TEXTARGET_SHADOW2D:
@@ -3009,14 +3008,14 @@ parse_fp_instruction (GLcontext * ctx, GLubyte ** inst,
/* TODO ARB_fragment_program_shadow code */
break;
}
- Program->TexturesUsed[texcoord] |= (1<<fp->TexSrcIdx);
+ Program->TexturesUsed[texcoord] |= (1<<fp->TexSrcTarget);
break;
case OP_TEX_KIL:
Program->UsesKill = 1;
if (parse_fp_vector_src_reg(ctx, inst, vc_head, Program, &fp->SrcReg[0]))
return 1;
- fp->Opcode = FP_OPCODE_KIL;
+ fp->Opcode = OPCODE_KIL;
break;
}
@@ -3026,7 +3025,7 @@ parse_fp_instruction (GLcontext * ctx, GLubyte ** inst,
static GLuint
parse_vp_dst_reg(GLcontext * ctx, GLubyte ** inst,
struct var_cache **vc_head, struct arb_program *Program,
- struct vp_dst_register *reg )
+ struct prog_dst_register *reg )
{
GLint mask;
GLuint idx;
@@ -3053,7 +3052,7 @@ static GLuint
parse_vp_address_reg (GLcontext * ctx, GLubyte ** inst,
struct var_cache **vc_head,
struct arb_program *Program,
- struct vp_dst_register *reg)
+ struct prog_dst_register *reg)
{
GLint idx;
@@ -3078,7 +3077,7 @@ static GLuint
parse_vp_vector_src_reg(GLcontext * ctx, GLubyte ** inst,
struct var_cache **vc_head,
struct arb_program *program,
- struct vp_src_register *reg )
+ struct prog_src_register *reg )
{
enum register_file file;
GLint index;
@@ -3100,7 +3099,7 @@ parse_vp_vector_src_reg(GLcontext * ctx, GLubyte ** inst,
reg->Index = index;
reg->Swizzle = MAKE_SWIZZLE4(swizzle[0], swizzle[1],
swizzle[2], swizzle[3]);
- reg->Negate = negateMask;
+ reg->NegateBase = negateMask;
reg->RelAddr = isRelOffset;
return 0;
}
@@ -3110,7 +3109,7 @@ static GLuint
parse_vp_scalar_src_reg (GLcontext * ctx, GLubyte ** inst,
struct var_cache **vc_head,
struct arb_program *Program,
- struct vp_src_register *reg )
+ struct prog_src_register *reg )
{
enum register_file File;
GLint Index;
@@ -3131,7 +3130,7 @@ parse_vp_scalar_src_reg (GLcontext * ctx, GLubyte ** inst,
reg->File = File;
reg->Index = Index;
reg->Swizzle = (Swizzle[0] << 0);
- reg->Negate = Negate;
+ reg->NegateBase = Negate;
reg->RelAddr = IsRelOffset;
return 0;
}
@@ -3144,7 +3143,7 @@ parse_vp_scalar_src_reg (GLcontext * ctx, GLubyte ** inst,
static GLuint
parse_vp_instruction (GLcontext * ctx, GLubyte ** inst,
struct var_cache **vc_head, struct arb_program *Program,
- struct vp_instruction *vp)
+ struct prog_instruction *vp)
{
GLint a;
GLubyte type, code;
@@ -3155,14 +3154,14 @@ parse_vp_instruction (GLcontext * ctx, GLubyte ** inst,
/* The actual opcode name */
code = *(*inst)++;
- _mesa_init_vp_instruction(vp);
+ _mesa_init_instruction(vp);
/* Record the position in the program string for debugging */
vp->StringPos = Program->Position;
switch (type) {
/* XXX: */
case OP_ALU_ARL:
- vp->Opcode = VP_OPCODE_ARL;
+ vp->Opcode = OPCODE_ARL;
/* Remember to set SrcReg.RelAddr; */
@@ -3181,19 +3180,19 @@ parse_vp_instruction (GLcontext * ctx, GLubyte ** inst,
case OP_ALU_VECTOR:
switch (code) {
case OP_ABS:
- vp->Opcode = VP_OPCODE_ABS;
+ vp->Opcode = OPCODE_ABS;
break;
case OP_FLR:
- vp->Opcode = VP_OPCODE_FLR;
+ vp->Opcode = OPCODE_FLR;
break;
case OP_FRC:
- vp->Opcode = VP_OPCODE_FRC;
+ vp->Opcode = OPCODE_FRC;
break;
case OP_LIT:
- vp->Opcode = VP_OPCODE_LIT;
+ vp->Opcode = OPCODE_LIT;
break;
case OP_MOV:
- vp->Opcode = VP_OPCODE_MOV;
+ vp->Opcode = OPCODE_MOV;
break;
}
@@ -3207,22 +3206,22 @@ parse_vp_instruction (GLcontext * ctx, GLubyte ** inst,
case OP_ALU_SCALAR:
switch (code) {
case OP_EX2:
- vp->Opcode = VP_OPCODE_EX2;
+ vp->Opcode = OPCODE_EX2;
break;
case OP_EXP:
- vp->Opcode = VP_OPCODE_EXP;
+ vp->Opcode = OPCODE_EXP;
break;
case OP_LG2:
- vp->Opcode = VP_OPCODE_LG2;
+ vp->Opcode = OPCODE_LG2;
break;
case OP_LOG:
- vp->Opcode = VP_OPCODE_LOG;
+ vp->Opcode = OPCODE_LOG;
break;
case OP_RCP:
- vp->Opcode = VP_OPCODE_RCP;
+ vp->Opcode = OPCODE_RCP;
break;
case OP_RSQ:
- vp->Opcode = VP_OPCODE_RSQ;
+ vp->Opcode = OPCODE_RSQ;
break;
}
if (parse_vp_dst_reg(ctx, inst, vc_head, Program, &vp->DstReg))
@@ -3235,7 +3234,7 @@ parse_vp_instruction (GLcontext * ctx, GLubyte ** inst,
case OP_ALU_BINSC:
switch (code) {
case OP_POW:
- vp->Opcode = VP_OPCODE_POW;
+ vp->Opcode = OPCODE_POW;
break;
}
if (parse_vp_dst_reg(ctx, inst, vc_head, Program, &vp->DstReg))
@@ -3250,40 +3249,40 @@ parse_vp_instruction (GLcontext * ctx, GLubyte ** inst,
case OP_ALU_BIN:
switch (code) {
case OP_ADD:
- vp->Opcode = VP_OPCODE_ADD;
+ vp->Opcode = OPCODE_ADD;
break;
case OP_DP3:
- vp->Opcode = VP_OPCODE_DP3;
+ vp->Opcode = OPCODE_DP3;
break;
case OP_DP4:
- vp->Opcode = VP_OPCODE_DP4;
+ vp->Opcode = OPCODE_DP4;
break;
case OP_DPH:
- vp->Opcode = VP_OPCODE_DPH;
+ vp->Opcode = OPCODE_DPH;
break;
case OP_DST:
- vp->Opcode = VP_OPCODE_DST;
+ vp->Opcode = OPCODE_DST;
break;
case OP_MAX:
- vp->Opcode = VP_OPCODE_MAX;
+ vp->Opcode = OPCODE_MAX;
break;
case OP_MIN:
- vp->Opcode = VP_OPCODE_MIN;
+ vp->Opcode = OPCODE_MIN;
break;
case OP_MUL:
- vp->Opcode = VP_OPCODE_MUL;
+ vp->Opcode = OPCODE_MUL;
break;
case OP_SGE:
- vp->Opcode = VP_OPCODE_SGE;
+ vp->Opcode = OPCODE_SGE;
break;
case OP_SLT:
- vp->Opcode = VP_OPCODE_SLT;
+ vp->Opcode = OPCODE_SLT;
break;
case OP_SUB:
- vp->Opcode = VP_OPCODE_SUB;
+ vp->Opcode = OPCODE_SUB;
break;
case OP_XPD:
- vp->Opcode = VP_OPCODE_XPD;
+ vp->Opcode = OPCODE_XPD;
break;
}
if (parse_vp_dst_reg(ctx, inst, vc_head, Program, &vp->DstReg))
@@ -3298,7 +3297,7 @@ parse_vp_instruction (GLcontext * ctx, GLubyte ** inst,
case OP_ALU_TRI:
switch (code) {
case OP_MAD:
- vp->Opcode = VP_OPCODE_MAD;
+ vp->Opcode = OPCODE_MAD;
break;
}
@@ -3314,7 +3313,7 @@ parse_vp_instruction (GLcontext * ctx, GLubyte ** inst,
case OP_ALU_SWZ:
switch (code) {
case OP_SWZ:
- vp->Opcode = VP_OPCODE_SWZ;
+ vp->Opcode = OPCODE_SWZ;
break;
}
{
@@ -3332,7 +3331,7 @@ parse_vp_instruction (GLcontext * ctx, GLubyte ** inst,
parse_extended_swizzle_mask (inst, swizzle, &negateMask);
vp->SrcReg[0].File = file;
vp->SrcReg[0].Index = index;
- vp->SrcReg[0].Negate = negateMask;
+ vp->SrcReg[0].NegateBase = negateMask;
vp->SrcReg[0].Swizzle = MAKE_SWIZZLE4(swizzle[0],
swizzle[1],
swizzle[2],
@@ -3698,8 +3697,8 @@ parse_arb_program(GLcontext * ctx, GLubyte * inst, struct var_cache **vc_head,
/* Finally, tag on an OPCODE_END instruction */
if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
const GLuint numInst = Program->Base.NumInstructions;
- _mesa_init_fp_instruction(Program->FPInstructions + numInst);
- Program->FPInstructions[numInst].Opcode = FP_OPCODE_END;
+ _mesa_init_instruction(Program->FPInstructions + numInst);
+ Program->FPInstructions[numInst].Opcode = OPCODE_END;
/* YYY Wrong Position in program, whatever, at least not random -> crash
Program->Position = parse_position (&inst);
*/
@@ -3707,8 +3706,8 @@ parse_arb_program(GLcontext * ctx, GLubyte * inst, struct var_cache **vc_head,
}
else {
const GLuint numInst = Program->Base.NumInstructions;
- _mesa_init_vp_instruction(Program->VPInstructions + numInst);
- Program->VPInstructions[numInst].Opcode = VP_OPCODE_END;
+ _mesa_init_instruction(Program->VPInstructions + numInst);
+ Program->VPInstructions[numInst].Opcode = OPCODE_END;
/* YYY Wrong Position in program, whatever, at least not random -> crash
Program->Position = parse_position (&inst);
*/
diff --git a/src/mesa/shader/arbprogparse.h b/src/mesa/shader/arbprogparse.h
index 59f8e3b22e..5dbf31a2b1 100644
--- a/src/mesa/shader/arbprogparse.h
+++ b/src/mesa/shader/arbprogparse.h
@@ -28,8 +28,7 @@
#include "context.h"
#include "mtypes.h"
-#include "nvvertprog.h"
-#include "nvfragprog.h"
+#include "program_instruction.h"
#define MAX_INSTRUCTIONS 256
@@ -53,7 +52,7 @@ struct arb_program
GLuint MinorVersion;
/* ARB_vertex_program specifics */
- struct vp_instruction VPInstructions[MAX_INSTRUCTIONS];
+ struct prog_instruction VPInstructions[MAX_INSTRUCTIONS];
/* Options currently recognized by the parser */
/* ARB_fp */
@@ -64,7 +63,7 @@ struct arb_program
GLboolean HintPositionInvariant;
/* ARB_fragment_program specifics */
- struct fp_instruction FPInstructions[MAX_INSTRUCTIONS];
+ struct prog_instruction FPInstructions[MAX_INSTRUCTIONS];
GLbitfield TexturesUsed[MAX_TEXTURE_IMAGE_UNITS];
GLuint NumAluInstructions;
GLuint NumTexInstructions;
diff --git a/src/mesa/shader/arbprogram.c b/src/mesa/shader/arbprogram.c
index f47f673399..35b760bee5 100644
--- a/src/mesa/shader/arbprogram.c
+++ b/src/mesa/shader/arbprogram.c
@@ -39,9 +39,8 @@
#include "mtypes.h"
#include "nvprogram.h"
#include "nvfragparse.h"
-#include "nvfragprog.h"
+#include "program_instruction.h"
#include "nvvertparse.h"
-#include "nvvertprog.h"
void GLAPIENTRY
diff --git a/src/mesa/shader/arbvertparse.c b/src/mesa/shader/arbvertparse.c
index 2fbfa5fe9e..1cc2384fb5 100644
--- a/src/mesa/shader/arbvertparse.c
+++ b/src/mesa/shader/arbvertparse.c
@@ -40,7 +40,7 @@
#include "program.h"
#include "nvprogram.h"
#include "nvvertparse.h"
-#include "nvvertprog.h"
+#include "program_instruction.h"
#include "arbprogparse.h"
@@ -49,7 +49,7 @@
* XXX this is probably redundant. We've already got code like this
* in the nvvertparse.c file. Combine/clean-up someday.
*/
-void _mesa_debug_vp_inst(GLint num, struct vp_instruction *vp)
+void _mesa_debug_vp_inst(GLint num, struct prog_instruction *vp)
{
GLint a;
static const char *opcode_string[] = {
@@ -115,9 +115,9 @@ void _mesa_debug_vp_inst(GLint num, struct vp_instruction *vp)
if (vp[a].SrcReg[0].File != 0xf) {
if (vp[a].SrcReg[0].Swizzle != SWIZZLE_NOOP ||
- vp[a].SrcReg[0].Negate)
+ vp[a].SrcReg[0].NegateBase)
_mesa_printf("%s[%d].%s%c%c%c%c ", file_string[vp[a].SrcReg[0].File], vp[a].SrcReg[0].Index,
- vp[a].SrcReg[0].Negate ? "-" : "",
+ vp[a].SrcReg[0].NegateBase ? "-" : "",
swz[GET_SWZ(vp[a].SrcReg[0].Swizzle, 0)],
swz[GET_SWZ(vp[a].SrcReg[0].Swizzle, 1)],
swz[GET_SWZ(vp[a].SrcReg[0].Swizzle, 2)],
@@ -128,9 +128,9 @@ void _mesa_debug_vp_inst(GLint num, struct vp_instruction *vp)
if (vp[a].SrcReg[1].File != 0xf) {
if (vp[a].SrcReg[1].Swizzle != SWIZZLE_NOOP ||
- vp[a].SrcReg[1].Negate)
+ vp[a].SrcReg[1].NegateBase)
_mesa_printf("%s[%d].%s%c%c%c%c ", file_string[vp[a].SrcReg[1].File], vp[a].SrcReg[1].Index,
- vp[a].SrcReg[1].Negate ? "-" : "",
+ vp[a].SrcReg[1].NegateBase ? "-" : "",
swz[GET_SWZ(vp[a].SrcReg[1].Swizzle, 0)],
swz[GET_SWZ(vp[a].SrcReg[1].Swizzle, 1)],
swz[GET_SWZ(vp[a].SrcReg[1].Swizzle, 2)],
@@ -141,9 +141,9 @@ void _mesa_debug_vp_inst(GLint num, struct vp_instruction *vp)
if (vp[a].SrcReg[2].File != 0xf) {
if (vp[a].SrcReg[2].Swizzle != SWIZZLE_NOOP ||
- vp[a].SrcReg[2].Negate)
+ vp[a].SrcReg[2].NegateBase)
_mesa_printf("%s[%d].%s%c%c%c%c ", file_string[vp[a].SrcReg[2].File], vp[a].SrcReg[2].Index,
- vp[a].SrcReg[2].Negate ? "-" : "",
+ vp[a].SrcReg[2].NegateBase ? "-" : "",
swz[GET_SWZ(vp[a].SrcReg[2].Swizzle, 0)],
swz[GET_SWZ(vp[a].SrcReg[2].Swizzle, 1)],
swz[GET_SWZ(vp[a].SrcReg[2].Swizzle, 2)],
@@ -169,7 +169,7 @@ _mesa_parse_arb_vertex_program(GLcontext * ctx, GLenum target,
{
struct arb_program ap;
(void) target;
- struct vp_instruction *newInstructions;
+ struct prog_instruction *newInstructions;
/* set the program target before parsing */
ap.Base.Target = GL_VERTEX_PROGRAM_ARB;
@@ -183,14 +183,14 @@ _mesa_parse_arb_vertex_program(GLcontext * ctx, GLenum target,
* vertex_program struct.
*/
/* copy instruction buffer */
- newInstructions = (struct vp_instruction *)
- _mesa_malloc(ap.Base.NumInstructions * sizeof(struct vp_instruction));
+ newInstructions = (struct prog_instruction *)
+ _mesa_malloc(ap.Base.NumInstructions * sizeof(struct prog_instruction));
if (!newInstructions) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramStringARB");
return;
}
_mesa_memcpy(newInstructions, ap.VPInstructions,
- ap.Base.NumInstructions * sizeof(struct vp_instruction));
+ ap.Base.NumInstructions * sizeof(struct prog_instruction));
if (program->Instructions)
_mesa_free(program->Instructions);
program->Instructions = newInstructions;
diff --git a/src/mesa/shader/arbvertparse.h b/src/mesa/shader/arbvertparse.h
index f2ac1570be..30ff162913 100644
--- a/src/mesa/shader/arbvertparse.h
+++ b/src/mesa/shader/arbvertparse.h
@@ -31,6 +31,6 @@ _mesa_parse_arb_vertex_program(GLcontext * ctx, GLenum target,
struct vertex_program *program);
extern void
-_mesa_debug_vp_inst(GLint num, struct vp_instruction *vp);
+_mesa_debug_vp_inst(GLint num, struct prog_instruction *vp);
#endif
diff --git a/src/mesa/shader/nvfragparse.c b/src/mesa/shader/nvfragparse.c
index 3d72b485a2..3a48005844 100644
--- a/src/mesa/shader/nvfragparse.c
+++ b/src/mesa/shader/nvfragparse.c
@@ -1,8 +1,8 @@
/*
* Mesa 3-D graphics library
- * Version: 6.1
+ * Version: 6.5
*
- * Copyright (C) 1999-2004 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"),
@@ -43,7 +43,7 @@
#include "imports.h"
#include "macros.h"
#include "mtypes.h"
-#include "nvfragprog.h"
+#include "program_instruction.h"
#include "nvfragparse.h"
#include "nvprogram.h"
#include "program.h"
@@ -79,60 +79,60 @@
struct instruction_pattern {
const char *name;
- enum fp_opcode opcode;
+ enum prog_opcode opcode;
GLuint inputs;
GLuint outputs;
GLuint suffixes;
};
static const struct instruction_pattern Instructions[] = {
- { "ADD", FP_OPCODE_ADD, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
- { "COS", FP_OPCODE_COS, INPUT_1S, OUTPUT_S, _R | _H | _C | _S },
- { "DDX", FP_OPCODE_DDX, INPUT_1V, OUTPUT_V, _R | _H | _C | _S },
- { "DDY", FP_OPCODE_DDY, INPUT_1V, OUTPUT_V, _R | _H | _C | _S },
- { "DP3", FP_OPCODE_DP3, INPUT_2V, OUTPUT_S, _R | _H | _X | _C | _S },
- { "DP4", FP_OPCODE_DP4, INPUT_2V, OUTPUT_S, _R | _H | _X | _C | _S },
- { "DST", FP_OPCODE_DP4, INPUT_2V, OUTPUT_V, _R | _H | _C | _S },
- { "EX2", FP_OPCODE_DP4, INPUT_1S, OUTPUT_S, _R | _H | _C | _S },
- { "FLR", FP_OPCODE_FLR, INPUT_1V, OUTPUT_V, _R | _H | _X | _C | _S },
- { "FRC", FP_OPCODE_FRC, INPUT_1V, OUTPUT_V, _R | _H | _X | _C | _S },
- { "KIL", FP_OPCODE_KIL_NV, INPUT_CC, OUTPUT_NONE, 0 },
- { "LG2", FP_OPCODE_LG2, INPUT_1S, OUTPUT_S, _R | _H | _C | _S },
- { "LIT", FP_OPCODE_LIT, INPUT_1V, OUTPUT_V, _R | _H | _C | _S },
- { "LRP", FP_OPCODE_LRP, INPUT_3V, OUTPUT_V, _R | _H | _X | _C | _S },
- { "MAD", FP_OPCODE_MAD, INPUT_3V, OUTPUT_V, _R | _H | _X | _C | _S },
- { "MAX", FP_OPCODE_MAX, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
- { "MIN", FP_OPCODE_MIN, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
- { "MOV", FP_OPCODE_MOV, INPUT_1V, OUTPUT_V, _R | _H | _X | _C | _S },
- { "MUL", FP_OPCODE_MUL, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
- { "PK2H", FP_OPCODE_PK2H, INPUT_1V, OUTPUT_S, 0 },
- { "PK2US", FP_OPCODE_PK2US, INPUT_1V, OUTPUT_S, 0 },
- { "PK4B", FP_OPCODE_PK4B, INPUT_1V, OUTPUT_S, 0 },
- { "PK4UB", FP_OPCODE_PK4UB, INPUT_1V, OUTPUT_S, 0 },
- { "POW", FP_OPCODE_POW, INPUT_2S, OUTPUT_S, _R | _H | _C | _S },
- { "RCP", FP_OPCODE_RCP, INPUT_1S, OUTPUT_S, _R | _H | _C | _S },
- { "RFL", FP_OPCODE_RFL, INPUT_2V, OUTPUT_V, _R | _H | _C | _S },
- { "RSQ", FP_OPCODE_RSQ, INPUT_1S, OUTPUT_S, _R | _H | _C | _S },
- { "SEQ", FP_OPCODE_SEQ, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
- { "SFL", FP_OPCODE_SFL, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
- { "SGE", FP_OPCODE_SGE, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
- { "SGT", FP_OPCODE_SGT, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
- { "SIN", FP_OPCODE_SIN, INPUT_1S, OUTPUT_S, _R | _H | _C | _S },
- { "SLE", FP_OPCODE_SLE, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
- { "SLT", FP_OPCODE_SLT, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
- { "SNE", FP_OPCODE_SNE, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
- { "STR", FP_OPCODE_STR, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
- { "SUB", FP_OPCODE_SUB, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
- { "TEX", FP_OPCODE_TEX, INPUT_1V_T, OUTPUT_V, _C | _S },
- { "TXD", FP_OPCODE_TXD, INPUT_3V_T, OUTPUT_V, _C | _S },
- { "TXP", FP_OPCODE_TXP_NV, INPUT_1V_T, OUTPUT_V, _C | _S },
- { "UP2H", FP_OPCODE_UP2H, INPUT_1S, OUTPUT_V, _C | _S },
- { "UP2US", FP_OPCODE_UP2US, INPUT_1S, OUTPUT_V, _C | _S },
- { "UP4B", FP_OPCODE_UP4B, INPUT_1S, OUTPUT_V, _C | _S },
- { "UP4UB", FP_OPCODE_UP4UB, INPUT_1S, OUTPUT_V, _C | _S },
- { "X2D", FP_OPCODE_X2D, INPUT_3V, OUTPUT_V, _R | _H | _C | _S },
- { "PRINT", FP_OPCODE_PRINT, INPUT_1V_S, OUTPUT_NONE, 0 },
- { NULL, (enum fp_opcode) -1, 0, 0, 0 }
+ { "ADD", OPCODE_ADD, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
+ { "COS", OPCODE_COS, INPUT_1S, OUTPUT_S, _R | _H | _C | _S },
+ { "DDX", OPCODE_DDX, INPUT_1V, OUTPUT_V, _R | _H | _C | _S },
+ { "DDY", OPCODE_DDY, INPUT_1V, OUTPUT_V, _R | _H | _C | _S },
+ { "DP3", OPCODE_DP3, INPUT_2V, OUTPUT_S, _R | _H | _X | _C | _S },
+ { "DP4", OPCODE_DP4, INPUT_2V, OUTPUT_S, _R | _H | _X | _C | _S },
+ { "DST", OPCODE_DP4, INPUT_2V, OUTPUT_V, _R | _H | _C | _S },
+ { "EX2", OPCODE_DP4, INPUT_1S, OUTPUT_S, _R | _H | _C | _S },
+ { "FLR", OPCODE_FLR, INPUT_1V, OUTPUT_V, _R | _H | _X | _C | _S },
+ { "FRC", OPCODE_FRC, INPUT_1V, OUTPUT_V, _R | _H | _X | _C | _S },
+ { "KIL", OPCODE_KIL_NV, INPUT_CC, OUTPUT_NONE, 0 },
+ { "LG2", OPCODE_LG2, INPUT_1S, OUTPUT_S, _R | _H | _C | _S },
+ { "LIT", OPCODE_LIT, INPUT_1V, OUTPUT_V, _R | _H | _C | _S },
+ { "LRP", OPCODE_LRP, INPUT_3V, OUTPUT_V, _R | _H | _X | _C | _S },
+ { "MAD", OPCODE_MAD, INPUT_3V, OUTPUT_V, _R | _H | _X | _C | _S },
+ { "MAX", OPCODE_MAX, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
+ { "MIN", OPCODE_MIN, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
+ { "MOV", OPCODE_MOV, INPUT_1V, OUTPUT_V, _R | _H | _X | _C | _S },
+ { "MUL", OPCODE_MUL, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
+ { "PK2H", OPCODE_PK2H, INPUT_1V, OUTPUT_S, 0 },
+ { "PK2US", OPCODE_PK2US, INPUT_1V, OUTPUT_S, 0 },
+ { "PK4B", OPCODE_PK4B, INPUT_1V, OUTPUT_S, 0 },
+ { "PK4UB", OPCODE_PK4UB, INPUT_1V, OUTPUT_S, 0 },
+ { "POW", OPCODE_POW, INPUT_2S, OUTPUT_S, _R | _H | _C | _S },
+ { "RCP", OPCODE_RCP, INPUT_1S, OUTPUT_S, _R | _H | _C | _S },
+ { "RFL", OPCODE_RFL, INPUT_2V, OUTPUT_V, _R | _H | _C | _S },
+ { "RSQ", OPCODE_RSQ, INPUT_1S, OUTPUT_S, _R | _H | _C | _S },
+ { "SEQ", OPCODE_SEQ, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
+ { "SFL", OPCODE_SFL, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
+ { "SGE", OPCODE_SGE, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
+ { "SGT", OPCODE_SGT, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
+ { "SIN", OPCODE_SIN, INPUT_1S, OUTPUT_S, _R | _H | _C | _S },
+ { "SLE", OPCODE_SLE, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
+ { "SLT", OPCODE_SLT, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
+ { "SNE", OPCODE_SNE, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
+ { "STR", OPCODE_STR, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
+ { "SUB", OPCODE_SUB, INPUT_2V, OUTPUT_V, _R | _H | _X | _C | _S },
+ { "TEX", OPCODE_TEX, INPUT_1V_T, OUTPUT_V, _C | _S },
+ { "TXD", OPCODE_TXD, INPUT_3V_T, OUTPUT_V, _C | _S },
+ { "TXP", OPCODE_TXP_NV, INPUT_1V_T, OUTPUT_V, _C | _S },
+ { "UP2H", OPCODE_UP2H, INPUT_1S, OUTPUT_V, _C | _S },
+ { "UP2US", OPCODE_UP2US, INPUT_1S, OUTPUT_V, _C | _S },
+ { "UP4B", OPCODE_UP4B, INPUT_1S, OUTPUT_V, _C | _S },
+ { "UP4UB", OPCODE_UP4UB, INPUT_1S, OUTPUT_V, _C | _S },
+ { "X2D", OPCODE_X2D, INPUT_3V, OUTPUT_V, _R | _H | _C | _S },
+ { "PRINT", OPCODE_PRINT, INPUT_1V_S, OUTPUT_NONE, 0 },
+ { NULL, (enum prog_opcode) -1, 0, 0, 0 }
};
@@ -248,7 +248,7 @@ MatchInstruction(const GLubyte *token)
return result;
}
}
- result.opcode = (enum fp_opcode) -1;
+ result.opcode = (enum prog_opcode) -1;
return result;
}
@@ -668,7 +668,7 @@ Parse_SwizzleSuffix(const GLubyte *token, GLuint swizzle[4])
static GLboolean
Parse_CondCodeMask(struct parse_state *parseState,
- struct fp_dst_register *dstReg)
+ struct prog_dst_register *dstReg)
{
if (Parse_String(parseState, "EQ"))
dstReg->CondMask = COND_EQ;
@@ -865,7 +865,7 @@ Parse_OutputReg(struct parse_state *parseState, GLint *outputRegNum)
static GLboolean
Parse_MaskedDstReg(struct parse_state *parseState,
- struct fp_dst_register *dstReg)
+ struct prog_dst_register *dstReg)
{
GLubyte token[100];
GLint idx;
@@ -964,7 +964,7 @@ Parse_MaskedDstReg(struct parse_state *parseState,
*/
static GLboolean
Parse_VectorSrc(struct parse_state *parseState,
- struct fp_src_register *srcReg)
+ struct prog_src_register *srcReg)
{
GLfloat sign = 1.0F;
GLubyte token[100];
@@ -1087,7 +1087,7 @@ Parse_VectorSrc(struct parse_state *parseState,
static GLboolean
Parse_ScalarSrcReg(struct parse_state *parseState,
- struct fp_src_register *srcReg)
+ struct prog_src_register *srcReg)
{
GLubyte token[100];
GLfloat sign = 1.0F;
@@ -1198,7 +1198,7 @@ Parse_ScalarSrcReg(struct parse_state *parseState,
static GLboolean
Parse_PrintInstruction(struct parse_state *parseState,
- struct fp_instruction *inst)
+ struct prog_instruction *inst)
{
const GLubyte *str;
GLubyte *msg;
@@ -1251,15 +1251,15 @@ Parse_PrintInstruction(struct parse_state *parseState,
static GLboolean
Parse_InstructionSequence(struct parse_state *parseState,
- struct fp_instruction program[])
+ struct prog_instruction program[])
{
while (1) {
- struct fp_instruction *inst = program + parseState->numInst;
+ struct prog_instruction *inst = program + parseState->numInst;
struct instruction_pattern instMatch;
GLubyte token[100];
/* Initialize the instruction */
- _mesa_init_fp_instruction(inst);
+ _mesa_init_instruction(inst);
/* special instructions */
if (Parse_String(parseState, "DEFINE")) {
@@ -1301,7 +1301,7 @@ Parse_InstructionSequence(struct parse_state *parseState,
(const char *) id, value);
}
else if (Parse_String(parseState, "END")) {
- inst->Opcode = FP_OPCODE_END;
+ inst->Opcode = OPCODE_END;
inst->StringPos = parseState->curLine - parseState->start;
assert(inst->StringPos >= 0);
parseState->numInst++;
@@ -1328,7 +1328,7 @@ Parse_InstructionSequence(struct parse_state *parseState,
inst->Opcode = instMatch.opcode;
inst->Precision = instMatch.suffixes & (_R | _H | _X);
inst->Saturate = (instMatch.suffixes & (_S)) ? GL_TRUE : GL_FALSE;
- inst->UpdateCondRegister = (instMatch.suffixes & (_C)) ? GL_TRUE : GL_FALSE;
+ inst->CondUpdate = (instMatch.suffixes & (_C)) ? GL_TRUE : GL_FALSE;
inst->StringPos = parseState->curLine - parseState->start;
assert(inst->StringPos >= 0);
@@ -1342,7 +1342,7 @@ Parse_InstructionSequence(struct parse_state *parseState,
RETURN_ERROR1("Expected ,");
}
else if (instMatch.outputs == OUTPUT_NONE) {
- if (instMatch.opcode == FP_OPCODE_KIL_NV) {
+ if (instMatch.opcode == OPCODE_KIL_NV) {
/* This is a little weird, the cond code info is in
* the dest register.
*/
@@ -1350,7 +1350,7 @@ Parse_InstructionSequence(struct parse_state *parseState,
RETURN_ERROR;
}
else {
- ASSERT(instMatch.opcode == FP_OPCODE_PRINT);
+ ASSERT(instMatch.opcode == OPCODE_PRINT);
}
}
@@ -1402,7 +1402,7 @@ Parse_InstructionSequence(struct parse_state *parseState,
if (!Parse_TextureImageId(parseState, &unit, &idx))
RETURN_ERROR;
inst->TexSrcUnit = unit;
- inst->TexSrcIdx = idx;
+ inst->TexSrcTarget = idx;
}
else if (instMatch.inputs == INPUT_3V_T) {
GLubyte unit, idx;
@@ -1421,7 +1421,7 @@ Parse_InstructionSequence(struct parse_state *parseState,
if (!Parse_TextureImageId(parseState, &unit, &idx))
RETURN_ERROR;
inst->TexSrcUnit = unit;
- inst->TexSrcIdx = idx;
+ inst->TexSrcTarget = idx;
}
else if (instMatch.inputs == INPUT_1V_S) {
if (!Parse_PrintInstruction(parseState, inst))
@@ -1454,8 +1454,8 @@ _mesa_parse_nv_fragment_program(GLcontext *ctx, GLenum dstTarget,
struct fragment_program *program)
{
struct parse_state parseState;
- struct fp_instruction instBuffer[MAX_NV_FRAGMENT_PROGRAM_INSTRUCTIONS];
- struct fp_instruction *newInst;
+ struct prog_instruction instBuffer[MAX_NV_FRAGMENT_PROGRAM_INSTRUCTIONS];
+ struct prog_instruction *newInst;
GLenum target;
GLubyte *programString;
@@ -1519,14 +1519,14 @@ _mesa_parse_nv_fragment_program(GLcontext *ctx, GLenum dstTarget,
/* copy the compiled instructions */
assert(parseState.numInst <= MAX_NV_FRAGMENT_PROGRAM_INSTRUCTIONS);
- newInst = (struct fp_instruction *)
- MALLOC(parseState.numInst * sizeof(struct fp_instruction));
+ newInst = (struct prog_instruction *)
+ MALLOC(parseState.numInst * sizeof(struct prog_instruction));
if (!newInst) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glLoadProgramNV");
return; /* out of memory */
}
MEMCPY(newInst, instBuffer,
- parseState.numInst * sizeof(struct fp_instruction));
+ parseState.numInst * sizeof(struct prog_instruction));
/* install the program */
program->Base.Target = target;
@@ -1568,7 +1568,7 @@ _mesa_parse_nv_fragment_program(GLcontext *ctx, GLenum dstTarget,
static void
PrintSrcReg(const struct fragment_program *program,
- const struct fp_src_register *src)
+ const struct prog_src_register *src)
{
static const char comps[5] = "xyzw";
@@ -1635,10 +1635,10 @@ PrintSrcReg(const struct fragment_program *program,
}
static void
-PrintTextureSrc(const struct fp_instruction *inst)
+PrintTextureSrc(const struct prog_instruction *inst)
{
_mesa_printf("TEX%d, ", inst->TexSrcUnit);
- switch (inst->TexSrcIdx) {
+ switch (inst->TexSrcTarget) {
case TEXTURE_1D_INDEX:
_mesa_printf("1D");
break;
@@ -1660,7 +1660,7 @@ PrintTextureSrc(const struct fp_instruction *inst)
}
static void
-PrintCondCode(const struct fp_dst_register *dst)
+PrintCondCode(const struct prog_dst_register *dst)
{
static const char *comps = "xyzw";
static const char *ccString[] = {
@@ -1684,7 +1684,7 @@ PrintCondCode(const struct fp_dst_register *dst)
static void
-PrintDstReg(const struct fp_dst_register *dst)
+PrintDstReg(const struct prog_dst_register *dst)
{
if (dst->File == PROGRAM_OUTPUT) {
_mesa_printf("o[%s]", OutputRegisters[dst->Index]);
@@ -1732,9 +1732,9 @@ PrintDstReg(const struct fp_dst_register *dst)
void
_mesa_print_nv_fragment_program(const struct fragment_program *program)
{
- const struct fp_instruction *inst;
+ const struct prog_instruction *inst;
- for (inst = program->Instructions; inst->Opcode != FP_OPCODE_END; inst++) {
+ for (inst = program->Instructions; inst->Opcode != OPCODE_END; inst++) {
int i;
for (i = 0; Instructions[i].name; i++) {
if (inst->Opcode == Instructions[i].opcode) {
@@ -1744,7 +1744,7 @@ _mesa_print_nv_fragment_program(const struct fragment_program *program)
_mesa_printf("H");
else if (inst->Precision == FIXED12)
_mesa_printf("X");
- if (inst->UpdateCondRegister)
+ if (inst->CondUpdate)
_mesa_printf("C");
if (inst->Saturate)
_mesa_printf("_SAT");
@@ -1818,24 +1818,3 @@ _mesa_nv_fragment_output_register_name(GLuint i)
ASSERT(i < MAX_NV_FRAGMENT_PROGRAM_OUTPUTS);
return OutputRegisters[i];
}
-
-
-/**
- * Initialize fragment program instruction fields to defaults.
- */
-void
-_mesa_init_fp_instruction(struct fp_instruction *inst)
-{
- _mesa_bzero(inst, sizeof(struct fp_instruction));
- inst->SrcReg[0].File = PROGRAM_UNDEFINED;
- inst->SrcReg[0].Swizzle = SWIZZLE_NOOP;
- inst->SrcReg[1].File = PROGRAM_UNDEFINED;
- inst->SrcReg[1].Swizzle = SWIZZLE_NOOP;
- inst->SrcReg[2].File = PROGRAM_UNDEFINED;
- inst->SrcReg[2].Swizzle = SWIZZLE_NOOP;
- inst->DstReg.File = PROGRAM_UNDEFINED;
- inst->DstReg.WriteMask = WRITEMASK_XYZW;
- inst->DstReg.CondSwizzle = SWIZZLE_NOOP;
- inst->Precision = FLOAT32;
- inst->DstReg.CondMask = COND_TR;
-}
diff --git a/src/mesa/shader/nvfragprog.h b/src/mesa/shader/nvfragprog.h
deleted file mode 100644
index 8596ba08e1..0000000000
--- a/src/mesa/shader/nvfragprog.h
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- * Mesa 3-D graphics library
- * Version: 6.5
- *
- * 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"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-
-/* Private fragment program types and constants only used by files
- * related to fragment programs.
- *
- * XXX TO-DO: Rename this file "fragprog.h" since it's not NV-specific.
- */
-
-
-#ifndef NVFRAGPROG_H
-#define NVFRAGPROG_H
-
-#include "config.h"
-#include "mtypes.h"
-
-
-
-/* condition codes */
-#define COND_GT 1 /* greater than zero */
-#define COND_EQ 2 /* equal to zero */
-#define COND_LT 3 /* less than zero */
-#define COND_UN 4 /* unordered (NaN) */
-#define COND_GE 5 /* greater then or equal to zero */
-#define COND_LE 6 /* less then or equal to zero */
-#define COND_NE 7 /* not equal to zero */
-#define COND_TR 8 /* always true */
-#define COND_FL 9 /* always false */
-
-
-/* instruction precision */
-#define FLOAT32 0x1
-#define FLOAT16 0x2
-#define FIXED12 0x4
-
-
-/* Fragment program instruction opcodes */
-enum fp_opcode {
- FP_OPCODE_ABS, /* ARB_f_p only */
- FP_OPCODE_ADD,
- FP_OPCODE_CMP, /* ARB_f_p only */
- FP_OPCODE_COS,
- FP_OPCODE_DDX, /* NV_f_p only */
- FP_OPCODE_DDY, /* NV_f_p only */
- FP_OPCODE_DP3,
- FP_OPCODE_DP4,
- FP_OPCODE_DPH, /* ARB_f_p only */
- FP_OPCODE_DST,
- FP_OPCODE_END, /* private opcode */
- FP_OPCODE_EX2,
- FP_OPCODE_FLR,
- FP_OPCODE_FRC,
- FP_OPCODE_KIL, /* ARB_f_p only */
- FP_OPCODE_KIL_NV, /* NV_f_p only */
- FP_OPCODE_LG2,
- FP_OPCODE_LIT,
- FP_OPCODE_LRP,
- FP_OPCODE_MAD,
- FP_OPCODE_MAX,
- FP_OPCODE_MIN,
- FP_OPCODE_MOV,
- FP_OPCODE_MUL,
- FP_OPCODE_PK2H, /* NV_f_p only */
- FP_OPCODE_PK2US, /* NV_f_p only */
- FP_OPCODE_PK4B, /* NV_f_p only */
- FP_OPCODE_PK4UB, /* NV_f_p only */
- FP_OPCODE_POW,
- FP_OPCODE_PRINT, /* Mesa only */
- FP_OPCODE_RCP,
- FP_OPCODE_RFL, /* NV_f_p only */
- FP_OPCODE_RSQ,
- FP_OPCODE_SCS, /* ARB_f_p only */
- FP_OPCODE_SEQ, /* NV_f_p only */
- FP_OPCODE_SFL, /* NV_f_p only */
- FP_OPCODE_SGE, /* NV_f_p only */
- FP_OPCODE_SGT, /* NV_f_p only */
- FP_OPCODE_SIN,
- FP_OPCODE_SLE, /* NV_f_p only */
- FP_OPCODE_SLT,
- FP_OPCODE_SNE, /* NV_f_p only */
- FP_OPCODE_STR, /* NV_f_p only */
- FP_OPCODE_SUB,
- FP_OPCODE_SWZ, /* ARB_f_p only */
- FP_OPCODE_TEX,
- FP_OPCODE_TXB, /* ARB_f_p only */
- FP_OPCODE_TXD, /* NV_f_p only */
- FP_OPCODE_TXP, /* ARB_f_p only */
- FP_OPCODE_TXP_NV, /* NV_f_p only */
- FP_OPCODE_UP2H, /* NV_f_p only */
- FP_OPCODE_UP2US, /* NV_f_p only */
- FP_OPCODE_UP4B, /* NV_f_p only */
- FP_OPCODE_UP4UB, /* NV_f_p only */
- FP_OPCODE_X2D, /* NV_f_p only - 2d mat mul */
- FP_OPCODE_XPD /* ARB_f_p only - cross product */
-};
-
-
-/* Instruction source register */
-struct fp_src_register
-{
- GLuint File:4;
- GLuint Index:8;
- GLuint Swizzle:12;
- GLuint NegateBase:4; /* ARB: negate/extended negate, per component.
- NV: negate before absolute value? */
- GLuint Abs:1; /* NV: take absolute value (all components) ? */
- GLuint NegateAbs:1; /* NV: negate (all components) after absolute value? */
-};
-
-
-/* Instruction destination register */
-struct fp_dst_register
-{
- GLuint File:4;
- GLuint Index:8;
- GLuint WriteMask:4;
- GLuint CondMask:4; /* NV: enough bits? */
- GLuint CondSwizzle:12; /* NV: enough bits? */
-};
-
-
-/* Fragment program instruction */
-struct fp_instruction
-{
- GLuint Opcode:6;
- GLuint Saturate:1;
- GLuint UpdateCondRegister:1; /* NV */
- GLuint Precision:2; /* NV: unused/unneeded? */
- GLuint TexSrcUnit:4; /* texture unit for TEX, TXD, TXP instructions */
- GLuint TexSrcIdx:3; /* TEXTURE_1D,2D,3D,CUBE,RECT_INDEX source target */
-
-#if FEATURE_MESA_program_debug
- GLint StringPos:15; /* enough bits? */
-#endif
-
- void *Data; /* some arbitrary data, only used for PRINT instruction now */
- struct fp_src_register SrcReg[3];
- struct fp_dst_register DstReg;
-};
-
-
-extern void
-_mesa_init_fp_instruction(struct fp_instruction *inst);
-
-
-#endif
diff --git a/src/mesa/shader/nvprogram.c b/src/mesa/shader/nvprogram.c
index 4b89301764..c85e7c00bd 100644
--- a/src/mesa/shader/nvprogram.c
+++ b/src/mesa/shader/nvprogram.c
@@ -44,10 +44,9 @@
#include "macros.h"
#include "mtypes.h"
#include "nvfragparse.h"
-#include "nvfragprog.h"
+#include "program_instruction.h"
#include "nvvertexec.h"
#include "nvvertparse.h"
-#include "nvvertprog.h"
#include "nvprogram.h"
#include "program.h"
diff --git a/src/mesa/shader/nvvertexec.c b/src/mesa/shader/nvvertexec.c
index 1d7c7c72a1..5bb40d881e 100644
--- a/src/mesa/shader/nvvertexec.c
+++ b/src/mesa/shader/nvvertexec.c
@@ -34,7 +34,7 @@
#include "macros.h"
#include "mtypes.h"
#include "nvvertexec.h"
-#include "nvvertprog.h"
+#include "program_instruction.h"
#include "program.h"
#include "math/m_matrix.h"
@@ -227,7 +227,7 @@ _mesa_dump_vp_state( const struct gl_vertex_program_state *state )
* source register.
*/
static INLINE const GLfloat *
-get_register_pointer( const struct vp_src_register *source,
+get_register_pointer( const struct prog_src_register *source,
const struct gl_vertex_program_state *state )
{
if (source->RelAddr) {
@@ -277,13 +277,13 @@ get_register_pointer( const struct vp_src_register *source,
* Apply swizzling and negating as needed.
*/
static INLINE void
-fetch_vector4( const struct vp_src_register *source,
+fetch_vector4( const struct prog_src_register *source,
const struct gl_vertex_program_state *state,
GLfloat result[4] )
{
const GLfloat *src = get_register_pointer(source, state);
- if (source->Negate) {
+ if (source->NegateBase) {
result[0] = -src[GET_SWZ(source->Swizzle, 0)];
result[1] = -src[GET_SWZ(source->Swizzle, 1)];
result[2] = -src[GET_SWZ(source->Swizzle, 2)];
@@ -303,13 +303,13 @@ fetch_vector4( const struct vp_src_register *source,
* As above, but only return result[0] element.
*/
static INLINE void
-fetch_vector1( const struct vp_src_register *source,
+fetch_vector1( const struct prog_src_register *source,
const struct gl_vertex_program_state *state,
GLfloat result[4] )
{
const GLfloat *src = get_register_pointer(source, state);
- if (source->Negate) {
+ if (source->NegateBase) {
result[0] = -src[GET_SWZ(source->Swizzle, 0)];
}
else {
@@ -322,7 +322,7 @@ fetch_vector1( const struct vp_src_register *source,
* Store 4 floats into a register.
*/
static void
-store_vector4( const struct vp_dst_register *dest,
+store_vector4( const struct prog_dst_register *dest,
struct gl_vertex_program_state *state,
const GLfloat value[4] )
{
@@ -382,7 +382,7 @@ void
_mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
{
struct gl_vertex_program_state *state = &ctx->VertexProgram;
- const struct vp_instruction *inst;
+ const struct prog_instruction *inst;
ctx->_CurrentProgram = GL_VERTEX_PROGRAM_ARB; /* or NV, doesn't matter */
@@ -407,14 +407,14 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
}
switch (inst->Opcode) {
- case VP_OPCODE_MOV:
+ case OPCODE_MOV:
{
GLfloat t[4];
fetch_vector4( &inst->SrcReg[0], state, t );
store_vector4( &inst->DstReg, state, t );
}
break;
- case VP_OPCODE_LIT:
+ case OPCODE_LIT:
{
const GLfloat epsilon = 1.0F / 256.0F; /* per NV spec */
GLfloat t[4], lit[4];
@@ -429,7 +429,7 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, lit );
}
break;
- case VP_OPCODE_RCP:
+ case OPCODE_RCP:
{
GLfloat t[4];
fetch_vector1( &inst->SrcReg[0], state, t );
@@ -439,7 +439,7 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, t );
}
break;
- case VP_OPCODE_RSQ:
+ case OPCODE_RSQ:
{
GLfloat t[4];
fetch_vector1( &inst->SrcReg[0], state, t );
@@ -448,7 +448,7 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, t );
}
break;
- case VP_OPCODE_EXP:
+ case OPCODE_EXP:
{
GLfloat t[4], q[4], floor_t0;
fetch_vector1( &inst->SrcReg[0], state, t );
@@ -477,7 +477,7 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, q );
}
break;
- case VP_OPCODE_LOG:
+ case OPCODE_LOG:
{
GLfloat t[4], q[4], abs_t0;
fetch_vector1( &inst->SrcReg[0], state, t );
@@ -514,7 +514,7 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, q );
}
break;
- case VP_OPCODE_MUL:
+ case OPCODE_MUL:
{
GLfloat t[4], u[4], prod[4];
fetch_vector4( &inst->SrcReg[0], state, t );
@@ -526,7 +526,7 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, prod );
}
break;
- case VP_OPCODE_ADD:
+ case OPCODE_ADD:
{
GLfloat t[4], u[4], sum[4];
fetch_vector4( &inst->SrcReg[0], state, t );
@@ -538,7 +538,7 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, sum );
}
break;
- case VP_OPCODE_DP3:
+ case OPCODE_DP3:
{
GLfloat t[4], u[4], dot[4];
fetch_vector4( &inst->SrcReg[0], state, t );
@@ -548,7 +548,7 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, dot );
}
break;
- case VP_OPCODE_DP4:
+ case OPCODE_DP4:
{
GLfloat t[4], u[4], dot[4];
fetch_vector4( &inst->SrcReg[0], state, t );
@@ -558,7 +558,7 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, dot );
}
break;
- case VP_OPCODE_DST:
+ case OPCODE_DST:
{
GLfloat t[4], u[4], dst[4];
fetch_vector4( &inst->SrcReg[0], state, t );
@@ -570,7 +570,7 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, dst );
}
break;
- case VP_OPCODE_MIN:
+ case OPCODE_MIN:
{
GLfloat t[4], u[4], min[4];
fetch_vector4( &inst->SrcReg[0], state, t );
@@ -582,7 +582,7 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, min );
}
break;
- case VP_OPCODE_MAX:
+ case OPCODE_MAX:
{
GLfloat t[4], u[4], max[4];
fetch_vector4( &inst->SrcReg[0], state, t );
@@ -594,7 +594,7 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, max );
}
break;
- case VP_OPCODE_SLT:
+ case OPCODE_SLT:
{
GLfloat t[4], u[4], slt[4];
fetch_vector4( &inst->SrcReg[0], state, t );
@@ -606,7 +606,7 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, slt );
}
break;
- case VP_OPCODE_SGE:
+ case OPCODE_SGE:
{
GLfloat t[4], u[4], sge[4];
fetch_vector4( &inst->SrcReg[0], state, t );
@@ -618,7 +618,7 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, sge );
}
break;
- case VP_OPCODE_MAD:
+ case OPCODE_MAD:
{
GLfloat t[4], u[4], v[4], sum[4];
fetch_vector4( &inst->SrcReg[0], state, t );
@@ -631,14 +631,14 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, sum );
}
break;
- case VP_OPCODE_ARL:
+ case OPCODE_ARL:
{
GLfloat t[4];
fetch_vector4( &inst->SrcReg[0], state, t );
state->AddressReg[0] = (GLint) FLOORF(t[0]);
}
break;
- case VP_OPCODE_DPH:
+ case OPCODE_DPH:
{
GLfloat t[4], u[4], dot[4];
fetch_vector4( &inst->SrcReg[0], state, t );
@@ -648,7 +648,7 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, dot );
}
break;
- case VP_OPCODE_RCC:
+ case OPCODE_RCC:
{
GLfloat t[4], u;
fetch_vector1( &inst->SrcReg[0], state, t );
@@ -676,7 +676,7 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, t );
}
break;
- case VP_OPCODE_SUB: /* GL_NV_vertex_program1_1 */
+ case OPCODE_SUB: /* GL_NV_vertex_program1_1 */
{
GLfloat t[4], u[4], sum[4];
fetch_vector4( &inst->SrcReg[0], state, t );
@@ -688,7 +688,7 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, sum );
}
break;
- case VP_OPCODE_ABS: /* GL_NV_vertex_program1_1 */
+ case OPCODE_ABS: /* GL_NV_vertex_program1_1 */
{
GLfloat t[4];
fetch_vector4( &inst->SrcReg[0], state, t );
@@ -699,7 +699,7 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, t );
}
break;
- case VP_OPCODE_FLR: /* GL_ARB_vertex_program */
+ case OPCODE_FLR: /* GL_ARB_vertex_program */
{
GLfloat t[4];
fetch_vector4( &inst->SrcReg[0], state, t );
@@ -710,7 +710,7 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, t );
}
break;
- case VP_OPCODE_FRC: /* GL_ARB_vertex_program */
+ case OPCODE_FRC: /* GL_ARB_vertex_program */
{
GLfloat t[4];
fetch_vector4( &inst->SrcReg[0], state, t );
@@ -721,7 +721,7 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, t );
}
break;
- case VP_OPCODE_EX2: /* GL_ARB_vertex_program */
+ case OPCODE_EX2: /* GL_ARB_vertex_program */
{
GLfloat t[4];
fetch_vector1( &inst->SrcReg[0], state, t );
@@ -729,7 +729,7 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, t );
}
break;
- case VP_OPCODE_LG2: /* GL_ARB_vertex_program */
+ case OPCODE_LG2: /* GL_ARB_vertex_program */
{
GLfloat t[4];
fetch_vector1( &inst->SrcReg[0], state, t );
@@ -737,7 +737,7 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, t );
}
break;
- case VP_OPCODE_POW: /* GL_ARB_vertex_program */
+ case OPCODE_POW: /* GL_ARB_vertex_program */
{
GLfloat t[4], u[4];
fetch_vector1( &inst->SrcReg[0], state, t );
@@ -746,7 +746,7 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, t );
}
break;
- case VP_OPCODE_XPD: /* GL_ARB_vertex_program */
+ case OPCODE_XPD: /* GL_ARB_vertex_program */
{
GLfloat t[4], u[4], cross[4];
fetch_vector4( &inst->SrcReg[0], state, t );
@@ -757,9 +757,9 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
store_vector4( &inst->DstReg, state, cross );
}
break;
- case VP_OPCODE_SWZ: /* GL_ARB_vertex_program */
+ case OPCODE_SWZ: /* GL_ARB_vertex_program */
{
- const struct vp_src_register *source = &inst->SrcReg[0];
+ const struct prog_src_register *source = &inst->SrcReg[0];
const GLfloat *src = get_register_pointer(source, state);
GLfloat result[4];
GLuint i;
@@ -772,13 +772,13 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
result[i] = 1.0;
else
result[i] = src[GET_SWZ(source->Swizzle, i)];
- if (source->Negate & (1 << i))
+ if (source->NegateBase & (1 << i))
result[i] = -result[i];
}
store_vector4( &inst->DstReg, state, result );
}
break;
- case VP_OPCODE_PRINT:
+ case OPCODE_PRINT:
if (inst->SrcReg[0].File) {
GLfloat t[4];
fetch_vector4( &inst->SrcReg[0], state, t );
@@ -789,7 +789,7 @@ _mesa_exec_vertex_program(GLcontext *ctx, const struct vertex_program *program)
_mesa_printf("%s\n", (char *) inst->Data);
}
break;
- case VP_OPCODE_END:
+ case OPCODE_END:
ctx->_CurrentProgram = 0;
return;
default:
@@ -818,7 +818,7 @@ masking, relative addressing, etc. when they're not needed.
For example:
-void simple_add( struct vp_instruction *inst )
+void simple_add( struct prog_instruction *inst )
{
GLfloat *sum = machine->Registers[inst->DstReg.Register];
GLfloat *a = machine->Registers[inst->SrcReg[0].Register];
diff --git a/src/mesa/shader/nvvertparse.c b/src/mesa/shader/nvvertparse.c
index c36d43dd24..d5b08def43 100644
--- a/src/mesa/shader/nvvertparse.c
+++ b/src/mesa/shader/nvvertparse.c
@@ -1,8 +1,8 @@
/*
* Mesa 3-D graphics library
- * Version: 6.3
+ * Version: 6.5
*
- * Copyright (C) 1999-2004 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"),
@@ -45,7 +45,7 @@
#include "mtypes.h"
#include "nvprogram.h"
#include "nvvertparse.h"
-#include "nvvertprog.h"
+#include "program_instruction.h"
#include "program.h"
@@ -293,7 +293,7 @@ static const char *OutputRegisters[MAX_NV_VERTEX_PROGRAM_OUTPUTS + 1] = {
"PSIZ", "BFC0", "BFC1", NULL
};
-/* NOTE: the order here must match opcodes in nvvertprog.h */
+/* NOTE: the order here must match opcodes in program_instruction.h */
static const char *Opcodes[] = {
"MOV", "LIT", "RCP", "RSQ", "EXP", "LOG", "MUL", "ADD", "DP3", "DP4",
"DST", "MIN", "MAX", "SLT", "SGE", "MAD", "ARL", "DPH", "RCC", "SUB",
@@ -393,7 +393,7 @@ Parse_AbsParamReg(struct parse_state *parseState, GLint *regNum)
static GLboolean
-Parse_ParamReg(struct parse_state *parseState, struct vp_src_register *srcReg)
+Parse_ParamReg(struct parse_state *parseState, struct prog_src_register *srcReg)
{
GLubyte token[100];
@@ -561,7 +561,7 @@ Parse_OutputReg(struct parse_state *parseState, GLint *outputRegNum)
static GLboolean
-Parse_MaskedDstReg(struct parse_state *parseState, struct vp_dst_register *dstReg)
+Parse_MaskedDstReg(struct parse_state *parseState, struct prog_dst_register *dstReg)
{
GLubyte token[100];
GLint idx;
@@ -642,7 +642,7 @@ Parse_MaskedDstReg(struct parse_state *parseState, struct vp_dst_register *dstRe
static GLboolean
-Parse_SwizzleSrcReg(struct parse_state *parseState, struct vp_src_register *srcReg)
+Parse_SwizzleSrcReg(struct parse_state *parseState, struct prog_src_register *srcReg)
{
GLubyte token[100];
GLint idx;
@@ -654,12 +654,12 @@ Parse_SwizzleSrcReg(struct parse_state *parseState, struct vp_src_register *srcR
RETURN_ERROR;
if (token[0] == '-') {
(void) Parse_String(parseState, "-");
- srcReg->Negate = GL_TRUE;
+ srcReg->NegateBase = GL_TRUE;
if (!Peek_Token(parseState, token))
RETURN_ERROR;
}
else {
- srcReg->Negate = GL_FALSE;
+ srcReg->NegateBase = GL_FALSE;
}
/* Src reg can be R<n>, c[n], c[n +/- offset], or a named vertex attrib */
@@ -733,7 +733,7 @@ Parse_SwizzleSrcReg(struct parse_state *parseState, struct vp_src_register *srcR
static GLboolean
-Parse_ScalarSrcReg(struct parse_state *parseState, struct vp_src_register *srcReg)
+Parse_ScalarSrcReg(struct parse_state *parseState, struct prog_src_register *srcReg)
{
GLubyte token[100];
GLint idx;
@@ -744,13 +744,13 @@ Parse_ScalarSrcReg(struct parse_state *parseState, struct vp_src_register *srcRe
if (!Peek_Token(parseState, token))
RETURN_ERROR;
if (token[0] == '-') {
- srcReg->Negate = GL_TRUE;
+ srcReg->NegateBase = GL_TRUE;
(void) Parse_String(parseState, "-"); /* consume '-' */
if (!Peek_Token(parseState, token))
RETURN_ERROR;
}
else {
- srcReg->Negate = GL_FALSE;
+ srcReg->NegateBase = GL_FALSE;
}
/* Src reg can be R<n>, c[n], c[n +/- offset], or a named vertex attrib */
@@ -803,9 +803,10 @@ Parse_ScalarSrcReg(struct parse_state *parseState, struct vp_src_register *srcRe
static GLint
Parse_UnaryOpInstruction(struct parse_state *parseState,
- struct vp_instruction *inst, enum vp_opcode opcode)
+ struct prog_instruction *inst,
+ enum prog_opcode opcode)
{
- if (opcode == VP_OPCODE_ABS && !parseState->isVersion1_1)
+ if (opcode == OPCODE_ABS && !parseState->isVersion1_1)
RETURN_ERROR1("ABS illegal for vertex program 1.0");
inst->Opcode = opcode;
@@ -833,11 +834,12 @@ Parse_UnaryOpInstruction(struct parse_state *parseState,
static GLboolean
Parse_BiOpInstruction(struct parse_state *parseState,
- struct vp_instruction *inst, enum vp_opcode opcode)
+ struct prog_instruction *inst,
+ enum prog_opcode opcode)
{
- if (opcode == VP_OPCODE_DPH && !parseState->isVersion1_1)
+ if (opcode == OPCODE_DPH && !parseState->isVersion1_1)
RETURN_ERROR1("DPH illegal for vertex program 1.0");
- if (opcode == VP_OPCODE_SUB && !parseState->isVersion1_1)
+ if (opcode == OPCODE_SUB && !parseState->isVersion1_1)
RETURN_ERROR1("SUB illegal for vertex program 1.0");
inst->Opcode = opcode;
@@ -885,7 +887,8 @@ Parse_BiOpInstruction(struct parse_state *parseState,
static GLboolean
Parse_TriOpInstruction(struct parse_state *parseState,
- struct vp_instruction *inst, enum vp_opcode opcode)
+ struct prog_instruction *inst,
+ enum prog_opcode opcode)
{
inst->Opcode = opcode;
inst->StringPos = parseState->curLine - parseState->start;
@@ -952,9 +955,10 @@ Parse_TriOpInstruction(struct parse_state *parseState,
static GLboolean
Parse_ScalarInstruction(struct parse_state *parseState,
- struct vp_instruction *inst, enum vp_opcode opcode)
+ struct prog_instruction *inst,
+ enum prog_opcode opcode)
{
- if (opcode == VP_OPCODE_RCC && !parseState->isVersion1_1)
+ if (opcode == OPCODE_RCC && !parseState->isVersion1_1)
RETURN_ERROR1("RCC illegal for vertex program 1.0");
inst->Opcode = opcode;
@@ -981,9 +985,9 @@ Parse_ScalarInstruction(struct parse_state *parseState,
static GLboolean
-Parse_AddressInstruction(struct parse_state *parseState, struct vp_instruction *inst)
+Parse_AddressInstruction(struct parse_state *parseState, struct prog_instruction *inst)
{
- inst->Opcode = VP_OPCODE_ARL;
+ inst->Opcode = OPCODE_ARL;
inst->StringPos = parseState->curLine - parseState->start;
/* dest A0 reg */
@@ -1007,11 +1011,11 @@ Parse_AddressInstruction(struct parse_state *parseState, struct vp_instruction *
static GLboolean
-Parse_EndInstruction(struct parse_state *parseState, struct vp_instruction *inst)
+Parse_EndInstruction(struct parse_state *parseState, struct prog_instruction *inst)
{
GLubyte token[100];
- inst->Opcode = VP_OPCODE_END;
+ inst->Opcode = OPCODE_END;
inst->StringPos = parseState->curLine - parseState->start;
/* this should fail! */
@@ -1036,16 +1040,16 @@ Parse_EndInstruction(struct parse_state *parseState, struct vp_instruction *inst
* | "PRINT" <string literal> "," <dstReg>
*/
static GLboolean
-Parse_PrintInstruction(struct parse_state *parseState, struct vp_instruction *inst)
+Parse_PrintInstruction(struct parse_state *parseState, struct prog_instruction *inst)
{
const GLubyte *str;
GLubyte *msg;
GLuint len;
GLubyte token[100];
- struct vp_src_register *srcReg = &inst->SrcReg[0];
+ struct prog_src_register *srcReg = &inst->SrcReg[0];
GLint idx;
- inst->Opcode = VP_OPCODE_PRINT;
+ inst->Opcode = OPCODE_PRINT;
inst->StringPos = parseState->curLine - parseState->start;
/* The first argument is a literal string 'just like this' */
@@ -1070,7 +1074,7 @@ Parse_PrintInstruction(struct parse_state *parseState, struct vp_instruction *in
RETURN_ERROR;
srcReg->RelAddr = GL_FALSE;
- srcReg->Negate = GL_FALSE;
+ srcReg->NegateBase = GL_FALSE;
srcReg->Swizzle = SWIZZLE_NOOP;
/* Register can be R<n>, c[n], c[n +/- offset], a named vertex attrib,
@@ -1117,7 +1121,7 @@ Parse_PrintInstruction(struct parse_state *parseState, struct vp_instruction *in
static GLboolean
Parse_OptionSequence(struct parse_state *parseState,
- struct vp_instruction program[])
+ struct prog_instruction program[])
{
(void) program;
while (1) {
@@ -1137,92 +1141,92 @@ Parse_OptionSequence(struct parse_state *parseState,
static GLboolean
Parse_InstructionSequence(struct parse_state *parseState,
- struct vp_instruction program[])
+ struct prog_instruction program[])
{
while (1) {
- struct vp_instruction *inst = program + parseState->numInst;
+ struct prog_instruction *inst = program + parseState->numInst;
/* Initialize the instruction */
- _mesa_init_vp_instruction(inst);
+ _mesa_init_instruction(inst);
if (Parse_String(parseState, "MOV")) {
- if (!Parse_UnaryOpInstruction(parseState, inst, VP_OPCODE_MOV))
+ if (!Parse_UnaryOpInstruction(parseState, inst, OPCODE_MOV))
RETURN_ERROR;
}
else if (Parse_String(parseState, "LIT")) {
- if (!Parse_UnaryOpInstruction(parseState, inst, VP_OPCODE_LIT))
+ if (!Parse_UnaryOpInstruction(parseState, inst, OPCODE_LIT))
RETURN_ERROR;
}
else if (Parse_String(parseState, "ABS")) {
- if (!Parse_UnaryOpInstruction(parseState, inst, VP_OPCODE_ABS))
+ if (!Parse_UnaryOpInstruction(parseState, inst, OPCODE_ABS))
RETURN_ERROR;
}
else if (Parse_String(parseState, "MUL")) {
- if (!Parse_BiOpInstruction(parseState, inst, VP_OPCODE_MUL))
+ if (!Parse_BiOpInstruction(parseState, inst, OPCODE_MUL))
RETURN_ERROR;
}
else if (Parse_String(parseState, "ADD")) {
- if (!Parse_BiOpInstruction(parseState, inst, VP_OPCODE_ADD))
+ if (!Parse_BiOpInstruction(parseState, inst, OPCODE_ADD))
RETURN_ERROR;
}
else if (Parse_String(parseState, "DP3")) {
- if (!Parse_BiOpInstruction(parseState, inst, VP_OPCODE_DP3))
+ if (!Parse_BiOpInstruction(parseState, inst, OPCODE_DP3))
RETURN_ERROR;
}
else if (Parse_String(parseState, "DP4")) {
- if (!Parse_BiOpInstruction(parseState, inst, VP_OPCODE_DP4))
+ if (!Parse_BiOpInstruction(parseState, inst, OPCODE_DP4))
RETURN_ERROR;
}
else if (Parse_String(parseState, "DST")) {
- if (!Parse_BiOpInstruction(parseState, inst, VP_OPCODE_DST))
+ if (!Parse_BiOpInstruction(parseState, inst, OPCODE_DST))
RETURN_ERROR;
}
else if (Parse_String(parseState, "MIN")) {
- if (!Parse_BiOpInstruction(parseState, inst, VP_OPCODE_MIN))
+ if (!Parse_BiOpInstruction(parseState, inst, OPCODE_MIN))
RETURN_ERROR;
}
else if (Parse_String(parseState, "MAX")) {
- if (!Parse_BiOpInstruction(parseState, inst, VP_OPCODE_MAX))
+ if (!Parse_BiOpInstruction(parseState, inst, OPCODE_MAX))
RETURN_ERROR;
}
else if (Parse_String(parseState, "SLT")) {
- if (!Parse_BiOpInstruction(parseState, inst, VP_OPCODE_SLT))
+ if (!Parse_BiOpInstruction(parseState, inst, OPCODE_SLT))
RETURN_ERROR;
}
else if (Parse_String(parseState, "SGE")) {
- if (!Parse_BiOpInstruction(parseState, inst, VP_OPCODE_SGE))
+ if (!Parse_BiOpInstruction(parseState, inst, OPCODE_SGE))
RETURN_ERROR;
}
else if (Parse_String(parseState, "DPH")) {
- if (!Parse_BiOpInstruction(parseState, inst, VP_OPCODE_DPH))
+ if (!Parse_BiOpInstruction(parseState, inst, OPCODE_DPH))
RETURN_ERROR;
}
else if (Parse_String(parseState, "SUB")) {
- if (!Parse_BiOpInstruction(parseState, inst, VP_OPCODE_SUB))
+ if (!Parse_BiOpInstruction(parseState, inst, OPCODE_SUB))
RETURN_ERROR;
}
else if (Parse_String(parseState, "MAD")) {
- if (!Parse_TriOpInstruction(parseState, inst, VP_OPCODE_MAD))
+ if (!Parse_TriOpInstruction(parseState, inst, OPCODE_MAD))
RETURN_ERROR;
}
else if (Parse_String(parseState, "RCP")) {
- if (!Parse_ScalarInstruction(parseState, inst, VP_OPCODE_RCP))
+ if (!Parse_ScalarInstruction(parseState, inst, OPCODE_RCP))
RETURN_ERROR;
}
else if (Parse_String(parseState, "RSQ")) {
- if (!Parse_ScalarInstruction(parseState, inst, VP_OPCODE_RSQ))
+ if (!Parse_ScalarInstruction(parseState, inst, OPCODE_RSQ))
RETURN_ERROR;
}
else if (Parse_String(parseState, "EXP")) {
- if (!Parse_ScalarInstruction(parseState, inst, VP_OPCODE_EXP))
+ if (!Parse_ScalarInstruction(parseState, inst, OPCODE_EXP))
RETURN_ERROR;
}
else if (Parse_String(parseState, "LOG")) {
- if (!Parse_ScalarInstruction(parseState, inst, VP_OPCODE_LOG))
+ if (!Parse_ScalarInstruction(parseState, inst, OPCODE_LOG))
RETURN_ERROR;
}
else if (Parse_String(parseState, "RCC")) {
- if (!Parse_ScalarInstruction(parseState, inst, VP_OPCODE_RCC))
+ if (!Parse_ScalarInstruction(parseState, inst, OPCODE_RCC))
RETURN_ERROR;
}
else if (Parse_String(parseState, "ARL")) {
@@ -1271,7 +1275,7 @@ Parse_InstructionSequence(struct parse_state *parseState,
static GLboolean
Parse_Program(struct parse_state *parseState,
- struct vp_instruction instBuffer[])
+ struct prog_instruction instBuffer[])
{
if (parseState->isVersion1_1) {
if (!Parse_OptionSequence(parseState, instBuffer)) {
@@ -1293,8 +1297,8 @@ _mesa_parse_nv_vertex_program(GLcontext *ctx, GLenum dstTarget,
struct vertex_program *program)
{
struct parse_state parseState;
- struct vp_instruction instBuffer[MAX_NV_VERTEX_PROGRAM_INSTRUCTIONS];
- struct vp_instruction *newInst;
+ struct prog_instruction instBuffer[MAX_NV_VERTEX_PROGRAM_INSTRUCTIONS];
+ struct prog_instruction *newInst;
GLenum target;
GLubyte *programString;
@@ -1374,15 +1378,15 @@ _mesa_parse_nv_vertex_program(GLcontext *ctx, GLenum dstTarget,
/* copy the compiled instructions */
assert(parseState.numInst <= MAX_NV_VERTEX_PROGRAM_INSTRUCTIONS);
- newInst = (struct vp_instruction *)
- MALLOC(parseState.numInst * sizeof(struct vp_instruction));
+ newInst = (struct prog_instruction *)
+ MALLOC(parseState.numInst * sizeof(struct prog_instruction));
if (!newInst) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glLoadProgramNV");
FREE(programString);
return; /* out of memory */
}
MEMCPY(newInst, instBuffer,
- parseState.numInst * sizeof(struct vp_instruction));
+ parseState.numInst * sizeof(struct prog_instruction));
/* install the program */
program->Base.Target = target;
@@ -1419,10 +1423,10 @@ _mesa_parse_nv_vertex_program(GLcontext *ctx, GLenum dstTarget,
static void
-PrintSrcReg(const struct vp_src_register *src)
+PrintSrcReg(const struct prog_src_register *src)
{
static const char comps[5] = "xyzw";
- if (src->Negate)
+ if (src->NegateBase)
_mesa_printf("-");
if (src->RelAddr) {
if (src->Index > 0)
@@ -1462,7 +1466,7 @@ PrintSrcReg(const struct vp_src_register *src)
static void
-PrintDstReg(const struct vp_dst_register *dst)
+PrintDstReg(const struct prog_dst_register *dst)
{
if (dst->File == PROGRAM_OUTPUT) {
_mesa_printf("o[%s]", OutputRegisters[dst->Index]);
@@ -1496,34 +1500,34 @@ PrintDstReg(const struct vp_dst_register *dst)
* Print a single NVIDIA vertex program instruction.
*/
void
-_mesa_print_nv_vertex_instruction(const struct vp_instruction *inst)
+_mesa_print_nv_vertex_instruction(const struct prog_instruction *inst)
{
switch (inst->Opcode) {
- case VP_OPCODE_MOV:
- case VP_OPCODE_LIT:
- case VP_OPCODE_RCP:
- case VP_OPCODE_RSQ:
- case VP_OPCODE_EXP:
- case VP_OPCODE_LOG:
- case VP_OPCODE_RCC:
- case VP_OPCODE_ABS:
+ case OPCODE_MOV:
+ case OPCODE_LIT:
+ case OPCODE_RCP:
+ case OPCODE_RSQ:
+ case OPCODE_EXP:
+ case OPCODE_LOG:
+ case OPCODE_RCC:
+ case OPCODE_ABS:
_mesa_printf("%s ", Opcodes[(int) inst->Opcode]);
PrintDstReg(&inst->DstReg);
_mesa_printf(", ");
PrintSrcReg(&inst->SrcReg[0]);
_mesa_printf(";\n");
break;
- case VP_OPCODE_MUL:
- case VP_OPCODE_ADD:
- case VP_OPCODE_DP3:
- case VP_OPCODE_DP4:
- case VP_OPCODE_DST:
- case VP_OPCODE_MIN:
- case VP_OPCODE_MAX:
- case VP_OPCODE_SLT:
- case VP_OPCODE_SGE:
- case VP_OPCODE_DPH:
- case VP_OPCODE_SUB:
+ case OPCODE_MUL:
+ case OPCODE_ADD:
+ case OPCODE_DP3:
+ case OPCODE_DP4:
+ case OPCODE_DST:
+ case OPCODE_MIN:
+ case OPCODE_MAX:
+ case OPCODE_SLT:
+ case OPCODE_SGE:
+ case OPCODE_DPH:
+ case OPCODE_SUB:
_mesa_printf("%s ", Opcodes[(int) inst->Opcode]);
PrintDstReg(&inst->DstReg);
_mesa_printf(", ");
@@ -1532,7 +1536,7 @@ _mesa_print_nv_vertex_instruction(const struct vp_instruction *inst)
PrintSrcReg(&inst->SrcReg[1]);
_mesa_printf(";\n");
break;
- case VP_OPCODE_MAD:
+ case OPCODE_MAD:
_mesa_printf("MAD ");
PrintDstReg(&inst->DstReg);
_mesa_printf(", ");
@@ -1543,12 +1547,12 @@ _mesa_print_nv_vertex_instruction(const struct vp_instruction *inst)
PrintSrcReg(&inst->SrcReg[2]);
_mesa_printf(";\n");
break;
- case VP_OPCODE_ARL:
+ case OPCODE_ARL:
_mesa_printf("ARL A0.x, ");
PrintSrcReg(&inst->SrcReg[0]);
_mesa_printf(";\n");
break;
- case VP_OPCODE_PRINT:
+ case OPCODE_PRINT:
_mesa_printf("PRINT '%s'", inst->Data);
if (inst->SrcReg[0].File) {
_mesa_printf(", ");
@@ -1559,7 +1563,7 @@ _mesa_print_nv_vertex_instruction(const struct vp_instruction *inst)
_mesa_printf("\n");
}
break;
- case VP_OPCODE_END:
+ case OPCODE_END:
_mesa_printf("END\n");
break;
default:
@@ -1574,11 +1578,11 @@ _mesa_print_nv_vertex_instruction(const struct vp_instruction *inst)
void
_mesa_print_nv_vertex_program(const struct vertex_program *program)
{
- const struct vp_instruction *inst;
+ const struct prog_instruction *inst;
for (inst = program->Instructions; ; inst++) {
_mesa_print_nv_vertex_instruction(inst);
- if (inst->Opcode == VP_OPCODE_END)
+ if (inst->Opcode == OPCODE_END)
return;
}
}
@@ -1601,19 +1605,24 @@ _mesa_nv_vertex_output_register_name(GLuint i)
/**
- * Initialize vertex program instruction fields to defaults.
+ * Initialize program instruction fields to defaults.
*/
void
-_mesa_init_vp_instruction(struct vp_instruction *inst)
+_mesa_init_instruction(struct prog_instruction *inst)
{
- _mesa_bzero(inst, sizeof(struct vp_instruction));
+ _mesa_bzero(inst, sizeof(struct prog_instruction));
+
inst->SrcReg[0].File = PROGRAM_UNDEFINED;
inst->SrcReg[0].Swizzle = SWIZZLE_NOOP;
inst->SrcReg[1].File = PROGRAM_UNDEFINED;
inst->SrcReg[1].Swizzle = SWIZZLE_NOOP;
inst->SrcReg[2].File = PROGRAM_UNDEFINED;
inst->SrcReg[2].Swizzle = SWIZZLE_NOOP;
+
inst->DstReg.File = PROGRAM_UNDEFINED;
inst->DstReg.WriteMask = WRITEMASK_XYZW;
+ inst->DstReg.CondMask = COND_TR;
+ inst->DstReg.CondSwizzle = SWIZZLE_NOOP;
+
+ inst->Precision = FLOAT32;
}
-
diff --git a/src/mesa/shader/nvvertparse.h b/src/mesa/shader/nvvertparse.h
index 205885f45c..d78d9fa137 100644
--- a/src/mesa/shader/nvvertparse.h
+++ b/src/mesa/shader/nvvertparse.h
@@ -36,7 +36,7 @@ _mesa_parse_nv_vertex_program(GLcontext *ctx, GLenum target,
struct vertex_program *program);
extern void
-_mesa_print_nv_vertex_instruction(const struct vp_instruction *inst);
+_mesa_print_nv_vertex_instruction(const struct prog_instruction *inst);
extern void
_mesa_print_nv_vertex_program(const struct vertex_program *program);
diff --git a/src/mesa/shader/nvvertprog.h b/src/mesa/shader/nvvertprog.h
deleted file mode 100644
index 994a324f8f..0000000000
--- a/src/mesa/shader/nvvertprog.h
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
- * Mesa 3-D graphics library
- * Version: 6.3.1
- *
- * 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"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-
-/* Private vertex program types and constants only used by files
- * related to vertex programs.
- *
- * XXX TO-DO: Rename this file "vertprog.h" since it's not NV-specific.
- */
-
-
-#ifndef NVVERTPROG_H
-#define NVVERTPROG_H
-
-
-/* Vertex program opcodes */
-enum vp_opcode
-{
- VP_OPCODE_ABS,
- VP_OPCODE_ADD,
- VP_OPCODE_ARL,
- VP_OPCODE_DP3,
- VP_OPCODE_DP4,
- VP_OPCODE_DPH,
- VP_OPCODE_DST,
- VP_OPCODE_END, /* Placeholder */
- VP_OPCODE_EX2, /* ARB only */
- VP_OPCODE_EXP,
- VP_OPCODE_FLR, /* ARB */
- VP_OPCODE_FRC, /* ARB */
- VP_OPCODE_LG2, /* ARB only */
- VP_OPCODE_LIT,
- VP_OPCODE_LOG,
- VP_OPCODE_MAD,
- VP_OPCODE_MAX,
- VP_OPCODE_MIN,
- VP_OPCODE_MOV,
- VP_OPCODE_MUL,
- VP_OPCODE_POW, /* ARB only */
- VP_OPCODE_PRINT, /* Mesa only */
- VP_OPCODE_RCC,
- VP_OPCODE_RCP,
- VP_OPCODE_RSQ,
- VP_OPCODE_SGE,
- VP_OPCODE_SLT,
- VP_OPCODE_SUB,
- VP_OPCODE_SWZ, /* ARB only */
- VP_OPCODE_XPD, /* ARB only */
-
- VP_MAX_OPCODE
-};
-
-
-
-/* Instruction source register */
-struct vp_src_register
-{
- GLuint File:4; /* one of the PROGRAM_* register file values */
- GLint Index:9; /* may be negative for relative addressing */
- GLuint Swizzle:12;
- GLuint Negate:4; /* ARB requires component-wise negation. */
- GLuint RelAddr:1;
- GLuint pad:2;
-};
-
-
-/* Instruction destination register */
-struct vp_dst_register
-{
- GLuint File:4; /* one of the PROGRAM_* register file values */
- GLuint Index:8;
- GLuint WriteMask:4;
- GLuint pad:16;
-};
-
-
-/* Vertex program instruction */
-struct vp_instruction
-{
- GLshort Opcode;
-#if FEATURE_MESA_program_debug
- GLshort StringPos;
-#endif
- void *Data; /* some arbitrary data, only used for PRINT instruction now */
- struct vp_src_register SrcReg[3];
- struct vp_dst_register DstReg;
-};
-
-
-extern void
-_mesa_init_vp_instruction(struct vp_instruction *inst);
-
-
-#endif /* VERTPROG_H */
diff --git a/src/mesa/shader/program.c b/src/mesa/shader/program.c
index b4ac8f51d4..4b8817876d 100644
--- a/src/mesa/shader/program.c
+++ b/src/mesa/shader/program.c
@@ -37,9 +37,8 @@
#include "mtypes.h"
#include "program.h"
#include "nvfragparse.h"
-#include "nvfragprog.h"
+#include "program_instruction.h"
#include "nvvertparse.h"
-#include "nvvertprog.h"
#include "atifragshader.h"
diff --git a/src/mesa/shader/program_instruction.h b/src/mesa/shader/program_instruction.h
new file mode 100644
index 0000000000..80dbd16a90
--- /dev/null
+++ b/src/mesa/shader/program_instruction.h
@@ -0,0 +1,344 @@
+/*
+ * Mesa 3-D graphics library
+ * Version: 6.5
+ *
+ * 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"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+/**
+ * \file prog_instruction.h
+ *
+ * Private vertex program types and constants only used by files
+ * related to vertex programs.
+ *
+ * \author Brian Paul
+ * \author Keith Whitwell
+ * \author Ian Romanick <idr@us.ibm.com>
+ */
+
+
+#ifndef PROG_INSTRUCTION_H
+#define PROG_INSTRUCTION_H
+
+/**
+ * Condition codes for GL_NV_fragment_program
+ */
+/*@{*/
+#define COND_GT 1 /* greater than zero */
+#define COND_EQ 2 /* equal to zero */
+#define COND_LT 3 /* less than zero */
+#define COND_UN 4 /* unordered (NaN) */
+#define COND_GE 5 /* greater then or equal to zero */
+#define COND_LE 6 /* less then or equal to zero */
+#define COND_NE 7 /* not equal to zero */
+#define COND_TR 8 /* always true */
+#define COND_FL 9 /* always false */
+/*@}*/
+
+
+/*
+ * Instruction precision for GL_NV_fragment_program
+ */
+/*@{*/
+#define FLOAT32 0x1
+#define FLOAT16 0x2
+#define FIXED12 0x4
+/*@}*/
+
+
+/**
+ * Program instruction opcodes, for both vertex and fragment programs.
+ * \note changes to this opcode list must be reflected in t_vb_arbprogram.c
+ */
+ /* ARB_vp ARB_fp NV_vp NV_fp */
+enum prog_opcode { /*---------------------------------*/
+ OPCODE_ABS, /* X 1.1 */
+ OPCODE_ADD, /* X X X X */
+ OPCODE_ARL, /* X X */
+ OPCODE_CMP, /* X */
+ OPCODE_COS, /* X 2 */
+ OPCODE_DDX, /* X */
+ OPCODE_DDY, /* X */
+ OPCODE_DP3, /* X X X X */
+ OPCODE_DP4, /* X X X X */
+ OPCODE_DPH, /* X X 1.1 */
+ OPCODE_DST, /* X X X */
+ OPCODE_END, /* X X X X */
+ OPCODE_EX2, /* X X 2 X */
+ OPCODE_EXP, /* X X */
+ OPCODE_FLR, /* X X 2 X */
+ OPCODE_FRC, /* X X 2 X */
+ OPCODE_KIL, /* X */
+ OPCODE_KIL_NV, /* X */
+ OPCODE_LG2, /* X X 2 X */
+ OPCODE_LIT, /* X X X X */
+ OPCODE_LOG, /* X X X */
+ OPCODE_LRP, /* X X */
+ OPCODE_MAD, /* X X X X */
+ OPCODE_MAX, /* X X X X */
+ OPCODE_MIN, /* X X X X */
+ OPCODE_MOV, /* X X X X */
+ OPCODE_MUL, /* X X X X */
+ OPCODE_PK2H, /* X */
+ OPCODE_PK2US, /* X */
+ OPCODE_PK4B, /* X */
+ OPCODE_PK4UB, /* X */
+ OPCODE_POW, /* X X X */
+ OPCODE_PRINT, /* X X */
+ OPCODE_RCC, /* 1.1 */
+ OPCODE_RCP, /* X X X X */
+ OPCODE_RFL, /* X X */
+ OPCODE_RSQ, /* X X X X */
+ OPCODE_SCS, /* X */
+ OPCODE_SEQ, /* 2 X */
+ OPCODE_SFL, /* 2 X */
+ OPCODE_SGE, /* X X X X */
+ OPCODE_SGT, /* 2 X */
+ OPCODE_SIN, /* X 2 X */
+ OPCODE_SLE, /* 2 X */
+ OPCODE_SLT, /* X X X X */
+ OPCODE_SNE, /* 2 X */
+ OPCODE_STR, /* X 2 X */
+ OPCODE_SUB, /* X X 1.1 X */
+ OPCODE_SWZ, /* X X */
+ OPCODE_TEX, /* X X */
+ OPCODE_TXB, /* X */
+ OPCODE_TXD, /* X X */
+ OPCODE_TXP, /* X */
+ OPCODE_TXP_NV, /* X */
+ OPCODE_UP2H, /* X */
+ OPCODE_UP2US, /* X */
+ OPCODE_UP4B, /* X */
+ OPCODE_UP4UB, /* X */
+ OPCODE_X2D, /* X */
+ OPCODE_XPD, /* X X */
+#if 0
+ OPCODE_ARA, /* NV_vertex_program2 */
+ OPCODE_ARL_NV, /* NV_vertex_program2 */
+ OPCODE_ARR, /* NV_vertex_program2 */
+
+ OPCODE_SEQ, /* NV_vertex_program2 */
+ OPCODE_SFL, /* NV_vertex_program2 */
+ OPCODE_SGT, /* NV_vertex_program2 */
+ OPCODE_SLE, /* NV_vertex_program2 */
+ OPCODE_SNE, /* NV_vertex_program2 */
+ OPCODE_STR, /* NV_vertex_program2 */
+
+ OPCODE_SSG, /* NV_vertex_program2 */
+ OPCODE_COS, /* NV_vertex_program2 */
+ OPCODE_SIN, /* NV_vertex_program2 */
+
+ OPCODE_BRA, /* NV_vertex_program2 */
+ OPCODE_CAL, /* NV_vertex_program2 */
+ OPCODE_RET, /* NV_vertex_program2 */
+
+ OPCODE_PUSHA, /* NV_vertex_program3 */
+ OPCODE_POPA, /* NV_vertex_program3 */
+
+ OPCODE_TEX, /* NV_vertex_program3 */
+ OPCODE_TXB, /* NV_vertex_program3 */
+ OPCODE_TXL, /* NV_vertex_program3 */
+ OPCODE_TXP, /* NV_vertex_program3 */
+#endif
+ MAX_OPCODE
+};
+
+
+/**
+ * Instruction source register.
+ */
+struct prog_src_register
+{
+ GLuint File:4; /**< One of the PROGRAM_* register file values. */
+ GLint Index:9; /**< May be negative for relative addressing. */
+ GLuint Swizzle:12;
+ GLuint RelAddr:1;
+
+ /**
+ * \name Source register "sign" control.
+ *
+ * The ARB and NV extensions allow varrying degrees of control over the
+ * sign of the source vector components. These values allow enough control
+ * for all flavors of the extensions.
+ */
+ /*@{*/
+ /**
+ * Per-component negation for the SWZ instruction.
+ *
+ * \since
+ * ARB_vertex_program, ARB_fragment_program
+ */
+ GLuint NegateBase:4;
+
+ /**
+ * Take the component-wise absolute value.
+ *
+ * \since
+ * NV_fragment_program, NV_fragment_program_option, NV_vertex_program2,
+ * NV_vertex_program2_option.
+ */
+ GLuint Abs:1;
+
+ /**
+ * Take the component-wise negation. The negation occurs \b after the
+ * (optional) absolute value operation.
+ */
+ GLuint NegateAbs:1;
+ /*@}*/
+};
+
+
+/**
+ * Instruction destination register.
+ */
+struct prog_dst_register
+{
+ /**
+ * One of the PROGRAM_* register file values.
+ */
+ GLuint File:4;
+
+ GLuint Index:8;
+ GLuint WriteMask:4;
+
+ /**
+ * \name Conditional destination update control.
+ *
+ * \since
+ * NV_fragment_program, NV_fragment_program_option, NV_vertex_program2,
+ * NV_vertex_program2_option.
+ */
+ /*@{*/
+ /**
+ * Takes one of the 9 possible condition values (EQ, FL, GT, GE, LE, LT,
+ * NE, TR, or UN). Destination update is enabled if the matching
+ * (swizzled) condition code value passes. When a conditional update mask
+ * is not specified, this will be \c COND_TR.
+ */
+ GLuint CondMask:4;
+
+ /**
+ * Condition code swizzle value.
+ */
+ GLuint CondSwizzle:12;
+
+ /**
+ * Selects the condition code register to use for conditional destination
+ * update masking. In NV_fragmnet_program or NV_vertex_program2 mode, only
+ * condition code register 0 is available. In NV_vertex_program3 mode,
+ * condition code registers 0 and 1 are available.
+ */
+ GLuint CondSrc:1;
+ /*@}*/
+
+ GLuint pad:31;
+};
+
+
+/**
+ * Vertex/fragment program instruction.
+ */
+struct prog_instruction
+{
+ enum prog_opcode Opcode;
+#if FEATURE_MESA_program_debug
+ GLshort StringPos;
+#endif
+ /**
+ * Arbitrary data. Used for the PRINT, CAL, and BRA instructions.
+ */
+ void *Data;
+
+ struct prog_src_register SrcReg[3];
+ struct prog_dst_register DstReg;
+
+ /**
+ * Indicates that the instruction should update the condition code
+ * register.
+ *
+ * \since
+ * NV_fragment_program, NV_fragment_program_option, NV_vertex_program2,
+ * NV_vertex_program2_option.
+ */
+ GLuint CondUpdate:1;
+
+ /**
+ * If prog_instruction::cc_update is \c GL_TRUE, this value selects the
+ * condition code register that is to be updated.
+ *
+ * In GL_NV_fragment_program or GL_NV_vertex_program2 mode, only condition
+ * code register 0 is available. In GL_NV_vertex_program3 mode, condition code registers
+ * 0 and 1 are available.
+ *
+ * \since
+ * NV_fragment_program, NV_fragment_program_option, NV_vertex_program2,
+ * NV_vertex_program2_option.
+ */
+ GLuint CondDst:1;
+
+ /**
+ * Saturate each value of the vectored result to the range [0,1] or the
+ * range [-1,1]. \c SSAT mode (i.e., saturation to the range [-1,1]) is
+ * only available in NV_fragment_program2 mode.
+ *
+ * \since
+ * NV_fragment_program, NV_fragment_program_option, NV_vertex_program3.
+ */
+ GLuint Saturate:2;
+
+ /**
+ * Per-instruction selectable precision.
+ *
+ * \since
+ * NV_fragment_program, NV_fragment_program_option.
+ */
+ GLuint Precision:3;
+
+ /**
+ * \name Texture source controls.
+ *
+ * The texture source controls are only used with the \c TEX, \c TXD,
+ * \c TXL, and \c TXP instructions.
+ *
+ * \since
+ * ARB_fragment_program, NV_fragment_program, NV_vertex_program3.
+ */
+ /*@{*/
+ /**
+ * Source texture unit. OpenGL supports a maximum of 32 texture
+ * units.
+ */
+ GLuint TexSrcUnit:5;
+
+ /**
+ * Source texture target (e.g., GL_TEXTURE_1D, GL_TEXTURE_2D,
+ * GL_TEXTURE_3D, GL_TEXTURE_CUBE, GL_TEXTURE_RECTANGLE_ARB).
+ */
+ GLuint TexSrcTarget:3;
+ /*@}*/
+};
+
+
+extern void
+_mesa_init_instruction(struct prog_instruction *inst);
+
+
+#endif /* PROG_INSTRUCTION_H */
diff --git a/src/mesa/swrast/s_fragprog_to_c.c b/src/mesa/swrast/s_fragprog_to_c.c
index e94c4c78a6..dfd02dcd54 100644
--- a/src/mesa/swrast/s_fragprog_to_c.c
+++ b/src/mesa/swrast/s_fragprog_to_c.c
@@ -30,7 +30,7 @@
#include "glheader.h"
#include "colormac.h"
#include "context.h"
-#include "nvfragprog.h"
+#include "program_instruction.h"
#include "macros.h"
#include "program.h"
@@ -179,7 +179,7 @@ static INLINE void emit_char( struct fragment_program *p, char c )
* Retrieve a ureg for the given source register. Will emit
* constants, apply swizzling and negation as needed.
*/
-static GLuint src_vector( const struct fp_src_register *source )
+static GLuint src_vector( const struct prog_src_register *source )
{
GLuint src;
@@ -262,7 +262,7 @@ static void print_footer( struct fragment_program *p )
}
static void print_dest_reg( struct fragment_program *p,
- const struct fp_instruction *inst )
+ const struct prog_instruction *inst )
{
switch (inst->DstReg.File) {
case PROGRAM_OUTPUT:
@@ -277,7 +277,7 @@ static void print_dest_reg( struct fragment_program *p,
}
static void print_dest( struct fragment_program *p,
- const struct fp_instruction *inst,
+ const struct prog_instruction *inst,
GLuint idx )
{
print_dest_reg(p, inst);
@@ -369,7 +369,7 @@ static void print_expression( struct fragment_program *p,
}
static void do_tex_kill( struct fragment_program *p,
- const struct fp_instruction *inst,
+ const struct prog_instruction *inst,
GLuint arg )
{
GLuint i;
@@ -389,7 +389,7 @@ static void do_tex_kill( struct fragment_program *p,
}
static void do_tex_simple( struct fragment_program *p,
- const struct fp_instruction *inst,
+ const struct prog_instruction *inst,
const char *fn, GLuint texunit, GLuint arg )
{
emit(p, " %s( ctx, ", fn);
@@ -401,7 +401,7 @@ static void do_tex_simple( struct fragment_program *p,
static void do_tex( struct fragment_program *p,
- const struct fp_instruction *inst,
+ const struct prog_instruction *inst,
const char *fn, GLuint texunit, GLuint arg )
{
GLuint i;
@@ -444,7 +444,7 @@ static void do_tex( struct fragment_program *p,
static void saturate( struct fragment_program *p,
- const struct fp_instruction *inst,
+ const struct prog_instruction *inst,
GLuint i )
{
emit(p, " ");
@@ -456,7 +456,7 @@ static void saturate( struct fragment_program *p,
static void assign_single( GLuint i,
struct fragment_program *p,
- const struct fp_instruction *inst,
+ const struct prog_instruction *inst,
const char *fmt,
... )
{
@@ -476,7 +476,7 @@ static void assign_single( GLuint i,
}
static void assign4( struct fragment_program *p,
- const struct fp_instruction *inst,
+ const struct prog_instruction *inst,
const char *fmt,
... )
{
@@ -498,7 +498,7 @@ static void assign4( struct fragment_program *p,
}
static void assign4_replicate( struct fragment_program *p,
- const struct fp_instruction *inst,
+ const struct prog_instruction *inst,
const char *fmt,
... )
{
@@ -537,44 +537,45 @@ static void assign4_replicate( struct fragment_program *p,
}
-
-
+/**
+ * XXX This should go away.
+ */
static GLuint nr_args( GLuint opcode )
{
switch (opcode) {
- case FP_OPCODE_ABS: return 1;
- case FP_OPCODE_ADD: return 2;
- case FP_OPCODE_CMP: return 3;
- case FP_OPCODE_COS: return 1;
- case FP_OPCODE_DP3: return 2;
- case FP_OPCODE_DP4: return 2;
- case FP_OPCODE_DPH: return 2;
- case FP_OPCODE_DST: return 2;
- case FP_OPCODE_EX2: return 1;
- case FP_OPCODE_FLR: return 1;
- case FP_OPCODE_FRC: return 1;
- case FP_OPCODE_KIL: return 1;
- case FP_OPCODE_LG2: return 1;
- case FP_OPCODE_LIT: return 1;
- case FP_OPCODE_LRP: return 3;
- case FP_OPCODE_MAD: return 3;
- case FP_OPCODE_MAX: return 2;
- case FP_OPCODE_MIN: return 2;
- case FP_OPCODE_MOV: return 1;
- case FP_OPCODE_MUL: return 2;
- case FP_OPCODE_POW: return 2;
- case FP_OPCODE_RCP: return 1;
- case FP_OPCODE_RSQ: return 1;
- case FP_OPCODE_SCS: return 1;
- case FP_OPCODE_SGE: return 2;
- case FP_OPCODE_SIN: return 1;
- case FP_OPCODE_SLT: return 2;
- case FP_OPCODE_SUB: return 2;
- case FP_OPCODE_SWZ: return 1;
- case FP_OPCODE_TEX: return 1;
- case FP_OPCODE_TXB: return 1;
- case FP_OPCODE_TXP: return 1;
- case FP_OPCODE_XPD: return 2;
+ case OPCODE_ABS: return 1;
+ case OPCODE_ADD: return 2;
+ case OPCODE_CMP: return 3;
+ case OPCODE_COS: return 1;
+ case OPCODE_DP3: return 2;
+ case OPCODE_DP4: return 2;
+ case OPCODE_DPH: return 2;
+ case OPCODE_DST: return 2;
+ case OPCODE_EX2: return 1;
+ case OPCODE_FLR: return 1;
+ case OPCODE_FRC: return 1;
+ case OPCODE_KIL: return 1;
+ case OPCODE_LG2: return 1;
+ case OPCODE_LIT: return 1;
+ case OPCODE_LRP: return 3;
+ case OPCODE_MAD: return 3;
+ case OPCODE_MAX: return 2;
+ case OPCODE_MIN: return 2;
+ case OPCODE_MOV: return 1;
+ case OPCODE_MUL: return 2;
+ case OPCODE_POW: return 2;
+ case OPCODE_RCP: return 1;
+ case OPCODE_RSQ: return 1;
+ case OPCODE_SCS: return 1;
+ case OPCODE_SGE: return 2;
+ case OPCODE_SIN: return 1;
+ case OPCODE_SLT: return 2;
+ case OPCODE_SUB: return 2;
+ case OPCODE_SWZ: return 1;
+ case OPCODE_TEX: return 1;
+ case OPCODE_TXB: return 1;
+ case OPCODE_TXP: return 1;
+ case OPCODE_XPD: return 2;
default: return 0;
}
}
@@ -583,9 +584,9 @@ static GLuint nr_args( GLuint opcode )
static void translate_program( struct fragment_program *p )
{
- const struct fp_instruction *inst = p->Instructions;
+ const struct prog_instruction *inst = p->Instructions;
- for (; inst->Opcode != FP_OPCODE_END; inst++) {
+ for (; inst->Opcode != OPCODE_END; inst++) {
GLuint src[3], i;
GLuint nr = nr_args( inst->Opcode );
@@ -606,23 +607,23 @@ static void translate_program( struct fragment_program *p )
}
switch (inst->Opcode) {
- case FP_OPCODE_ABS:
+ case OPCODE_ABS:
assign4(p, inst, "fabsf(%s)", src[0]);
break;
- case FP_OPCODE_ADD:
+ case OPCODE_ADD:
assign4(p, inst, "%s + %s", src[0], src[1]);
break;
- case FP_OPCODE_CMP:
+ case OPCODE_CMP:
assign4(p, inst, "%s < 0.0F ? %s : %s", src[0], src[1], src[2]);
break;
- case FP_OPCODE_COS:
+ case OPCODE_COS:
assign4_replicate(p, inst, "COS(%s)", src[0]);
break;
- case FP_OPCODE_DP3:
+ case OPCODE_DP3:
assign4_replicate(p, inst,
"%s*%s + %s*%s + %s*%s",
deref(src[0],_X),
@@ -633,7 +634,7 @@ static void translate_program( struct fragment_program *p )
deref(src[1],_Z));
break;
- case FP_OPCODE_DP4:
+ case OPCODE_DP4:
assign4_replicate(p, inst,
"%s*%s + %s*%s + %s*%s + %s*%s",
deref(src[0],_X),
@@ -644,7 +645,7 @@ static void translate_program( struct fragment_program *p )
deref(src[1],_Z));
break;
- case FP_OPCODE_DPH:
+ case OPCODE_DPH:
assign4_replicate(p, inst,
"%s*%s + %s*%s + %s*%s + %s",
deref(src[0],_X),
@@ -654,7 +655,7 @@ static void translate_program( struct fragment_program *p )
deref(src[1],_Z));
break;
- case FP_OPCODE_DST:
+ case OPCODE_DST:
/* result[0] = 1 * 1;
* result[1] = a[1] * b[1];
* result[2] = a[2] * 1;
@@ -669,27 +670,27 @@ static void translate_program( struct fragment_program *p )
assign_single(3, p, inst, "%s", deref(src[1], _W));
break;
- case FP_OPCODE_EX2:
+ case OPCODE_EX2:
assign4_replicate(p, inst, "powf(2.0, %s)", src[0]);
break;
- case FP_OPCODE_FLR:
+ case OPCODE_FLR:
assign4_replicate(p, inst, "floorf(%s)", src[0]);
break;
- case FP_OPCODE_FRC:
+ case OPCODE_FRC:
assign4_replicate(p, inst, "%s - floorf(%s)", src[0], src[0]);
break;
- case FP_OPCODE_KIL:
+ case OPCODE_KIL:
do_tex_kill(p, inst, src[0]);
break;
- case FP_OPCODE_LG2:
+ case OPCODE_LG2:
assign4_replicate(p, inst, "LOG2(%s)", src[0]);
break;
- case FP_OPCODE_LIT:
+ case OPCODE_LIT:
assign_single(0, p, inst, "1.0");
assign_single(1, p, inst, "MIN2(%s, 0)", deref(src[0], _X));
assign_single(2, p, inst, "(%s > 0.0) ? expf(%s * MIN2(%s, 0)) : 0.0",
@@ -699,45 +700,45 @@ static void translate_program( struct fragment_program *p )
assign_single(3, p, inst, "1.0");
break;
- case FP_OPCODE_LRP:
+ case OPCODE_LRP:
assign4(p, inst,
"%s * %s + (1.0 - %s) * %s",
src[0], src[1], src[0], src[2]);
break;
- case FP_OPCODE_MAD:
+ case OPCODE_MAD:
assign4(p, inst, "%s * %s + %s", src[0], src[1], src[2]);
break;
- case FP_OPCODE_MAX:
+ case OPCODE_MAX:
assign4(p, inst, "MAX2(%s, %s)", src[0], src[1]);
break;
- case FP_OPCODE_MIN:
+ case OPCODE_MIN:
assign4(p, inst, "MIN2(%s, %s)", src[0], src[1]);
break;
- case FP_OPCODE_MOV:
+ case OPCODE_MOV:
assign4(p, inst, "%s", src[0]);
break;
- case FP_OPCODE_MUL:
+ case OPCODE_MUL:
assign4(p, inst, "%s * %s", src[0], src[1]);
break;
- case FP_OPCODE_POW:
+ case OPCODE_POW:
assign4_replicate(p, inst, "powf(%s, %s)", src[0], src[1]);
break;
- case FP_OPCODE_RCP:
+ case OPCODE_RCP:
assign4_replicate(p, inst, "1.0/%s", src[0]);
break;
- case FP_OPCODE_RSQ:
+ case OPCODE_RSQ:
assign4_replicate(p, inst, "_mesa_inv_sqrtf(%s)", src[0]);
break;
- case FP_OPCODE_SCS:
+ case OPCODE_SCS:
if (inst->DstReg.WriteMask[0]) {
assign_single(0, p, inst, "cosf(%s)", deref(src[0], _X));
}
@@ -747,39 +748,39 @@ static void translate_program( struct fragment_program *p )
}
break;
- case FP_OPCODE_SGE:
+ case OPCODE_SGE:
assign4(p, inst, "%s >= %s ? 1.0 : 0.0", src[0], src[1]);
break;
- case FP_OPCODE_SIN:
+ case OPCODE_SIN:
assign4_replicate(p, inst, "sinf(%s)", src[0]);
break;
- case FP_OPCODE_SLT:
+ case OPCODE_SLT:
assign4(p, inst, "%s < %s ? 1.0 : 0.0", src[0], src[1]);
break;
- case FP_OPCODE_SUB:
+ case OPCODE_SUB:
assign4(p, inst, "%s - %s", src[0], src[1]);
break;
- case FP_OPCODE_SWZ: /* same implementation as MOV: */
+ case OPCODE_SWZ: /* same implementation as MOV: */
assign4(p, inst, "%s", src[0]);
break;
- case FP_OPCODE_TEX:
+ case OPCODE_TEX:
do_tex(p, inst, "TEX", inst->TexSrcUnit, src[0]);
break;
- case FP_OPCODE_TXB:
+ case OPCODE_TXB:
do_tex(p, inst, "TXB", inst->TexSrcUnit, src[0]);
break;
- case FP_OPCODE_TXP:
+ case OPCODE_TXP:
do_tex(p, inst, "TXP", inst->TexSrcUnit, src[0]);
break;
- case FP_OPCODE_XPD:
+ case OPCODE_XPD:
/* Cross product:
* result.x = src[0].y * src[1].z - src[0].z * src[1].y;
* result.y = src[0].z * src[1].x - src[0].x * src[1].z;
diff --git a/src/mesa/swrast/s_nvfragprog.c b/src/mesa/swrast/s_nvfragprog.c
index cae0e49cc3..94224bc1d3 100644
--- a/src/mesa/swrast/s_nvfragprog.c
+++ b/src/mesa/swrast/s_nvfragprog.c
@@ -34,7 +34,7 @@
#include "glheader.h"
#include "colormac.h"
#include "context.h"
-#include "nvfragprog.h"
+#include "program_instruction.h"
#include "program.h"
#include "s_nvfragprog.h"
@@ -104,7 +104,7 @@ fetch_texel_deriv( GLcontext *ctx, const GLfloat texcoord[4],
*/
static INLINE const GLfloat *
get_register_pointer( GLcontext *ctx,
- const struct fp_src_register *source,
+ const struct prog_src_register *source,
const struct fp_machine *machine,
const struct fragment_program *program )
{
@@ -151,7 +151,7 @@ get_register_pointer( GLcontext *ctx,
*/
static void
fetch_vector4( GLcontext *ctx,
- const struct fp_src_register *source,
+ const struct prog_src_register *source,
const struct fp_machine *machine,
const struct fragment_program *program,
GLfloat result[4] )
@@ -192,7 +192,7 @@ fetch_vector4( GLcontext *ctx,
*/
static GLboolean
fetch_vector4_deriv( GLcontext *ctx,
- const struct fp_src_register *source,
+ const struct prog_src_register *source,
const struct sw_span *span,
char xOrY, GLint column, GLfloat result[4] )
{
@@ -321,7 +321,7 @@ fetch_vector4_deriv( GLcontext *ctx,
*/
static void
fetch_vector1( GLcontext *ctx,
- const struct fp_src_register *source,
+ const struct prog_src_register *source,
const struct fp_machine *machine,
const struct fragment_program *program,
GLfloat result[4] )
@@ -385,13 +385,13 @@ test_cc(GLuint condCode, GLuint ccMaskRule)
* set-condition-code flags.
*/
static void
-store_vector4( const struct fp_instruction *inst,
+store_vector4( const struct prog_instruction *inst,
struct fp_machine *machine,
const GLfloat value[4] )
{
- const struct fp_dst_register *dest = &(inst->DstReg);
+ const struct prog_dst_register *dest = &(inst->DstReg);
const GLboolean clamp = inst->Saturate;
- const GLboolean updateCC = inst->UpdateCondRegister;
+ const GLboolean updateCC = inst->CondUpdate;
GLfloat *dstReg;
GLfloat dummyReg[4];
GLfloat clampedValue[4];
@@ -599,7 +599,7 @@ execute_program( GLcontext *ctx,
#endif
for (pc = 0; pc < maxInst; pc++) {
- const struct fp_instruction *inst = program->Instructions + pc;
+ const struct prog_instruction *inst = program->Instructions + pc;
if (ctx->FragmentProgram.CallbackEnabled &&
ctx->FragmentProgram.Callback) {
@@ -609,7 +609,7 @@ execute_program( GLcontext *ctx,
}
switch (inst->Opcode) {
- case FP_OPCODE_ABS:
+ case OPCODE_ABS:
{
GLfloat a[4], result[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, a );
@@ -620,7 +620,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_ADD:
+ case OPCODE_ADD:
{
GLfloat a[4], b[4], result[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, a );
@@ -632,7 +632,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_CMP:
+ case OPCODE_CMP:
{
GLfloat a[4], b[4], c[4], result[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, a );
@@ -645,7 +645,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_COS:
+ case OPCODE_COS:
{
GLfloat a[4], result[4];
fetch_vector1( ctx, &inst->SrcReg[0], machine, program, a );
@@ -653,7 +653,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_DDX: /* Partial derivative with respect to X */
+ case OPCODE_DDX: /* Partial derivative with respect to X */
{
GLfloat a[4], aNext[4], result[4];
struct fp_machine dMachine;
@@ -679,7 +679,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_DDY: /* Partial derivative with respect to Y */
+ case OPCODE_DDY: /* Partial derivative with respect to Y */
{
GLfloat a[4], aNext[4], result[4];
struct fp_machine dMachine;
@@ -698,7 +698,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_DP3:
+ case OPCODE_DP3:
{
GLfloat a[4], b[4], result[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, a );
@@ -712,7 +712,7 @@ execute_program( GLcontext *ctx,
#endif
}
break;
- case FP_OPCODE_DP4:
+ case OPCODE_DP4:
{
GLfloat a[4], b[4], result[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, a );
@@ -726,7 +726,7 @@ execute_program( GLcontext *ctx,
#endif
}
break;
- case FP_OPCODE_DPH:
+ case OPCODE_DPH:
{
GLfloat a[4], b[4], result[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, a );
@@ -736,7 +736,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_DST: /* Distance vector */
+ case OPCODE_DST: /* Distance vector */
{
GLfloat a[4], b[4], result[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, a );
@@ -748,7 +748,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_EX2: /* Exponential base 2 */
+ case OPCODE_EX2: /* Exponential base 2 */
{
GLfloat a[4], result[4];
fetch_vector1( ctx, &inst->SrcReg[0], machine, program, a );
@@ -757,7 +757,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_FLR:
+ case OPCODE_FLR:
{
GLfloat a[4], result[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, a );
@@ -768,7 +768,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_FRC:
+ case OPCODE_FRC:
{
GLfloat a[4], result[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, a );
@@ -779,7 +779,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_KIL_NV: /* NV_f_p only */
+ case OPCODE_KIL_NV: /* NV_f_p only */
{
const GLuint swizzle = inst->DstReg.CondSwizzle;
const GLuint condMask = inst->DstReg.CondMask;
@@ -791,7 +791,7 @@ execute_program( GLcontext *ctx,
}
}
break;
- case FP_OPCODE_KIL: /* ARB_f_p only */
+ case OPCODE_KIL: /* ARB_f_p only */
{
GLfloat a[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, a );
@@ -800,7 +800,7 @@ execute_program( GLcontext *ctx,
}
}
break;
- case FP_OPCODE_LG2: /* log base 2 */
+ case OPCODE_LG2: /* log base 2 */
{
GLfloat a[4], result[4];
fetch_vector1( ctx, &inst->SrcReg[0], machine, program, a );
@@ -809,7 +809,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_LIT:
+ case OPCODE_LIT:
{
const GLfloat epsilon = 1.0F / 256.0F; /* from NV VP spec */
GLfloat a[4], result[4];
@@ -834,7 +834,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_LRP:
+ case OPCODE_LRP:
{
GLfloat a[4], b[4], c[4], result[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, a );
@@ -847,7 +847,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_MAD:
+ case OPCODE_MAD:
{
GLfloat a[4], b[4], c[4], result[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, a );
@@ -860,7 +860,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_MAX:
+ case OPCODE_MAX:
{
GLfloat a[4], b[4], result[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, a );
@@ -878,7 +878,7 @@ execute_program( GLcontext *ctx,
#endif
}
break;
- case FP_OPCODE_MIN:
+ case OPCODE_MIN:
{
GLfloat a[4], b[4], result[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, a );
@@ -890,7 +890,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_MOV:
+ case OPCODE_MOV:
{
GLfloat result[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, result );
@@ -901,7 +901,7 @@ execute_program( GLcontext *ctx,
#endif
}
break;
- case FP_OPCODE_MUL:
+ case OPCODE_MUL:
{
GLfloat a[4], b[4], result[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, a );
@@ -919,7 +919,7 @@ execute_program( GLcontext *ctx,
#endif
}
break;
- case FP_OPCODE_PK2H: /* pack two 16-bit floats in one 32-bit float */
+ case OPCODE_PK2H: /* pack two 16-bit floats in one 32-bit float */
{
GLfloat a[4], result[4];
GLhalfNV hx, hy;
@@ -934,7 +934,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_PK2US: /* pack two GLushorts into one 32-bit float */
+ case OPCODE_PK2US: /* pack two GLushorts into one 32-bit float */
{
GLfloat a[4], result[4];
GLuint usx, usy, *rawResult = (GLuint *) result;
@@ -948,7 +948,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_PK4B: /* pack four GLbytes into one 32-bit float */
+ case OPCODE_PK4B: /* pack four GLbytes into one 32-bit float */
{
GLfloat a[4], result[4];
GLuint ubx, uby, ubz, ubw, *rawResult = (GLuint *) result;
@@ -966,7 +966,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_PK4UB: /* pack four GLubytes into one 32-bit float */
+ case OPCODE_PK4UB: /* pack four GLubytes into one 32-bit float */
{
GLfloat a[4], result[4];
GLuint ubx, uby, ubz, ubw, *rawResult = (GLuint *) result;
@@ -984,7 +984,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_POW:
+ case OPCODE_POW:
{
GLfloat a[4], b[4], result[4];
fetch_vector1( ctx, &inst->SrcReg[0], machine, program, a );
@@ -994,7 +994,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_RCP:
+ case OPCODE_RCP:
{
GLfloat a[4], result[4];
fetch_vector1( ctx, &inst->SrcReg[0], machine, program, a );
@@ -1009,7 +1009,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_RFL:
+ case OPCODE_RFL:
{
GLfloat axis[4], dir[4], result[4], tmp[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, axis );
@@ -1027,7 +1027,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_RSQ: /* 1 / sqrt() */
+ case OPCODE_RSQ: /* 1 / sqrt() */
{
GLfloat a[4], result[4];
fetch_vector1( ctx, &inst->SrcReg[0], machine, program, a );
@@ -1039,7 +1039,7 @@ execute_program( GLcontext *ctx,
#endif
}
break;
- case FP_OPCODE_SCS: /* sine and cos */
+ case OPCODE_SCS: /* sine and cos */
{
GLfloat a[4], result[4];
fetch_vector1( ctx, &inst->SrcReg[0], machine, program, a );
@@ -1050,7 +1050,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_SEQ: /* set on equal */
+ case OPCODE_SEQ: /* set on equal */
{
GLfloat a[4], b[4], result[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, a );
@@ -1062,13 +1062,13 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_SFL: /* set false, operands ignored */
+ case OPCODE_SFL: /* set false, operands ignored */
{
static const GLfloat result[4] = { 0.0F, 0.0F, 0.0F, 0.0F };
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_SGE: /* set on greater or equal */
+ case OPCODE_SGE: /* set on greater or equal */
{
GLfloat a[4], b[4], result[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, a );
@@ -1080,7 +1080,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_SGT: /* set on greater */
+ case OPCODE_SGT: /* set on greater */
{
GLfloat a[4], b[4], result[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, a );
@@ -1092,7 +1092,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_SIN:
+ case OPCODE_SIN:
{
GLfloat a[4], result[4];
fetch_vector1( ctx, &inst->SrcReg[0], machine, program, a );
@@ -1101,7 +1101,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_SLE: /* set on less or equal */
+ case OPCODE_SLE: /* set on less or equal */
{
GLfloat a[4], b[4], result[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, a );
@@ -1113,7 +1113,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_SLT: /* set on less */
+ case OPCODE_SLT: /* set on less */
{
GLfloat a[4], b[4], result[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, a );
@@ -1125,7 +1125,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_SNE: /* set on not equal */
+ case OPCODE_SNE: /* set on not equal */
{
GLfloat a[4], b[4], result[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, a );
@@ -1137,13 +1137,13 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_STR: /* set true, operands ignored */
+ case OPCODE_STR: /* set true, operands ignored */
{
static const GLfloat result[4] = { 1.0F, 1.0F, 1.0F, 1.0F };
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_SUB:
+ case OPCODE_SUB:
{
GLfloat a[4], b[4], result[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, a );
@@ -1155,9 +1155,9 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_SWZ:
+ case OPCODE_SWZ:
{
- const struct fp_src_register *source = &inst->SrcReg[0];
+ const struct prog_src_register *source = &inst->SrcReg[0];
const GLfloat *src = get_register_pointer(ctx, source,
machine, program);
GLfloat result[4];
@@ -1178,7 +1178,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_TEX: /* Both ARB and NV frag prog */
+ case OPCODE_TEX: /* Both ARB and NV frag prog */
/* Texel lookup */
{
GLfloat texcoord[4], color[4];
@@ -1206,7 +1206,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, color );
}
break;
- case FP_OPCODE_TXB: /* GL_ARB_fragment_program only */
+ case OPCODE_TXB: /* GL_ARB_fragment_program only */
/* Texel lookup with LOD bias */
{
GLfloat texcoord[4], color[4], bias, lambda;
@@ -1222,7 +1222,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, color );
}
break;
- case FP_OPCODE_TXD: /* GL_NV_fragment_program only */
+ case OPCODE_TXD: /* GL_NV_fragment_program only */
/* Texture lookup w/ partial derivatives for LOD */
{
GLfloat texcoord[4], dtdx[4], dtdy[4], color[4];
@@ -1234,7 +1234,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, color );
}
break;
- case FP_OPCODE_TXP: /* GL_ARB_fragment_program only */
+ case OPCODE_TXP: /* GL_ARB_fragment_program only */
/* Texture lookup w/ projective divide */
{
GLfloat texcoord[4], color[4];
@@ -1262,12 +1262,12 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, color );
}
break;
- case FP_OPCODE_TXP_NV: /* GL_NV_fragment_program only */
+ case OPCODE_TXP_NV: /* GL_NV_fragment_program only */
/* Texture lookup w/ projective divide */
{
GLfloat texcoord[4], color[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, texcoord );
- if (inst->TexSrcIdx != TEXTURE_CUBE_INDEX &&
+ if (inst->TexSrcTarget != TEXTURE_CUBE_INDEX &&
texcoord[3] != 0.0) {
texcoord[0] /= texcoord[3];
texcoord[1] /= texcoord[3];
@@ -1279,7 +1279,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, color );
}
break;
- case FP_OPCODE_UP2H: /* unpack two 16-bit floats */
+ case OPCODE_UP2H: /* unpack two 16-bit floats */
{
GLfloat a[4], result[4];
const GLuint *rawBits = (const GLuint *) a;
@@ -1292,7 +1292,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_UP2US: /* unpack two GLushorts */
+ case OPCODE_UP2US: /* unpack two GLushorts */
{
GLfloat a[4], result[4];
const GLuint *rawBits = (const GLuint *) a;
@@ -1305,7 +1305,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_UP4B: /* unpack four GLbytes */
+ case OPCODE_UP4B: /* unpack four GLbytes */
{
GLfloat a[4], result[4];
const GLuint *rawBits = (const GLuint *) a;
@@ -1317,7 +1317,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_UP4UB: /* unpack four GLubytes */
+ case OPCODE_UP4UB: /* unpack four GLubytes */
{
GLfloat a[4], result[4];
const GLuint *rawBits = (const GLuint *) a;
@@ -1329,7 +1329,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_XPD: /* cross product */
+ case OPCODE_XPD: /* cross product */
{
GLfloat a[4], b[4], result[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, a );
@@ -1341,7 +1341,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_X2D: /* 2-D matrix transform */
+ case OPCODE_X2D: /* 2-D matrix transform */
{
GLfloat a[4], b[4], c[4], result[4];
fetch_vector4( ctx, &inst->SrcReg[0], machine, program, a );
@@ -1354,7 +1354,7 @@ execute_program( GLcontext *ctx,
store_vector4( inst, machine, result );
}
break;
- case FP_OPCODE_PRINT:
+ case OPCODE_PRINT:
{
if (inst->SrcReg[0].File != -1) {
GLfloat a[4];
@@ -1367,7 +1367,7 @@ execute_program( GLcontext *ctx,
}
}
break;
- case FP_OPCODE_END:
+ case OPCODE_END:
return GL_TRUE;
default:
_mesa_problem(ctx, "Bad opcode %d in _mesa_exec_fragment_program",
diff --git a/src/mesa/swrast/s_tcc.c b/src/mesa/swrast/s_tcc.c
index e896d1fef5..9e6f4f26b7 100644
--- a/src/mesa/swrast/s_tcc.c
+++ b/src/mesa/swrast/s_tcc.c
@@ -33,7 +33,7 @@
#include "imports.h"
#include "colormac.h"
#include "context.h"
-#include "nvfragprog.h"
+#include "program_instruction.h"
#include "macros.h"
#include "program.h"
diff --git a/src/mesa/tnl/t_vb_arbprogram.c b/src/mesa/tnl/t_vb_arbprogram.c
index c6f7f7ff8f..8d024d9d66 100644
--- a/src/mesa/tnl/t_vb_arbprogram.c
+++ b/src/mesa/tnl/t_vb_arbprogram.c
@@ -614,15 +614,15 @@ static void print_NOP( union instruction op, const struct opcode_info *info )
{
}
-#define NOP 0
-#define ALU 1
-#define SWZ 2
-
-static const struct opcode_info opcode_info[] =
+static const struct opcode_info opcode_info[MAX_OPCODE + 3] =
{
{ 1, "ABS", print_ALU },
{ 2, "ADD", print_ALU },
{ 1, "ARL", print_NOP },
+ {-1, "CMP", NULL },
+ {-1, "COS", NULL },
+ {-1, "DDX", NULL },
+ {-1, "DDY", NULL },
{ 2, "DP3", print_ALU },
{ 2, "DP4", print_ALU },
{ 2, "DPH", print_ALU },
@@ -632,23 +632,49 @@ static const struct opcode_info opcode_info[] =
{ 1, "EXP", print_ALU },
{ 1, "FLR", print_ALU },
{ 1, "FRC", print_ALU },
+ {-1, "KIL", NULL },
+ {-1, "KIL_NV", NULL },
{ 1, "LG2", print_ALU },
{ 1, "LIT", print_ALU },
{ 1, "LOG", print_ALU },
+ {-1, "LRP", NULL },
{ 3, "MAD", print_NOP },
{ 2, "MAX", print_ALU },
{ 2, "MIN", print_ALU },
{ 1, "MOV", print_ALU },
{ 2, "MUL", print_ALU },
+ {-1, "PK2H", NULL },
+ {-1, "PK2US", NULL },
+ {-1, "PK4B", NULL },
+ {-1, "PK4UB", NULL },
{ 2, "POW", print_ALU },
{ 1, "PRT", print_ALU }, /* PRINT */
{ 1, "RCC", print_NOP },
{ 1, "RCP", print_ALU },
+ {-1, "RFL", NULL },
{ 1, "RSQ", print_ALU },
+ {-1, "SCS", NULL },
+ {-1, "SEQ", NULL },
+ {-1, "SFL", NULL },
{ 2, "SGE", print_ALU },
+ {-1, "SGT", NULL },
+ {-1, "SIN", NULL },
+ {-1, "SLE", NULL },
{ 2, "SLT", print_ALU },
+ {-1, "SNE", NULL },
+ {-1, "STR", NULL },
{ 2, "SUB", print_ALU },
{ 1, "SWZ", print_NOP },
+ {-1, "TEX", NULL },
+ {-1, "TXB", NULL },
+ {-1, "TXD", NULL },
+ {-1, "TXP", NULL },
+ {-1, "TXP_NV", NULL },
+ {-1, "UP2H", NULL },
+ {-1, "UP2US", NULL },
+ {-1, "UP4B", NULL },
+ {-1, "UP4UB", NULL },
+ {-1, "X2d", NULL },
{ 2, "XPD", print_ALU },
{ 1, "RSW", print_RSW },
{ 2, "MSK", print_MSK },
@@ -662,11 +688,15 @@ void _tnl_disassem_vba_insn( union instruction op )
}
-static void (* const opcode_func[])(struct arb_vp_machine *, union instruction) =
+static void (* const opcode_func[MAX_OPCODE+3])(struct arb_vp_machine *, union instruction) =
{
do_ABS,
do_ADD,
- do_NOP,
+ do_NOP,/*ARL*/
+ do_NOP,/*CMP*/
+ do_NOP,/*COS*/
+ do_NOP,/*DDX*/
+ do_NOP,/*DDY*/
do_DP3,
do_DP4,
do_DPH,
@@ -676,23 +706,49 @@ static void (* const opcode_func[])(struct arb_vp_machine *, union instruction)
do_EXP,
do_FLR,
do_FRC,
+ do_NOP,/*KIL*/
+ do_NOP,/*KIL_NV*/
do_LG2,
do_LIT,
do_LOG,
- do_NOP,
+ do_NOP,/*LRP*/
+ do_NOP,/*MAD*/
do_MAX,
do_MIN,
do_MOV,
do_MUL,
+ do_NOP,/*PK2H*/
+ do_NOP,/*PK2US*/
+ do_NOP,/*PK4B*/
+ do_NOP,/*PK4UB*/
do_POW,
do_PRT,
- do_NOP,
- do_RCP,
+ do_NOP,/*RCC*/
+ do_RCP,/*RCP*/
+ do_NOP,/*RFL*/
do_RSQ,
+ do_NOP,/*SCS*/
+ do_NOP,/*SEQ*/
+ do_NOP,/*SFL*/
do_SGE,
+ do_NOP,/*SGT*/
+ do_NOP,/*SIN*/
+ do_NOP,/*SLE*/
do_SLT,
+ do_NOP,/*SNE*/
+ do_NOP,/*STR*/
do_SUB,
- do_RSW,
+ do_RSW,/*SWZ*/
+ do_NOP,/*TEX*/
+ do_NOP,/*TXB*/
+ do_NOP,/*TXD*/
+ do_NOP,/*TXP*/
+ do_NOP,/*TXP_NV*/
+ do_NOP,/*UP2H*/
+ do_NOP,/*UP2US*/
+ do_NOP,/*UP4B*/
+ do_NOP,/*UP4UB*/
+ do_NOP,/*X2D*/
do_XPD,
do_RSW,
do_MSK,
@@ -774,13 +830,14 @@ static struct reg cvp_load_reg( struct compilation *cp,
case PROGRAM_WRITE_ONLY:
case PROGRAM_ADDRESS:
default:
+ _mesa_problem(NULL, "Invalid register file %d in cvp_load_reg()");
assert(0);
return tmpreg; /* can't happen */
}
}
static struct reg cvp_emit_arg( struct compilation *cp,
- const struct vp_src_register *src,
+ const struct prog_src_register *src,
GLuint arg )
{
struct reg reg = cvp_load_reg( cp, src->File, src->Index, src->RelAddr, arg );
@@ -789,7 +846,7 @@ static struct reg cvp_emit_arg( struct compilation *cp,
/* Emit any necessary swizzling.
*/
rsw.dword = 0;
- rsw.rsw.neg = src->Negate ? WRITEMASK_XYZW : 0;
+ rsw.rsw.neg = src->NegateBase ? WRITEMASK_XYZW : 0;
/* we're expecting 2-bit swizzles below... */
ASSERT(GET_SWZ(src->Swizzle, 0) < 4);
@@ -821,7 +878,7 @@ static struct reg cvp_emit_arg( struct compilation *cp,
}
static GLuint cvp_choose_result( struct compilation *cp,
- const struct vp_dst_register *dst,
+ const struct prog_dst_register *dst,
union instruction *fixup )
{
GLuint mask = dst->WriteMask;
@@ -884,7 +941,7 @@ static struct reg cvp_emit_rsw( struct compilation *cp,
/* Oops. Degenerate case:
*/
union instruction *op = cvp_next_instruction(cp);
- op->alu.opcode = VP_OPCODE_MOV;
+ op->alu.opcode = OPCODE_MOV;
op->alu.dst = dst;
op->alu.file0 = src.file;
op->alu.idx0 = src.idx;
@@ -900,7 +957,7 @@ static struct reg cvp_emit_rsw( struct compilation *cp,
static void cvp_emit_inst( struct compilation *cp,
- const struct vp_instruction *inst )
+ const struct prog_instruction *inst )
{
const struct opcode_info *info = &opcode_info[inst->Opcode];
union instruction *op;
@@ -915,13 +972,13 @@ static void cvp_emit_inst( struct compilation *cp,
switch (inst->Opcode) {
/* Split into mul and add:
*/
- case VP_OPCODE_MAD:
+ case OPCODE_MAD:
result = cvp_choose_result( cp, &inst->DstReg, &fixup );
for (i = 0; i < 3; i++)
reg[i] = cvp_emit_arg( cp, &inst->SrcReg[i], REG_ARG0+i );
op = cvp_next_instruction(cp);
- op->alu.opcode = VP_OPCODE_MUL;
+ op->alu.opcode = OPCODE_MUL;
op->alu.file0 = reg[0].file;
op->alu.idx0 = reg[0].idx;
op->alu.file1 = reg[1].file;
@@ -929,7 +986,7 @@ static void cvp_emit_inst( struct compilation *cp,
op->alu.dst = REG_ARG0;
op = cvp_next_instruction(cp);
- op->alu.opcode = VP_OPCODE_ADD;
+ op->alu.opcode = OPCODE_ADD;
op->alu.file0 = FILE_REG;
op->alu.idx0 = REG_ARG0;
op->alu.file1 = reg[2].file;
@@ -942,17 +999,17 @@ static void cvp_emit_inst( struct compilation *cp,
}
break;
- case VP_OPCODE_ARL:
+ case OPCODE_ARL:
reg[0] = cvp_emit_arg( cp, &inst->SrcReg[0], REG_ARG0 );
op = cvp_next_instruction(cp);
- op->alu.opcode = VP_OPCODE_FLR;
+ op->alu.opcode = OPCODE_FLR;
op->alu.dst = REG_ADDR;
op->alu.file0 = reg[0].file;
op->alu.idx0 = reg[0].idx;
break;
- case VP_OPCODE_SWZ: {
+ case OPCODE_SWZ: {
GLuint swz0 = 0, swz1 = 0;
GLuint neg0 = 0, neg1 = 0;
GLuint mask = 0;
@@ -964,7 +1021,7 @@ static void cvp_emit_inst( struct compilation *cp,
for (i = 0; i < 4; i++) {
GLuint swzelt = GET_SWZ(inst->SrcReg[0].Swizzle, i);
if (swzelt >= SWIZZLE_ZERO) {
- neg0 |= inst->SrcReg[0].Negate & (1<<i);
+ neg0 |= inst->SrcReg[0].NegateBase & (1<<i);
if (swzelt == SWIZZLE_ONE)
swz0 |= SWIZZLE_W << (i*2);
else if (i < SWIZZLE_W)
@@ -972,7 +1029,7 @@ static void cvp_emit_inst( struct compilation *cp,
}
else {
mask |= 1<<i;
- neg1 |= inst->SrcReg[0].Negate & (1<<i);
+ neg1 |= inst->SrcReg[0].NegateBase & (1<<i);
swz1 |= swzelt << (i*2);
}
}
@@ -1008,7 +1065,7 @@ static void cvp_emit_inst( struct compilation *cp,
break;
}
- case VP_OPCODE_END:
+ case OPCODE_END:
break;
default:
diff --git a/src/mesa/tnl/t_vb_arbprogram.h b/src/mesa/tnl/t_vb_arbprogram.h
index 4e73d2cde1..93692c92cd 100644
--- a/src/mesa/tnl/t_vb_arbprogram.h
+++ b/src/mesa/tnl/t_vb_arbprogram.h
@@ -36,9 +36,9 @@
/* New, internal instructions:
*/
-#define RSW (VP_MAX_OPCODE)
-#define MSK (VP_MAX_OPCODE+1)
-#define REL (VP_MAX_OPCODE+2)
+#define RSW (MAX_OPCODE)
+#define MSK (MAX_OPCODE+1)
+#define REL (MAX_OPCODE+2)
/**
* Register files for vertex programs
diff --git a/src/mesa/tnl/t_vb_program.c b/src/mesa/tnl/t_vb_program.c
index d77f5424c1..0f53657183 100644
--- a/src/mesa/tnl/t_vb_program.c
+++ b/src/mesa/tnl/t_vb_program.c
@@ -41,7 +41,7 @@
#include "imports.h"
#include "simple_list.h"
#include "mtypes.h"
-#include "nvvertprog.h"
+#include "program_instruction.h"
#include "nvvertexec.h"
#include "nvprogram.h"
diff --git a/src/mesa/tnl/t_vp_build.c b/src/mesa/tnl/t_vp_build.c
index d552748b6c..54fde628df 100644
--- a/src/mesa/tnl/t_vp_build.c
+++ b/src/mesa/tnl/t_vp_build.c
@@ -37,7 +37,7 @@
#include "t_vp_build.h"
#include "shader/program.h"
-#include "shader/nvvertprog.h"
+#include "shader/program_instruction.h"
#include "shader/arbvertparse.h"
struct state_key {
@@ -455,28 +455,32 @@ static void register_matrix_param6( struct tnl_program *p,
}
-static void emit_arg( struct vp_src_register *src,
+static void emit_arg( struct prog_src_register *src,
struct ureg reg )
{
src->File = reg.file;
src->Index = reg.idx;
src->Swizzle = reg.swz;
- src->Negate = reg.negate;
+ src->NegateBase = reg.negate;
+ src->Abs = 0;
+ src->NegateAbs = 0;
src->RelAddr = 0;
- src->pad = 0;
}
-static void emit_dst( struct vp_dst_register *dst,
+static void emit_dst( struct prog_dst_register *dst,
struct ureg reg, GLuint mask )
{
dst->File = reg.file;
dst->Index = reg.idx;
/* allow zero as a shorthand for xyzw */
dst->WriteMask = mask ? mask : WRITEMASK_XYZW;
+ dst->CondMask = COND_TR;
+ dst->CondSwizzle = 0;
+ dst->CondSrc = 0;
dst->pad = 0;
}
-static void debug_insn( struct vp_instruction *inst, const char *fn,
+static void debug_insn( struct prog_instruction *inst, const char *fn,
GLuint line )
{
if (DISASSEM) {
@@ -504,7 +508,7 @@ static void emit_op3fn(struct tnl_program *p,
GLuint line)
{
GLuint nr = p->program->Base.NumInstructions++;
- struct vp_instruction *inst = &p->program->Instructions[nr];
+ struct prog_instruction *inst = &p->program->Instructions[nr];
if (p->program->Base.NumInstructions > MAX_INSN) {
_mesa_problem(0, "Out of instructions in emit_op3fn\n");
@@ -542,7 +546,7 @@ static struct ureg make_temp( struct tnl_program *p, struct ureg reg )
return reg;
else {
struct ureg temp = get_temp(p);
- emit_op1(p, VP_OPCODE_MOV, temp, 0, reg);
+ emit_op1(p, OPCODE_MOV, temp, 0, reg);
return temp;
}
}
@@ -557,10 +561,10 @@ static void emit_matrix_transform_vec4( struct tnl_program *p,
const struct ureg *mat,
struct ureg src)
{
- emit_op2(p, VP_OPCODE_DP4, dest, WRITEMASK_X, src, mat[0]);
- emit_op2(p, VP_OPCODE_DP4, dest, WRITEMASK_Y, src, mat[1]);
- emit_op2(p, VP_OPCODE_DP4, dest, WRITEMASK_Z, src, mat[2]);
- emit_op2(p, VP_OPCODE_DP4, dest, WRITEMASK_W, src, mat[3]);
+ emit_op2(p, OPCODE_DP4, dest, WRITEMASK_X, src, mat[0]);
+ emit_op2(p, OPCODE_DP4, dest, WRITEMASK_Y, src, mat[1]);
+ emit_op2(p, OPCODE_DP4, dest, WRITEMASK_Z, src, mat[2]);
+ emit_op2(p, OPCODE_DP4, dest, WRITEMASK_W, src, mat[3]);
}
/* This version is much easier to implement if writemasks are not
@@ -579,10 +583,10 @@ static void emit_transpose_matrix_transform_vec4( struct tnl_program *p,
else
tmp = dest;
- emit_op2(p, VP_OPCODE_MUL, tmp, 0, swizzle1(src,X), mat[0]);
- emit_op3(p, VP_OPCODE_MAD, tmp, 0, swizzle1(src,Y), mat[1], tmp);
- emit_op3(p, VP_OPCODE_MAD, tmp, 0, swizzle1(src,Z), mat[2], tmp);
- emit_op3(p, VP_OPCODE_MAD, dest, 0, swizzle1(src,W), mat[3], tmp);
+ emit_op2(p, OPCODE_MUL, tmp, 0, swizzle1(src,X), mat[0]);
+ emit_op3(p, OPCODE_MAD, tmp, 0, swizzle1(src,Y), mat[1], tmp);
+ emit_op3(p, OPCODE_MAD, tmp, 0, swizzle1(src,Z), mat[2], tmp);
+ emit_op3(p, OPCODE_MAD, dest, 0, swizzle1(src,W), mat[3], tmp);
if (dest.file != PROGRAM_TEMPORARY)
release_temp(p, tmp);
@@ -593,9 +597,9 @@ static void emit_matrix_transform_vec3( struct tnl_program *p,
const struct ureg *mat,
struct ureg src)
{
- emit_op2(p, VP_OPCODE_DP3, dest, WRITEMASK_X, src, mat[0]);
- emit_op2(p, VP_OPCODE_DP3, dest, WRITEMASK_Y, src, mat[1]);
- emit_op2(p, VP_OPCODE_DP3, dest, WRITEMASK_Z, src, mat[2]);
+ emit_op2(p, OPCODE_DP3, dest, WRITEMASK_X, src, mat[0]);
+ emit_op2(p, OPCODE_DP3, dest, WRITEMASK_Y, src, mat[1]);
+ emit_op2(p, OPCODE_DP3, dest, WRITEMASK_Z, src, mat[2]);
}
@@ -604,9 +608,9 @@ static void emit_normalize_vec3( struct tnl_program *p,
struct ureg src )
{
struct ureg tmp = get_temp(p);
- emit_op2(p, VP_OPCODE_DP3, tmp, 0, src, src);
- emit_op1(p, VP_OPCODE_RSQ, tmp, 0, tmp);
- emit_op2(p, VP_OPCODE_MUL, dest, 0, src, tmp);
+ emit_op2(p, OPCODE_DP3, tmp, 0, src, src);
+ emit_op1(p, OPCODE_RSQ, tmp, 0, tmp);
+ emit_op2(p, OPCODE_MUL, dest, 0, src, tmp);
release_temp(p, tmp);
}
@@ -615,7 +619,7 @@ static void emit_passthrough( struct tnl_program *p,
GLuint output )
{
struct ureg out = register_output(p, output);
- emit_op1(p, VP_OPCODE_MOV, out, 0, register_input(p, input));
+ emit_op1(p, OPCODE_MOV, out, 0, register_input(p, input));
}
static struct ureg get_eye_position( struct tnl_program *p )
@@ -680,7 +684,7 @@ static struct ureg get_eye_normal( struct tnl_program *p )
struct ureg rescale = register_param2(p, STATE_INTERNAL,
STATE_NORMAL_SCALE);
- emit_op2( p, VP_OPCODE_MUL, p->eye_normal, 0, normal,
+ emit_op2( p, OPCODE_MUL, p->eye_normal, 0, normal,
swizzle1(rescale, X));
}
}
@@ -766,7 +770,7 @@ static struct ureg get_scenecolor( struct tnl_program *p, GLuint side )
struct ureg material_ambient = get_material(p, side, STATE_AMBIENT);
struct ureg material_diffuse = get_material(p, side, STATE_DIFFUSE);
struct ureg tmp = make_temp(p, material_diffuse);
- emit_op3(p, VP_OPCODE_MAD, tmp, WRITEMASK_XYZ, lm_ambient,
+ emit_op3(p, OPCODE_MAD, tmp, WRITEMASK_XYZ, lm_ambient,
material_ambient, material_emission);
return tmp;
}
@@ -784,7 +788,7 @@ static struct ureg get_lightprod( struct tnl_program *p, GLuint light,
register_param3(p, STATE_LIGHT, light, property);
struct ureg material_value = get_material(p, side, property);
struct ureg tmp = get_temp(p);
- emit_op2(p, VP_OPCODE_MUL, tmp, 0, light_value, material_value);
+ emit_op2(p, OPCODE_MUL, tmp, 0, light_value, material_value);
return tmp;
}
else
@@ -809,10 +813,10 @@ static struct ureg calculate_light_attenuation( struct tnl_program *p,
struct ureg slt = get_temp(p);
emit_normalize_vec3( p, spot, spot_dir ); /* XXX: precompute! */
- emit_op2(p, VP_OPCODE_DP3, spot, 0, negate(VPpli), spot);
- emit_op2(p, VP_OPCODE_SLT, slt, 0, swizzle1(spot_dir,W), spot);
- emit_op2(p, VP_OPCODE_POW, spot, 0, spot, swizzle1(attenuation, W));
- emit_op2(p, VP_OPCODE_MUL, att, 0, slt, spot);
+ emit_op2(p, OPCODE_DP3, spot, 0, negate(VPpli), spot);
+ emit_op2(p, OPCODE_SLT, slt, 0, swizzle1(spot_dir,W), spot);
+ emit_op2(p, OPCODE_POW, spot, 0, spot, swizzle1(attenuation, W));
+ emit_op2(p, OPCODE_MUL, att, 0, slt, spot);
release_temp(p, spot);
release_temp(p, slt);
@@ -823,20 +827,20 @@ static struct ureg calculate_light_attenuation( struct tnl_program *p,
if (p->state->unit[i].light_attenuated) {
/* 1/d,d,d,1/d */
- emit_op1(p, VP_OPCODE_RCP, dist, WRITEMASK_YZ, dist);
+ emit_op1(p, OPCODE_RCP, dist, WRITEMASK_YZ, dist);
/* 1,d,d*d,1/d */
- emit_op2(p, VP_OPCODE_MUL, dist, WRITEMASK_XZ, dist, swizzle1(dist,Y));
+ emit_op2(p, OPCODE_MUL, dist, WRITEMASK_XZ, dist, swizzle1(dist,Y));
/* 1/dist-atten */
- emit_op2(p, VP_OPCODE_DP3, dist, 0, attenuation, dist);
+ emit_op2(p, OPCODE_DP3, dist, 0, attenuation, dist);
if (!p->state->unit[i].light_spotcutoff_is_180) {
/* dist-atten */
- emit_op1(p, VP_OPCODE_RCP, dist, 0, dist);
+ emit_op1(p, OPCODE_RCP, dist, 0, dist);
/* spot-atten * dist-atten */
- emit_op2(p, VP_OPCODE_MUL, att, 0, dist, att);
+ emit_op2(p, OPCODE_MUL, att, 0, dist, att);
} else {
/* dist-atten */
- emit_op1(p, VP_OPCODE_RCP, att, 0, dist);
+ emit_op1(p, OPCODE_RCP, att, 0, dist);
}
}
@@ -871,7 +875,7 @@ static void build_lighting( struct tnl_program *p )
{
struct ureg shininess = get_material(p, 0, STATE_SHININESS);
- emit_op1(p, VP_OPCODE_MOV, dots, WRITEMASK_W, swizzle1(shininess,X));
+ emit_op1(p, OPCODE_MOV, dots, WRITEMASK_W, swizzle1(shininess,X));
release_temp(p, shininess);
_col0 = make_temp(p, get_scenecolor(p, 0));
@@ -884,7 +888,7 @@ static void build_lighting( struct tnl_program *p )
if (twoside) {
struct ureg shininess = get_material(p, 1, STATE_SHININESS);
- emit_op1(p, VP_OPCODE_MOV, dots, WRITEMASK_Z,
+ emit_op1(p, OPCODE_MOV, dots, WRITEMASK_Z,
negate(swizzle1(shininess,X)));
release_temp(p, shininess);
@@ -900,22 +904,22 @@ static void build_lighting( struct tnl_program *p )
*/
{
struct ureg res0 = register_output( p, VERT_RESULT_COL0 );
- emit_op1(p, VP_OPCODE_MOV, res0, 0, _col0);
+ emit_op1(p, OPCODE_MOV, res0, 0, _col0);
}
if (separate) {
struct ureg res1 = register_output( p, VERT_RESULT_COL1 );
- emit_op1(p, VP_OPCODE_MOV, res1, 0, _col1);
+ emit_op1(p, OPCODE_MOV, res1, 0, _col1);
}
if (twoside) {
struct ureg res0 = register_output( p, VERT_RESULT_BFC0 );
- emit_op1(p, VP_OPCODE_MOV, res0, 0, _bfc0);
+ emit_op1(p, OPCODE_MOV, res0, 0, _bfc0);
}
if (twoside && separate) {
struct ureg res1 = register_output( p, VERT_RESULT_BFC1 );
- emit_op1(p, VP_OPCODE_MOV, res1, 0, _bfc1);
+ emit_op1(p, OPCODE_MOV, res1, 0, _bfc1);
}
if (nr_lights == 0) {
@@ -950,14 +954,14 @@ static void build_lighting( struct tnl_program *p )
/* Calulate VPpli vector
*/
- emit_op2(p, VP_OPCODE_SUB, VPpli, 0, Ppli, V);
+ emit_op2(p, OPCODE_SUB, VPpli, 0, Ppli, V);
/* Normalize VPpli. The dist value also used in
* attenuation below.
*/
- emit_op2(p, VP_OPCODE_DP3, dist, 0, VPpli, VPpli);
- emit_op1(p, VP_OPCODE_RSQ, dist, 0, dist);
- emit_op2(p, VP_OPCODE_MUL, VPpli, 0, VPpli, dist);
+ emit_op2(p, OPCODE_DP3, dist, 0, VPpli, VPpli);
+ emit_op1(p, OPCODE_RSQ, dist, 0, dist);
+ emit_op2(p, OPCODE_MUL, VPpli, 0, VPpli, dist);
/* Calculate attenuation:
@@ -972,11 +976,11 @@ static void build_lighting( struct tnl_program *p )
*/
if (p->state->light_local_viewer) {
struct ureg eye_hat = get_eye_position_normalized(p);
- emit_op2(p, VP_OPCODE_SUB, half, 0, VPpli, eye_hat);
+ emit_op2(p, OPCODE_SUB, half, 0, VPpli, eye_hat);
}
else {
struct ureg z_dir = swizzle(get_identity_param(p),X,Y,W,Z);
- emit_op2(p, VP_OPCODE_ADD, half, 0, VPpli, z_dir);
+ emit_op2(p, OPCODE_ADD, half, 0, VPpli, z_dir);
}
emit_normalize_vec3(p, half, half);
@@ -986,8 +990,8 @@ static void build_lighting( struct tnl_program *p )
/* Calculate dot products:
*/
- emit_op2(p, VP_OPCODE_DP3, dots, WRITEMASK_X, normal, VPpli);
- emit_op2(p, VP_OPCODE_DP3, dots, WRITEMASK_Y, normal, half);
+ emit_op2(p, OPCODE_DP3, dots, WRITEMASK_X, normal, VPpli);
+ emit_op2(p, OPCODE_DP3, dots, WRITEMASK_Y, normal, half);
/* Front face lighting:
@@ -999,10 +1003,10 @@ static void build_lighting( struct tnl_program *p )
struct ureg res0, res1;
GLuint mask0, mask1;
- emit_op1(p, VP_OPCODE_LIT, lit, 0, dots);
+ emit_op1(p, OPCODE_LIT, lit, 0, dots);
if (!is_undef(att))
- emit_op2(p, VP_OPCODE_MUL, lit, 0, lit, att);
+ emit_op2(p, OPCODE_MUL, lit, 0, lit, att);
if (count == nr_lights) {
@@ -1025,9 +1029,9 @@ static void build_lighting( struct tnl_program *p )
res1 = _col1;
}
- emit_op3(p, VP_OPCODE_MAD, _col0, 0, swizzle1(lit,X), ambient, _col0);
- emit_op3(p, VP_OPCODE_MAD, res0, mask0, swizzle1(lit,Y), diffuse, _col0);
- emit_op3(p, VP_OPCODE_MAD, res1, mask1, swizzle1(lit,Z), specular, _col1);
+ emit_op3(p, OPCODE_MAD, _col0, 0, swizzle1(lit,X), ambient, _col0);
+ emit_op3(p, OPCODE_MAD, res0, mask0, swizzle1(lit,Y), diffuse, _col0);
+ emit_op3(p, OPCODE_MAD, res1, mask1, swizzle1(lit,Z), specular, _col1);
release_temp(p, ambient);
release_temp(p, diffuse);
@@ -1043,10 +1047,10 @@ static void build_lighting( struct tnl_program *p )
struct ureg res0, res1;
GLuint mask0, mask1;
- emit_op1(p, VP_OPCODE_LIT, lit, 0, negate(swizzle(dots,X,Y,W,Z)));
+ emit_op1(p, OPCODE_LIT, lit, 0, negate(swizzle(dots,X,Y,W,Z)));
if (!is_undef(att))
- emit_op2(p, VP_OPCODE_MUL, lit, 0, lit, att);
+ emit_op2(p, OPCODE_MUL, lit, 0, lit, att);
if (count == nr_lights) {
if (separate) {
@@ -1068,9 +1072,9 @@ static void build_lighting( struct tnl_program *p )
mask1 = 0;
}
- emit_op3(p, VP_OPCODE_MAD, _bfc0, 0, swizzle1(lit,X), ambient, _bfc0);
- emit_op3(p, VP_OPCODE_MAD, res0, mask0, swizzle1(lit,Y), diffuse, _bfc0);
- emit_op3(p, VP_OPCODE_MAD, res1, mask1, swizzle1(lit,Z), specular, _bfc1);
+ emit_op3(p, OPCODE_MAD, _bfc0, 0, swizzle1(lit,X), ambient, _bfc0);
+ emit_op3(p, OPCODE_MAD, res0, mask0, swizzle1(lit,Y), diffuse, _bfc0);
+ emit_op3(p, OPCODE_MAD, res1, mask1, swizzle1(lit,Z), specular, _bfc1);
release_temp(p, ambient);
release_temp(p, diffuse);
@@ -1106,22 +1110,22 @@ static void build_fog( struct tnl_program *p )
switch (p->state->fog_mode) {
case FOG_LINEAR: {
struct ureg id = get_identity_param(p);
- emit_op2(p, VP_OPCODE_SUB, tmp, 0, swizzle1(params,Z), input);
- emit_op2(p, VP_OPCODE_MUL, tmp, 0, tmp, swizzle1(params,W));
- emit_op2(p, VP_OPCODE_MAX, tmp, 0, tmp, swizzle1(id,X)); /* saturate */
- emit_op2(p, VP_OPCODE_MIN, fog, WRITEMASK_X, tmp, swizzle1(id,W));
+ emit_op2(p, OPCODE_SUB, tmp, 0, swizzle1(params,Z), input);
+ emit_op2(p, OPCODE_MUL, tmp, 0, tmp, swizzle1(params,W));
+ emit_op2(p, OPCODE_MAX, tmp, 0, tmp, swizzle1(id,X)); /* saturate */
+ emit_op2(p, OPCODE_MIN, fog, WRITEMASK_X, tmp, swizzle1(id,W));
break;
}
case FOG_EXP:
- emit_op1(p, VP_OPCODE_ABS, tmp, 0, input);
- emit_op2(p, VP_OPCODE_MUL, tmp, 0, tmp, swizzle1(params,X));
- emit_op2(p, VP_OPCODE_POW, fog, WRITEMASK_X,
+ emit_op1(p, OPCODE_ABS, tmp, 0, input);
+ emit_op2(p, OPCODE_MUL, tmp, 0, tmp, swizzle1(params,X));
+ emit_op2(p, OPCODE_POW, fog, WRITEMASK_X,
register_const1f(p, M_E), negate(tmp));
break;
case FOG_EXP2:
- emit_op2(p, VP_OPCODE_MUL, tmp, 0, input, swizzle1(params,X));
- emit_op2(p, VP_OPCODE_MUL, tmp, 0, tmp, tmp);
- emit_op2(p, VP_OPCODE_POW, fog, WRITEMASK_X,
+ emit_op2(p, OPCODE_MUL, tmp, 0, input, swizzle1(params,X));
+ emit_op2(p, OPCODE_MUL, tmp, 0, tmp, tmp);
+ emit_op2(p, OPCODE_POW, fog, WRITEMASK_X,
register_const1f(p, M_E), negate(tmp));
break;
}
@@ -1133,7 +1137,7 @@ static void build_fog( struct tnl_program *p )
*
* KW: Is it really necessary to do anything in this case?
*/
- emit_op1(p, VP_OPCODE_MOV, fog, WRITEMASK_X, input);
+ emit_op1(p, OPCODE_MOV, fog, WRITEMASK_X, input);
}
}
@@ -1146,11 +1150,11 @@ static void build_reflect_texgen( struct tnl_program *p,
struct ureg tmp = get_temp(p);
/* n.u */
- emit_op2(p, VP_OPCODE_DP3, tmp, 0, normal, eye_hat);
+ emit_op2(p, OPCODE_DP3, tmp, 0, normal, eye_hat);
/* 2n.u */
- emit_op2(p, VP_OPCODE_ADD, tmp, 0, tmp, tmp);
+ emit_op2(p, OPCODE_ADD, tmp, 0, tmp, tmp);
/* (-2n.u)n + u */
- emit_op3(p, VP_OPCODE_MAD, dest, writemask, negate(tmp), normal, eye_hat);
+ emit_op3(p, OPCODE_MAD, dest, writemask, negate(tmp), normal, eye_hat);
}
static void build_sphere_texgen( struct tnl_program *p,
@@ -1174,21 +1178,21 @@ static void build_sphere_texgen( struct tnl_program *p,
*/
/* n.u */
- emit_op2(p, VP_OPCODE_DP3, tmp, 0, normal, eye_hat);
+ emit_op2(p, OPCODE_DP3, tmp, 0, normal, eye_hat);
/* 2n.u */
- emit_op2(p, VP_OPCODE_ADD, tmp, 0, tmp, tmp);
+ emit_op2(p, OPCODE_ADD, tmp, 0, tmp, tmp);
/* (-2n.u)n + u */
- emit_op3(p, VP_OPCODE_MAD, r, 0, negate(tmp), normal, eye_hat);
+ emit_op3(p, OPCODE_MAD, r, 0, negate(tmp), normal, eye_hat);
/* r + 0,0,1 */
- emit_op2(p, VP_OPCODE_ADD, tmp, 0, r, swizzle(id,X,Y,W,Z));
+ emit_op2(p, OPCODE_ADD, tmp, 0, r, swizzle(id,X,Y,W,Z));
/* rx^2 + ry^2 + (rz+1)^2 */
- emit_op2(p, VP_OPCODE_DP3, tmp, 0, tmp, tmp);
+ emit_op2(p, OPCODE_DP3, tmp, 0, tmp, tmp);
/* 2/m */
- emit_op1(p, VP_OPCODE_RSQ, tmp, 0, tmp);
+ emit_op1(p, OPCODE_RSQ, tmp, 0, tmp);
/* 1/m */
- emit_op2(p, VP_OPCODE_MUL, inv_m, 0, tmp, half);
+ emit_op2(p, OPCODE_MUL, inv_m, 0, tmp, half);
/* r/m + 1/2 */
- emit_op3(p, VP_OPCODE_MAD, dest, writemask, r, inv_m, half);
+ emit_op3(p, OPCODE_MAD, dest, writemask, r, inv_m, half);
release_temp(p, tmp);
release_temp(p, r);
@@ -1237,7 +1241,7 @@ static void build_texture_transform( struct tnl_program *p )
register_param3(p, STATE_TEXGEN, i,
STATE_TEXGEN_OBJECT_S + j);
- emit_op2(p, VP_OPCODE_DP4, out_texgen, WRITEMASK_X << j,
+ emit_op2(p, OPCODE_DP4, out_texgen, WRITEMASK_X << j,
obj, plane );
break;
}
@@ -1247,7 +1251,7 @@ static void build_texture_transform( struct tnl_program *p )
register_param3(p, STATE_TEXGEN, i,
STATE_TEXGEN_EYE_S + j);
- emit_op2(p, VP_OPCODE_DP4, out_texgen, WRITEMASK_X << j,
+ emit_op2(p, OPCODE_DP4, out_texgen, WRITEMASK_X << j,
eye, plane );
break;
}
@@ -1277,12 +1281,12 @@ static void build_texture_transform( struct tnl_program *p )
if (normal_mask) {
struct ureg normal = get_eye_normal(p);
- emit_op1(p, VP_OPCODE_MOV, out_texgen, normal_mask, normal );
+ emit_op1(p, OPCODE_MOV, out_texgen, normal_mask, normal );
}
if (copy_mask) {
struct ureg in = register_input(p, VERT_ATTRIB_TEX0+i);
- emit_op1(p, VP_OPCODE_MOV, out_texgen, copy_mask, in );
+ emit_op1(p, OPCODE_MOV, out_texgen, copy_mask, in );
}
}
@@ -1323,19 +1327,19 @@ static void build_pointsize( struct tnl_program *p )
struct ureg ut = get_temp(p);
/* 1, -Z, Z * Z, 1 */
- emit_op1(p, VP_OPCODE_MOV, ut, 0, swizzle1(get_identity_param(p), W));
- emit_op2(p, VP_OPCODE_MUL, ut, WRITEMASK_YZ, ut, negate(swizzle1(eye, Z)));
- emit_op2(p, VP_OPCODE_MUL, ut, WRITEMASK_Z, ut, negate(swizzle1(eye, Z)));
+ emit_op1(p, OPCODE_MOV, ut, 0, swizzle1(get_identity_param(p), W));
+ emit_op2(p, OPCODE_MUL, ut, WRITEMASK_YZ, ut, negate(swizzle1(eye, Z)));
+ emit_op2(p, OPCODE_MUL, ut, WRITEMASK_Z, ut, negate(swizzle1(eye, Z)));
/* p1 + p2 * dist + p3 * dist * dist, 0 */
- emit_op2(p, VP_OPCODE_DP3, ut, 0, ut, state_attenuation);
+ emit_op2(p, OPCODE_DP3, ut, 0, ut, state_attenuation);
/* 1 / factor */
- emit_op1(p, VP_OPCODE_RCP, ut, 0, ut );
+ emit_op1(p, OPCODE_RCP, ut, 0, ut );
/* out = pointSize / factor */
- emit_op2(p, VP_OPCODE_MUL, out, WRITEMASK_X, ut, state_size);
+ emit_op2(p, OPCODE_MUL, out, WRITEMASK_X, ut, state_size);
release_temp(p, ut);
}
@@ -1371,7 +1375,7 @@ static void build_tnl_program( struct tnl_program *p )
/* Finish up:
*/
- emit_op1(p, VP_OPCODE_END, undef, 0, undef);
+ emit_op1(p, OPCODE_END, undef, 0, undef);
/* Disassemble:
*/
@@ -1402,7 +1406,7 @@ create_new_program( const struct state_key *key,
else
p.temp_reserved = ~((1<<max_temps)-1);
- p.program->Instructions = MALLOC(sizeof(struct vp_instruction) * MAX_INSN);
+ p.program->Instructions = MALLOC(sizeof(struct prog_instruction) * MAX_INSN);
p.program->Base.String = 0;
p.program->Base.NumInstructions =
p.program->Base.NumTemporaries =