Move span stuff from swrast.h to s_context.h (it's private).

Implemented remaining fragment program instructions.
Initial changes to implement fragment program texture sampling.

1 files changed, 475 insertions, 39 deletions

diff --git a/src/mesa/swrast/s_nvfragprog.c b/src/mesa/swrast/s_nvfragprog.c
index 6ff4569a8e8..16bfe7d1c45 100644
--- a/src/mesa/swrast/s_nvfragprog.c
+++ b/src/mesa/swrast/s_nvfragprog.c
@@ -1,10 +1,10 @@
-/* $Id: s_nvfragprog.c,v 1.2 2003/02/17 15:38:04 brianp Exp $ */
+/* $Id: s_nvfragprog.c,v 1.3 2003/02/23 04:10:54 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
  * Version:  5.1
  *
- * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2003  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"),
@@ -36,56 +36,42 @@
 #include "s_nvfragprog.h"
 
 
+
 /**
  * Fetch a texel.
  */
 static void
 fetch_texel( GLcontext *ctx, const GLfloat texcoord[4], GLuint unit,
-             GLenum target, GLfloat color[4] )
+             GLuint targetIndex, GLfloat color[4] )
 {
+   const GLfloat *lambda = NULL;
+   GLchan rgba[4];
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
    const struct gl_texture_object *texObj;
 
-   /* XXX Use swrast->TextureSample[texUnit]() to sample texture.
-    * Needs to be swrast->TextureSample[target][texUnit]() though.
-    */
-
-   switch (target) {
-      case GL_TEXTURE_1D:
+   switch (targetIndex) {
+      case TEXTURE_1D_INDEX:
          texObj = ctx->Texture.Unit[unit].Current1D;
          break;
-      case GL_TEXTURE_2D:
+      case TEXTURE_2D_INDEX:
          texObj = ctx->Texture.Unit[unit].Current2D;
          break;
-      case GL_TEXTURE_3D:
+      case TEXTURE_3D_INDEX:
          texObj = ctx->Texture.Unit[unit].Current3D;
          break;
-      case GL_TEXTURE_CUBE_MAP:
+      case TEXTURE_CUBE_INDEX:
          texObj = ctx->Texture.Unit[unit].CurrentCubeMap;
          break;
-      case GL_TEXTURE_RECTANGLE_NV:
+      case TEXTURE_RECT_INDEX:
          texObj = ctx->Texture.Unit[unit].CurrentRect;
          break;
       default:
          _mesa_problem(ctx, "Invalid target in fetch_texel");
    }
 
-   if (texObj->Complete) {
-      const struct gl_texture_image *texImage;
-      GLint col, row, img;
-      GLchan texel[4];
-      col = IROUND(texcoord[0] * texImage->Width); /* XXX temporary! */
-      row = IROUND(texcoord[1] * texImage->Height); /* XXX temporary! */
-      img = 0;
-      texImage->FetchTexel(texImage, col, row, img, texel);
-      /* XXX texture format? */
-      color[0] = CHAN_TO_FLOAT(texel[0]);
-      color[1] = CHAN_TO_FLOAT(texel[1]);
-      color[2] = CHAN_TO_FLOAT(texel[2]);
-      color[3] = CHAN_TO_FLOAT(texel[3]);
-   }
-   else {
-      ASSIGN_4V(color, 0.0, 0.0, 0.0, 0.0);
-   }
+   swrast->TextureSample[unit](ctx, unit, texObj, 1,
+                               (const GLfloat (*)[4]) &texcoord,
+                               lambda, &rgba);
 }
 
 
@@ -95,7 +81,7 @@ fetch_texel( GLcontext *ctx, const GLfloat texcoord[4], GLuint unit,
 static void
 fetch_texel_deriv( GLcontext *ctx, const GLfloat texcoord[4],
                    const GLfloat dtdx[4], const GLfloat dtdy[4],
-                   GLuint unit, GLenum target, GLfloat color[4] )
+                   GLuint unit, GLuint targetIndex, GLfloat color[4] )
 {
    /* XXX to do */
 
@@ -314,6 +300,30 @@ execute_program(GLcontext *ctx, const struct fragment_program *program)
                               inst->UpdateCondRegister );
             }
             break;
+         case FP_OPCODE_DDX: /* Partial derivative with respect to X */
+            {
+               GLfloat a[4], result[4];
+               fetch_vector4( &inst->SrcReg[0], machine, a );
+               result[0] = 0; /* XXX fix */
+               result[1] = 0;
+               result[2] = 0;
+               result[3] = 0;
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_DDY: /* Partial derivative with respect to Y */
+            {
+               GLfloat a[4], result[4];
+               fetch_vector4( &inst->SrcReg[0], machine, a );
+               result[0] = 0; /* XXX fix */
+               result[1] = 0;
+               result[2] = 0;
+               result[3] = 0;
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
          case FP_OPCODE_DP3:
             {
                GLfloat a[4], b[4], result[4];
@@ -336,6 +346,53 @@ execute_program(GLcontext *ctx, const struct fragment_program *program)
                               inst->UpdateCondRegister );
             }
             break;
+         case FP_OPCODE_DST: /* Distance vector */
+            {
+               GLfloat a[4], b[4], result[4];
+               fetch_vector4( &inst->SrcReg[0], machine, a );
+               fetch_vector4( &inst->SrcReg[1], machine, b );
+               result[0] = 1.0F;
+               result[1] = a[1] * b[1];
+               result[2] = a[2];
+               result[3] = b[3];
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_EX2: /* Exponential base 2 */
+            {
+               GLfloat a[4], result[4];
+               fetch_vector1( &inst->SrcReg[0], machine, a );
+               result[0] = result[1] = result[2] = result[3] =
+                  (GLfloat) pow(2.0, a[0]);
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_FLR:
+            {
+               GLfloat a[4], result[4];
+               fetch_vector4( &inst->SrcReg[0], machine, a );
+               result[0] = FLOORF(a[0]);
+               result[1] = FLOORF(a[1]);
+               result[2] = FLOORF(a[2]);
+               result[3] = FLOORF(a[3]);
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_FRC:
+            {
+               GLfloat a[4], result[4];
+               fetch_vector4( &inst->SrcReg[0], machine, a );
+               result[0] = a[0] - FLOORF(a[0]);
+               result[1] = a[1] - FLOORF(a[1]);
+               result[2] = a[2] - FLOORF(a[2]);
+               result[3] = a[3] - FLOORF(a[3]);
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
          case FP_OPCODE_KIL:
             {
                const GLuint *swizzle = inst->DstReg.CondSwizzle;
@@ -347,6 +404,32 @@ execute_program(GLcontext *ctx, const struct fragment_program *program)
                   return;
             }
             break;
+         case FP_OPCODE_LG2:  /* log base 2 */
+            {
+               GLfloat a[4], result[4];
+               fetch_vector1( &inst->SrcReg[0], machine, a );
+               result[0] = result[1] = result[2] = result[3]
+                  = LOG2(a[0]);
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_LIT:
+            {
+               GLfloat a[4], result[4];
+               fetch_vector4( &inst->SrcReg[0], machine, a );
+               if (a[0] < 0.0F)
+                  a[0] = 0.0F;
+               if (a[1] < 0.0F)
+                  a[1] = 0.0F;
+               result[0] = 1.0F;
+               result[1] = a[0];
+               result[2] = (a[0] > 0.0) ? pow(2.0, a[3]) : 0.0F;
+               result[3] = 1.0F;
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
          case FP_OPCODE_LRP:
             {
                GLfloat a[4], b[4], c[4], result[4];
@@ -361,6 +444,46 @@ execute_program(GLcontext *ctx, const struct fragment_program *program)
                               inst->UpdateCondRegister );
             }
             break;
+         case FP_OPCODE_MAD:
+            {
+               GLfloat a[4], b[4], c[4], result[4];
+               fetch_vector4( &inst->SrcReg[0], machine, a );
+               fetch_vector4( &inst->SrcReg[1], machine, b );
+               fetch_vector4( &inst->SrcReg[2], machine, c );
+               result[0] = a[0] * b[0] + c[0];
+               result[1] = a[1] * b[1] + c[1];
+               result[2] = a[2] * b[2] + c[2];
+               result[3] = a[3] * b[3] + c[3];
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_MAX:
+            {
+               GLfloat a[4], b[4], result[4];
+               fetch_vector4( &inst->SrcReg[0], machine, a );
+               fetch_vector4( &inst->SrcReg[1], machine, b );
+               result[0] = MAX2(a[0], b[0]);
+               result[1] = MAX2(a[1], b[1]);
+               result[2] = MAX2(a[2], b[2]);
+               result[3] = MAX2(a[3], b[3]);
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_MIN:
+            {
+               GLfloat a[4], b[4], result[4];
+               fetch_vector4( &inst->SrcReg[0], machine, a );
+               fetch_vector4( &inst->SrcReg[1], machine, b );
+               result[0] = MIN2(a[0], b[0]);
+               result[1] = MIN2(a[1], b[1]);
+               result[2] = MIN2(a[2], b[2]);
+               result[3] = MIN2(a[3], b[3]);
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
          case FP_OPCODE_MOV:
             {
                GLfloat t[4];
@@ -369,7 +492,136 @@ execute_program(GLcontext *ctx, const struct fragment_program *program)
                               inst->UpdateCondRegister );
             }
             break;
-         case FP_OPCODE_SEQ:
+         case FP_OPCODE_MUL:
+            {
+               GLfloat a[4], b[4], result[4];
+               fetch_vector4( &inst->SrcReg[0], machine, a );
+               fetch_vector4( &inst->SrcReg[1], machine, b );
+               result[0] = a[0] * b[0];
+               result[1] = a[1] * b[1];
+               result[2] = a[2] * b[2];
+               result[3] = a[3] * b[3];
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_PK2H: /* pack two 16-bit floats */
+            /* XXX this is probably wrong */
+            {
+               GLfloat a[4], result[4];
+               const GLuint *rawBits = (const GLuint *) a;
+               GLuint *rawResult = (GLuint *) result;
+               fetch_vector4( &inst->SrcReg[0], machine, a );
+               rawResult[0] = rawResult[1] = rawResult[2] = rawResult[3]
+                  = rawBits[0] | (rawBits[1] << 16);
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_PK2US: /* pack two GLushorts */
+            {
+               GLfloat a[4], result[4];
+               GLuint usx, usy, *rawResult = (GLuint *) result;
+               fetch_vector4( &inst->SrcReg[0], machine, a );
+               a[0] = CLAMP(a[0], 0.0F, 1.0F);
+               a[1] = CLAMP(a[0], 0.0F, 1.0F);
+               usx = IROUND(a[0] * 65535.0F);
+               usy = IROUND(a[1] * 65535.0F);
+               rawResult[0] = rawResult[1] = rawResult[2] = rawResult[3]
+                  = usx | (usy << 16);
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_PK4B: /* pack four GLbytes */
+            {
+               GLfloat a[4], result[4];
+               GLuint ubx, uby, ubz, ubw, *rawResult = (GLuint *) result;
+               fetch_vector4( &inst->SrcReg[0], machine, a );
+               a[0] = CLAMP(a[0], -128.0F / 127.0F, 1.0F);
+               a[1] = CLAMP(a[1], -128.0F / 127.0F, 1.0F);
+               a[2] = CLAMP(a[2], -128.0F / 127.0F, 1.0F);
+               a[3] = CLAMP(a[3], -128.0F / 127.0F, 1.0F);
+               ubx = IROUND(127.0F * a[0] + 128.0F);
+               uby = IROUND(127.0F * a[1] + 128.0F);
+               ubz = IROUND(127.0F * a[2] + 128.0F);
+               ubw = IROUND(127.0F * a[3] + 128.0F);
+               rawResult[0] = rawResult[1] = rawResult[2] = rawResult[3]
+                  = ubx | (uby << 8) | (ubz << 16) | (ubw << 24);
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_PK4UB: /* pack four GLubytes */
+            {
+               GLfloat a[4], result[4];
+               GLuint ubx, uby, ubz, ubw, *rawResult = (GLuint *) result;
+               fetch_vector4( &inst->SrcReg[0], machine, a );
+               a[0] = CLAMP(a[0], 0.0F, 1.0F);
+               a[1] = CLAMP(a[1], 0.0F, 1.0F);
+               a[2] = CLAMP(a[2], 0.0F, 1.0F);
+               a[3] = CLAMP(a[3], 0.0F, 1.0F);
+               ubx = IROUND(255.0F * a[0]);
+               uby = IROUND(255.0F * a[1]);
+               ubz = IROUND(255.0F * a[2]);
+               ubw = IROUND(255.0F * a[3]);
+               rawResult[0] = rawResult[1] = rawResult[2] = rawResult[3]
+                  = ubx | (uby << 8) | (ubz << 16) | (ubw << 24);
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_POW:
+            {
+               GLfloat a[4], b[4], result[4];
+               fetch_vector1( &inst->SrcReg[0], machine, a );
+               fetch_vector1( &inst->SrcReg[1], machine, b );
+               result[0] = result[1] = result[2] = result[3]
+                  = pow(a[0], b[0]);
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_RCP:
+            {
+               GLfloat a[4], result[4];
+               fetch_vector1( &inst->SrcReg[0], machine, a );
+               result[0] = result[1] = result[2] = result[3]
+                  = 1.0F / a[0];
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_RFL:
+            {
+               GLfloat axis[4], dir[4], result[4], tmp[4];
+               fetch_vector4( &inst->SrcReg[0], machine, axis );
+               fetch_vector4( &inst->SrcReg[1], machine, dir );
+               tmp[3] = axis[0] * axis[0]
+                      + axis[1] * axis[1]
+                      + axis[2] * axis[2];
+               tmp[0] = (2.0F * (axis[0] * dir[0] +
+                                 axis[1] * dir[1] +
+                                 axis[2] * dir[2])) / tmp[3];
+               result[0] = tmp[0] * axis[0] - dir[0];
+               result[1] = tmp[0] * axis[1] - dir[1];
+               result[2] = tmp[0] * axis[2] - dir[2];
+               /* result[3] is never written! XXX enforce in parser! */
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_RSQ: /* 1 / sqrt() */
+            {
+               GLfloat a[4], result[4];
+               fetch_vector1( &inst->SrcReg[0], machine, a );
+               result[0] = result[1] = result[2] = result[3]
+                  = 1.0F / GL_SQRT(a[0]);
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_SEQ: /* set on equal */
             {
                GLfloat a[4], b[4], result[4];
                fetch_vector4( &inst->SrcReg[0], machine, a );
@@ -382,13 +634,114 @@ execute_program(GLcontext *ctx, const struct fragment_program *program)
                               inst->UpdateCondRegister );
             }
             break;
+         case FP_OPCODE_SFL: /* set false, operands ignored */
+            {
+               static const GLfloat result[4] = { 0.0F, 0.0F, 0.0F, 0.0F };
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_SGE: /* set on greater or equal */
+            {
+               GLfloat a[4], b[4], result[4];
+               fetch_vector4( &inst->SrcReg[0], machine, a );
+               fetch_vector4( &inst->SrcReg[1], machine, b );
+               result[0] = (a[0] >= b[0]) ? 1.0F : 0.0F;
+               result[1] = (a[1] >= b[1]) ? 1.0F : 0.0F;
+               result[2] = (a[2] >= b[2]) ? 1.0F : 0.0F;
+               result[3] = (a[3] >= b[3]) ? 1.0F : 0.0F;
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_SGT: /* set on greater */
+            {
+               GLfloat a[4], b[4], result[4];
+               fetch_vector4( &inst->SrcReg[0], machine, a );
+               fetch_vector4( &inst->SrcReg[1], machine, b );
+               result[0] = (a[0] > b[0]) ? 1.0F : 0.0F;
+               result[1] = (a[1] > b[1]) ? 1.0F : 0.0F;
+               result[2] = (a[2] > b[2]) ? 1.0F : 0.0F;
+               result[3] = (a[3] > b[3]) ? 1.0F : 0.0F;
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_SIN:
+            {
+               GLfloat a[4], result[4];
+               fetch_vector1( &inst->SrcReg[0], machine, a );
+               result[0] = result[1] = result[2] = result[3] = sin(a[0]);
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_SLE: /* set on less or equal */
+            {
+               GLfloat a[4], b[4], result[4];
+               fetch_vector4( &inst->SrcReg[0], machine, a );
+               fetch_vector4( &inst->SrcReg[1], machine, b );
+               result[0] = (a[0] <= b[0]) ? 1.0F : 0.0F;
+               result[1] = (a[1] <= b[1]) ? 1.0F : 0.0F;
+               result[2] = (a[2] <= b[2]) ? 1.0F : 0.0F;
+               result[3] = (a[3] <= b[3]) ? 1.0F : 0.0F;
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_SLT: /* set on less */
+            {
+               GLfloat a[4], b[4], result[4];
+               fetch_vector4( &inst->SrcReg[0], machine, a );
+               fetch_vector4( &inst->SrcReg[1], machine, b );
+               result[0] = (a[0] < b[0]) ? 1.0F : 0.0F;
+               result[1] = (a[1] < b[1]) ? 1.0F : 0.0F;
+               result[2] = (a[2] < b[2]) ? 1.0F : 0.0F;
+               result[3] = (a[3] < b[3]) ? 1.0F : 0.0F;
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_SNE: /* set on not equal */
+            {
+               GLfloat a[4], b[4], result[4];
+               fetch_vector4( &inst->SrcReg[0], machine, a );
+               fetch_vector4( &inst->SrcReg[1], machine, b );
+               result[0] = (a[0] != b[0]) ? 1.0F : 0.0F;
+               result[1] = (a[1] != b[1]) ? 1.0F : 0.0F;
+               result[2] = (a[2] != b[2]) ? 1.0F : 0.0F;
+               result[3] = (a[3] != b[3]) ? 1.0F : 0.0F;
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_STR: /* set true, operands ignored */
+            {
+               static const GLfloat result[4] = { 1.0F, 1.0F, 1.0F, 1.0F };
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_SUB:
+            {
+               GLfloat a[4], b[4], result[4];
+               fetch_vector4( &inst->SrcReg[0], machine, a );
+               fetch_vector4( &inst->SrcReg[1], machine, b );
+               result[0] = a[0] - b[0];
+               result[1] = a[1] - b[1];
+               result[2] = a[2] - b[2];
+               result[3] = a[3] - b[3];
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
          case FP_OPCODE_TEX:
             /* Texel lookup */
             {
                GLfloat texcoord[4], color[4];
                fetch_vector4( &inst->SrcReg[0], machine, texcoord );
                fetch_texel( ctx, texcoord, inst->TexSrcUnit,
-                            inst->TexSrcTarget, color );
+                            inst->TexSrcIndex, color );
                store_vector4( &inst->DstReg, machine, color, inst->Saturate,
                               inst->UpdateCondRegister );
             }
@@ -401,7 +754,7 @@ execute_program(GLcontext *ctx, const struct fragment_program *program)
                fetch_vector4( &inst->SrcReg[1], machine, dtdx );
                fetch_vector4( &inst->SrcReg[2], machine, dtdy );
                fetch_texel_deriv( ctx, texcoord, dtdx, dtdy, inst->TexSrcUnit,
-                                  inst->TexSrcTarget, color );
+                                  inst->TexSrcIndex, color );
                store_vector4( &inst->DstReg, machine, color, inst->Saturate,
                               inst->UpdateCondRegister );
             }
@@ -415,17 +768,84 @@ execute_program(GLcontext *ctx, const struct fragment_program *program)
                texcoord[1] /= texcoord[3];
                texcoord[2] /= texcoord[3];
                fetch_texel( ctx, texcoord, inst->TexSrcUnit,
-                            inst->TexSrcTarget, color );
+                            inst->TexSrcIndex, color );
                store_vector4( &inst->DstReg, machine, color, inst->Saturate,
                               inst->UpdateCondRegister );
             }
             break;
+         case FP_OPCODE_UP2H: /* unpack two 16-bit floats */
+            /* XXX this is probably wrong */
+            {
+               GLfloat a[4], result[4];
+               const GLuint *rawBits = (const GLuint *) a;
+               GLuint *rawResult = (GLuint *) result;
+               fetch_vector1( &inst->SrcReg[0], machine, a );
+               rawResult[0] = rawBits[0] & 0xffff;
+               rawResult[1] = (rawBits[0] >> 16) & 0xffff;
+               rawResult[2] = rawBits[0] & 0xffff;
+               rawResult[3] = (rawBits[0] >> 16) & 0xffff;
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_UP2US: /* unpack two GLushorts */
+            {
+               GLfloat a[4], result[4];
+               const GLuint *rawBits = (const GLuint *) a;
+               fetch_vector1( &inst->SrcReg[0], machine, a );
+               result[0] = (GLfloat) ((rawBits[0] >>  0) & 0xffff) / 65535.0F;
+               result[1] = (GLfloat) ((rawBits[0] >> 16) & 0xffff) / 65535.0F;
+               result[2] = result[0];
+               result[3] = result[1];
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_UP4B: /* unpack four GLbytes */
+            {
+               GLfloat a[4], result[4];
+               const GLuint *rawBits = (const GLuint *) a;
+               fetch_vector1( &inst->SrcReg[0], machine, a );
+               result[0] = (((rawBits[0] >>  0) & 0xff) - 128) / 127.0F;
+               result[0] = (((rawBits[0] >>  8) & 0xff) - 128) / 127.0F;
+               result[0] = (((rawBits[0] >> 16) & 0xff) - 128) / 127.0F;
+               result[0] = (((rawBits[0] >> 24) & 0xff) - 128) / 127.0F;
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_UP4UB: /* unpack four GLubytes */
+            {
+               GLfloat a[4], result[4];
+               const GLuint *rawBits = (const GLuint *) a;
+               fetch_vector1( &inst->SrcReg[0], machine, a );
+               result[0] = ((rawBits[0] >>  0) & 0xff) / 255.0F;
+               result[0] = ((rawBits[0] >>  8) & 0xff) / 255.0F;
+               result[0] = ((rawBits[0] >> 16) & 0xff) / 255.0F;
+               result[0] = ((rawBits[0] >> 24) & 0xff) / 255.0F;
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
+         case FP_OPCODE_X2D: /* 2-D matrix transform */
+            {
+               GLfloat a[4], b[4], c[4], result[4];
+               fetch_vector4( &inst->SrcReg[0], machine, a );
+               fetch_vector4( &inst->SrcReg[1], machine, b );
+               fetch_vector4( &inst->SrcReg[2], machine, c );
+               result[0] = a[0] + b[0] * c[0] + b[1] * c[1];
+               result[1] = a[1] + b[0] * c[2] + b[1] * c[3];
+               result[2] = a[2] + b[0] * c[0] + b[1] * c[1];
+               result[3] = a[3] + b[0] * c[2] + b[1] * c[3];
+               store_vector4( &inst->DstReg, machine, result, inst->Saturate,
+                              inst->UpdateCondRegister );
+            }
+            break;
          default:
             _mesa_problem(ctx, "Bad opcode in _mesa_exec_fragment_program");
             return;
       }
    }
-
 }
 
 
@@ -443,7 +863,7 @@ _swrast_exec_nv_fragment_program( GLcontext *ctx, struct sw_span *span )
       const GLfloat *colOut = ctx->FragmentProgram.Machine.Registers[FP_OUTPUT_REG_START];
       GLuint j;
 
-      /* Clear temporary registers */
+      /* Clear temporary registers XXX use memzero() */
       for (j = 0; j < MAX_NV_FRAGMENT_PROGRAM_TEMPS; j++) {
          ctx->FragmentProgram.Machine.Registers[FP_TEMP_REG_START+j][0] = 0.0F;
          ctx->FragmentProgram.Machine.Registers[FP_TEMP_REG_START+j][1] = 0.0F;
@@ -451,11 +871,13 @@ _swrast_exec_nv_fragment_program( GLcontext *ctx, struct sw_span *span )
          ctx->FragmentProgram.Machine.Registers[FP_TEMP_REG_START+j][3] = 0.0F;
       }
 
-      /* Load input registers */
+      /*
+       * Load input registers - yes this is all very inefficient for now.
+       */
       wpos[0] = span->x + i;
       wpos[1] = span->y + i;
       wpos[2] = span->array->z[i];
-      wpos[3] = 1.0;
+      wpos[3] = 1.0; /* XXX should be 1/w */
 
       col0[0] = CHAN_TO_FLOAT(span->array->rgba[i][RCOMP]);
       col0[1] = CHAN_TO_FLOAT(span->array->rgba[i][GCOMP]);
@@ -468,6 +890,20 @@ _swrast_exec_nv_fragment_program( GLcontext *ctx, struct sw_span *span )
       col1[3] = CHAN_TO_FLOAT(span->array->spec[i][ACOMP]);
 
       fogc[0] = span->array->fog[i];
+      fogc[1] = 0.0F;
+      fogc[2] = 0.0F;
+      fogc[3] = 0.0F;
+
+      for (j = 0; j < ctx->Const.MaxTextureCoordUnits; j++) {
+         if (ctx->Texture.Unit[j]._ReallyEnabled) {
+            COPY_4V(ctx->FragmentProgram.Machine.Registers[4 + j],
+                    span->array->texcoords[j][i]);
+         }
+         else {
+            COPY_4V(ctx->FragmentProgram.Machine.Registers[4 + j],
+                    ctx->Current.Attrib[VERT_ATTRIB_TEX0 + j]);
+         }
+      }
 
       execute_program(ctx, ctx->FragmentProgram.Current);