Connecting the dots for some built-in functions

- Completed implementation of round
  and hyperbolic trigonometry operations
- Added a few more cases in op to string
  functions

Change-Id: Ic09d228de8e4446a66152b70edc6a6bba511288a
Reviewed-on: https://swiftshader-review.googlesource.com/2891
Tested-by: Alexis Hétu <sugoi@google.com>
Reviewed-by: Nicolas Capens <capn@google.com>

diff --git a/src/OpenGL/compiler/Intermediate.cpp b/src/OpenGL/compiler/Intermediate.cpp
index 37de4ae..0ebab3a 100644 (file)
--- a/src/OpenGL/compiler/Intermediate.cpp
+++ b/src/OpenGL/compiler/Intermediate.cpp
@@ -80,6 +80,12 @@ const char* getOperatorString(TOperator op) {
       case EOpAsin: return "asin";
       case EOpAcos: return "acos";
       case EOpAtan: return "atan";
+      case EOpSinh: return "sinh";
+      case EOpCosh: return "cosh";
+      case EOpTanh: return "tanh";
+      case EOpAsinh: return "asinh";
+      case EOpAcosh: return "acosh";
+      case EOpAtanh: return "atanh";
       case EOpExp: return "exp";
       case EOpLog: return "log";
       case EOpExp2: return "exp2";
@@ -89,6 +95,9 @@ const char* getOperatorString(TOperator op) {
       case EOpAbs: return "abs";
       case EOpSign: return "sign";
       case EOpFloor: return "floor";
+      case EOpTrunc: return "trunc";
+      case EOpRound: return "round";
+      case EOpRoundEven: return "roundEven";
       case EOpCeil: return "ceil";
       case EOpFract: return "fract";
       case EOpLength: return "length";
@@ -98,6 +107,8 @@ const char* getOperatorString(TOperator op) {
       case EOpFwidth: return "fwidth";
       case EOpAny: return "any";
       case EOpAll: return "all";
+      case EOpIsNan: return "isnan";
+      case EOpIsInf: return "isinf";
 
       default: break;
     }

diff --git a/src/OpenGL/compiler/OutputASM.cpp b/src/OpenGL/compiler/OutputASM.cpp
index aae86fe..c8bb014 100644 (file)
--- a/src/OpenGL/compiler/OutputASM.cpp
+++ b/src/OpenGL/compiler/OutputASM.cpp
@@ -624,6 +624,12 @@ namespace glsl
                case EOpAsin:             if(visit == PostVisit) emit(sw::Shader::OPCODE_ASIN, result, arg); break;\r
                case EOpAcos:             if(visit == PostVisit) emit(sw::Shader::OPCODE_ACOS, result, arg); break;\r
                case EOpAtan:             if(visit == PostVisit) emit(sw::Shader::OPCODE_ATAN, result, arg); break;\r
+               case EOpSinh:             if(visit == PostVisit) emit(sw::Shader::OPCODE_SINH, result, arg); break;\r
+               case EOpCosh:             if(visit == PostVisit) emit(sw::Shader::OPCODE_COSH, result, arg); break;\r
+               case EOpTanh:             if(visit == PostVisit) emit(sw::Shader::OPCODE_TANH, result, arg); break;\r
+               case EOpAsinh:            if(visit == PostVisit) emit(sw::Shader::OPCODE_ASINH, result, arg); break;\r
+               case EOpAcosh:            if(visit == PostVisit) emit(sw::Shader::OPCODE_ACOSH, result, arg); break;\r
+               case EOpAtanh:            if(visit == PostVisit) emit(sw::Shader::OPCODE_ATANH, result, arg); break;\r
                case EOpExp:              if(visit == PostVisit) emit(sw::Shader::OPCODE_EXP, result, arg); break;\r
                case EOpLog:              if(visit == PostVisit) emit(sw::Shader::OPCODE_LOG, result, arg); break;\r
                case EOpExp2:             if(visit == PostVisit) emit(sw::Shader::OPCODE_EXP2, result, arg); break;\r
@@ -633,8 +639,13 @@ namespace glsl
                case EOpAbs:              if(visit == PostVisit) emit(sw::Shader::OPCODE_ABS, result, arg); break;\r
                case EOpSign:             if(visit == PostVisit) emit(sw::Shader::OPCODE_SGN, result, arg); break;\r
                case EOpFloor:            if(visit == PostVisit) emit(sw::Shader::OPCODE_FLOOR, result, arg); break;\r
+               case EOpTrunc:            if(visit == PostVisit) emit(sw::Shader::OPCODE_TRUNC, result, arg); break;\r
+               case EOpRound:            if(visit == PostVisit) emit(sw::Shader::OPCODE_ROUND, result, arg); break;\r
+               case EOpRoundEven:        if(visit == PostVisit) emit(sw::Shader::OPCODE_ROUNDEVEN, result, arg); break;\r
                case EOpCeil:             if(visit == PostVisit) emit(sw::Shader::OPCODE_CEIL, result, arg, result); break;\r
                case EOpFract:            if(visit == PostVisit) emit(sw::Shader::OPCODE_FRC, result, arg); break;\r
+               case EOpIsNan:            if(visit == PostVisit) emit(sw::Shader::OPCODE_ISNAN, result, arg); break;\r
+               case EOpIsInf:            if(visit == PostVisit) emit(sw::Shader::OPCODE_ISINF, result, arg); break;\r
                case EOpLength:           if(visit == PostVisit) emit(sw::Shader::OPCODE_LEN(dim(arg)), result, arg); break;\r
                case EOpNormalize:        if(visit == PostVisit) emit(sw::Shader::OPCODE_NRM(dim(arg)), result, arg); break;\r
                case EOpDFdx:             if(visit == PostVisit) emit(sw::Shader::OPCODE_DFDX, result, arg); break;\r
@@ -1024,6 +1035,16 @@ namespace glsl
                case EOpMix:         if(visit == PostVisit) emit(sw::Shader::OPCODE_LRP, result, arg[2], arg[1], arg[0]); break;\r
                case EOpStep:        if(visit == PostVisit) emit(sw::Shader::OPCODE_STEP, result, arg[0], arg[1]); break;\r
                case EOpSmoothStep:  if(visit == PostVisit) emit(sw::Shader::OPCODE_SMOOTH, result, arg[0], arg[1], arg[2]); break;\r
+               case EOpFloatBitsToInt:  if(visit == PostVisit) emit(sw::Shader::OPCODE_FLOATBITSTOINT, result, arg[0]); break;\r
+               case EOpFloatBitsToUint: if(visit == PostVisit) emit(sw::Shader::OPCODE_FLOATBITSTOUINT, result, arg[0]); break;\r
+               case EOpIntBitsToFloat:  if(visit == PostVisit) emit(sw::Shader::OPCODE_INTBITSTOFLOAT, result, arg[0]); break;\r
+               case EOpUintBitsToFloat: if(visit == PostVisit) emit(sw::Shader::OPCODE_UINTBITSTOFLOAT, result, arg[0]); break;\r
+               case EOpPackSnorm2x16:   if(visit == PostVisit) emit(sw::Shader::OPCODE_PACKSNORM2x16, result, arg[0]); break;\r
+               case EOpPackUnorm2x16:   if(visit == PostVisit) emit(sw::Shader::OPCODE_PACKUNORM2x16, result, arg[0]); break;\r
+               case EOpPackHalf2x16:    if(visit == PostVisit) emit(sw::Shader::OPCODE_PACKHALF2x16, result, arg[0]); break;\r
+               case EOpUnpackSnorm2x16: if(visit == PostVisit) emit(sw::Shader::OPCODE_UNPACKSNORM2x16, result, arg[0]); break;\r
+               case EOpUnpackUnorm2x16: if(visit == PostVisit) emit(sw::Shader::OPCODE_UNPACKUNORM2x16, result, arg[0]); break;\r
+               case EOpUnpackHalf2x16:  if(visit == PostVisit) emit(sw::Shader::OPCODE_UNPACKHALF2x16, result, arg[0]); break;\r
                case EOpDistance:    if(visit == PostVisit) emit(sw::Shader::OPCODE_DIST(dim(arg[0])), result, arg[0], arg[1]); break;\r
                case EOpDot:         if(visit == PostVisit) emit(sw::Shader::OPCODE_DP(dim(arg[0])), result, arg[0], arg[1]); break;\r
                case EOpCross:       if(visit == PostVisit) emit(sw::Shader::OPCODE_CRS, result, arg[0], arg[1]); break;\r

diff --git a/src/OpenGL/compiler/intermOut.cpp b/src/OpenGL/compiler/intermOut.cpp
index f71eea4..81b088d 100644 (file)
--- a/src/OpenGL/compiler/intermOut.cpp
+++ b/src/OpenGL/compiler/intermOut.cpp
@@ -160,6 +160,12 @@ bool TOutputTraverser::visitUnary(Visit visit, TIntermUnary* node)
         case EOpAsin:           out << "arc sine";             break;
         case EOpAcos:           out << "arc cosine";           break;
         case EOpAtan:           out << "arc tangent";          break;
+        case EOpSinh:           out << "hyperbolic sine";        break;
+        case EOpCosh:           out << "hyperbolic cosine";      break;
+        case EOpTanh:           out << "hyperbolic tangent";     break;
+        case EOpAsinh:          out << "arc hyperbolic sine";    break;
+        case EOpAcosh:          out << "arc hyperbolic cosine";  break;
+        case EOpAtanh:          out << "arc hyperbolic tangent"; break;
 
         case EOpExp:            out << "exp";                  break;
         case EOpLog:            out << "log";                  break;
@@ -171,8 +177,26 @@ bool TOutputTraverser::visitUnary(Visit visit, TIntermUnary* node)
         case EOpAbs:            out << "Absolute value";       break;
         case EOpSign:           out << "Sign";                 break;
         case EOpFloor:          out << "Floor";                break;
+        case EOpTrunc:          out << "Trunc";                break;
+        case EOpRound:          out << "Round";                break;
+        case EOpRoundEven:      out << "RoundEven";            break;
         case EOpCeil:           out << "Ceiling";              break;
         case EOpFract:          out << "Fraction";             break;
+        case EOpIsNan:          out << "Is not a number";      break;
+        case EOpIsInf:          out << "Is infinity";          break;
+
+        case EOpFloatBitsToInt: out << "float bits to int";    break;
+        case EOpFloatBitsToUint: out << "float bits to uint";  break;
+        case EOpIntBitsToFloat: out << "int bits to float";    break;
+        case EOpUintBitsToFloat: out << "uint bits to float";  break;
+
+        case EOpPackSnorm2x16:  out << "pack Snorm 2x16";      break;
+        case EOpPackUnorm2x16:  out << "pack Unorm 2x16";      break;
+        case EOpPackHalf2x16:   out << "pack half 2x16";       break;
+
+        case EOpUnpackSnorm2x16: out << "unpack Snorm 2x16";   break;
+        case EOpUnpackUnorm2x16: out << "unpack Unorm 2x16";   break;
+        case EOpUnpackHalf2x16:  out << "unpack half 2x16";    break;
 
         case EOpLength:         out << "length";               break;
         case EOpNormalize:      out << "normalize";            break;
@@ -180,6 +204,10 @@ bool TOutputTraverser::visitUnary(Visit visit, TIntermUnary* node)
             // case EOpDPdy:           out << "dPdy";                 break;   
             // case EOpFwidth:         out << "fwidth";               break;                   
 
+        case EOpDeterminant:    out << "determinant";          break;
+        case EOpTranspose:      out << "transpose";            break;
+        case EOpInverse:        out << "inverse";              break;
+
         case EOpAny:            out << "any";                  break;
         case EOpAll:            out << "all";                  break;
 
@@ -258,6 +286,7 @@ bool TOutputTraverser::visitAggregate(Visit visit, TIntermAggregate* node)
         case EOpReflect:       out << "reflect";                 break;
         case EOpRefract:       out << "refract";                 break;
         case EOpMul:           out << "component-wise multiply"; break;
+        case EOpOuterProduct:  out << "outer product";           break;
 
         default: out.message(EPrefixError, "Bad aggregation op");
     }

diff --git a/src/Shader/PixelRoutine.cpp b/src/Shader/PixelRoutine.cpp
index e6a83c6..b9f3ab9 100644 (file)
--- a/src/Shader/PixelRoutine.cpp
+++ b/src/Shader/PixelRoutine.cpp
@@ -4042,6 +4042,7 @@ namespace sw
                        case Shader::OPCODE_FRC:                frc(d, s0);                                                                             break;
                        case Shader::OPCODE_TRUNC:      trunc(d, s0);                                   break;
                        case Shader::OPCODE_FLOOR:      floor(d, s0);                                   break;
+                       case Shader::OPCODE_ROUND:              round(d, s0);                                   break;
                        case Shader::OPCODE_CEIL:       ceil(d, s0);                                    break;
                        case Shader::OPCODE_EXP2X:              exp2x(d, s0, pp);                                                               break;
                        case Shader::OPCODE_EXP2:               exp2(d, s0, pp);                                                                break;
@@ -4095,6 +4096,12 @@ namespace sw
                        case Shader::OPCODE_ASIN:               asin(d, s0, pp);                                                                break;
                        case Shader::OPCODE_ATAN:               atan(d, s0, pp);                                                                break;
                        case Shader::OPCODE_ATAN2:              atan2(d, s0, s1, pp);                                                   break;
+                       case Shader::OPCODE_COSH:               cosh(d, s0, pp);                                                                break;
+                       case Shader::OPCODE_SINH:               sinh(d, s0, pp);                                                                break;
+                       case Shader::OPCODE_TANH:               tanh(d, s0, pp);                                                                break;
+                       case Shader::OPCODE_ACOSH:              acosh(d, s0, pp);                                                               break;
+                       case Shader::OPCODE_ASINH:              asinh(d, s0, pp);                                                               break;
+                       case Shader::OPCODE_ATANH:              atanh(d, s0, pp);                                                               break;
                        case Shader::OPCODE_M4X4:               M4X4(r, d, s0, src1);                                                   break;
                        case Shader::OPCODE_M4X3:               M4X3(r, d, s0, src1);                                                   break;
                        case Shader::OPCODE_M3X4:               M3X4(r, d, s0, src1);                                                   break;

diff --git a/src/Shader/Shader.cpp b/src/Shader/Shader.cpp
index 88bb4b0..f00a6a8 100644 (file)
--- a/src/Shader/Shader.cpp
+++ b/src/Shader/Shader.cpp
@@ -764,6 +764,16 @@ namespace sw
                case OPCODE_LRP:                        return "lrp";
                case OPCODE_STEP:                       return "step";
                case OPCODE_SMOOTH:                     return "smooth";
+               case OPCODE_FLOATBITSTOINT:      return "floatBitsToInt";
+               case OPCODE_FLOATBITSTOUINT: return "floatBitsToUInt";
+               case OPCODE_INTBITSTOFLOAT:      return "intBitsToFloat";
+               case OPCODE_UINTBITSTOFLOAT: return "uintBitsToFloat";
+               case OPCODE_PACKSNORM2x16:       return "packSnorm2x16";
+               case OPCODE_PACKUNORM2x16:       return "packUnorm2x16";
+               case OPCODE_PACKHALF2x16:        return "packHalf2x16";
+               case OPCODE_UNPACKSNORM2x16: return "unpackSnorm2x16";
+               case OPCODE_UNPACKUNORM2x16: return "unpackUnorm2x16";
+               case OPCODE_UNPACKHALF2x16:      return "unpackHalf2x16";
                case OPCODE_FRC:                        return "frc";
                case OPCODE_M4X4:                       return "m4x4";
                case OPCODE_M4X3:                       return "m4x3";
@@ -864,10 +874,18 @@ namespace sw
                case OPCODE_ASIN:           return "asin";
                case OPCODE_ATAN:           return "atan";
                case OPCODE_ATAN2:          return "atan2";
+               case OPCODE_COSH:           return "cosh";
+               case OPCODE_SINH:           return "sinh";
+               case OPCODE_TANH:           return "tanh";
+               case OPCODE_ACOSH:          return "acosh";
+               case OPCODE_ASINH:          return "asinh";
+               case OPCODE_ATANH:          return "atanh";
                case OPCODE_DP1:            return "dp1";
                case OPCODE_DP2:            return "dp2";
                case OPCODE_TRUNC:          return "trunc";
                case OPCODE_FLOOR:          return "floor";
+               case OPCODE_ROUND:          return "round";
+               case OPCODE_ROUNDEVEN:      return "roundEven";
                case OPCODE_CEIL:           return "ceil";
                case OPCODE_EXP2:           return "exp2";
                case OPCODE_LOG2:           return "log2";
@@ -878,6 +896,8 @@ namespace sw
                case OPCODE_B2F:            return "b2f";
                case OPCODE_ALL:            return "all";
                case OPCODE_ANY:            return "any";
+               case OPCODE_ISNAN:          return "isnan";
+               case OPCODE_ISINF:          return "isinf";
                case OPCODE_NOT:            return "not";
                case OPCODE_OR:             return "or";
                case OPCODE_XOR:            return "xor";

diff --git a/src/Shader/Shader.hpp b/src/Shader/Shader.hpp
index 898e96e..8c4fe3d 100644 (file)
--- a/src/Shader/Shader.hpp
+++ b/src/Shader/Shader.hpp
@@ -52,6 +52,8 @@ namespace sw
                        OPCODE_ATT,   // D3DSIO_DST\r
                        OPCODE_LRP,\r
                        OPCODE_FRC,\r
+                       OPCODE_ISNAN,\r
+                       OPCODE_ISINF,\r
                        OPCODE_M4X4,\r
                        OPCODE_M4X3,\r
                        OPCODE_M3X4,\r
@@ -147,10 +149,18 @@ namespace sw
                        OPCODE_ASIN,\r
                        OPCODE_ATAN,\r
                        OPCODE_ATAN2,\r
+                       OPCODE_COSH,\r
+                       OPCODE_SINH,\r
+                       OPCODE_TANH,\r
+                       OPCODE_ACOSH,\r
+                       OPCODE_ASINH,\r
+                       OPCODE_ATANH,\r
                        OPCODE_DP1,\r
                        OPCODE_DP2,\r
                        OPCODE_TRUNC,\r
                        OPCODE_FLOOR,\r
+                       OPCODE_ROUND,\r
+                       OPCODE_ROUNDEVEN,\r
                        OPCODE_CEIL,\r
                        OPCODE_SQRT,\r
                        OPCODE_RSQ,\r
@@ -180,6 +190,16 @@ namespace sw
                        OPCODE_AND,\r
                        OPCODE_STEP,\r
                        OPCODE_SMOOTH,\r
+                       OPCODE_FLOATBITSTOINT,\r
+                       OPCODE_FLOATBITSTOUINT,\r
+                       OPCODE_INTBITSTOFLOAT,\r
+                       OPCODE_UINTBITSTOFLOAT,\r
+                       OPCODE_PACKSNORM2x16,\r
+                       OPCODE_PACKUNORM2x16,\r
+                       OPCODE_PACKHALF2x16,\r
+                       OPCODE_UNPACKSNORM2x16,\r
+                       OPCODE_UNPACKUNORM2x16,\r
+                       OPCODE_UNPACKHALF2x16,\r
                        OPCODE_FORWARD1,\r
                        OPCODE_FORWARD2,\r
                        OPCODE_FORWARD3,\r

diff --git a/src/Shader/VertexProgram.cpp b/src/Shader/VertexProgram.cpp
index 7cd1daa..a2b4537 100644 (file)
--- a/src/Shader/VertexProgram.cpp
+++ b/src/Shader/VertexProgram.cpp
@@ -118,9 +118,9 @@ namespace sw
                        Vector4f s1;
                        Vector4f s2;
 
-                       if(src0.type != Shader::PARAMETER_VOID) s0 = reg(r, src0);
-                       if(src1.type != Shader::PARAMETER_VOID) s1 = reg(r, src1);
-                       if(src2.type != Shader::PARAMETER_VOID) s2 = reg(r, src2);
+                       if(src0.type != Shader::PARAMETER_VOID) s0 = fetchRegisterF(r, src0);
+                       if(src1.type != Shader::PARAMETER_VOID) s1 = fetchRegisterF(r, src1);
+                       if(src2.type != Shader::PARAMETER_VOID) s2 = fetchRegisterF(r, src2);
 
                        switch(opcode)
                        {
@@ -163,6 +163,7 @@ namespace sw
                        case Shader::OPCODE_FRC:                frc(d, s0);                                             break;
                        case Shader::OPCODE_TRUNC:      trunc(d, s0);                   break;
                        case Shader::OPCODE_FLOOR:      floor(d, s0);                   break;
+                       case Shader::OPCODE_ROUND:      round(d, s0);                   break;
                        case Shader::OPCODE_CEIL:       ceil(d, s0);                    break;
                        case Shader::OPCODE_LIT:                lit(d, s0);                                             break;
                        case Shader::OPCODE_LOG2X:              log2x(d, s0, pp);                               break;
@@ -213,6 +214,12 @@ namespace sw
                        case Shader::OPCODE_ASIN:               asin(d, s0);                                    break;
                        case Shader::OPCODE_ATAN:               atan(d, s0);                                    break;
                        case Shader::OPCODE_ATAN2:              atan2(d, s0, s1);                               break;
+                       case Shader::OPCODE_COSH:               cosh(d, s0, pp);                                break;
+                       case Shader::OPCODE_SINH:               sinh(d, s0, pp);                                break;
+                       case Shader::OPCODE_TANH:               tanh(d, s0, pp);                                break;
+                       case Shader::OPCODE_ACOSH:              acosh(d, s0, pp);                               break;
+                       case Shader::OPCODE_ASINH:              asinh(d, s0, pp);                               break;
+                       case Shader::OPCODE_ATANH:              atanh(d, s0, pp);                               break;
                        case Shader::OPCODE_SLT:                slt(d, s0, s1);                                 break;
                        case Shader::OPCODE_SUB:                sub(d, s0, s1);                                 break;
                        case Shader::OPCODE_BREAK:              BREAK(r);                                               break;
@@ -596,7 +603,7 @@ namespace sw
                }
        }
 
-       Vector4f VertexProgram::reg(Registers &r, const Src &src, int offset)
+       Vector4f VertexProgram::fetchRegisterF(Registers &r, const Src &src, int offset)
        {
                int i = src.index + offset;
 
@@ -859,8 +866,8 @@ namespace sw
 
        void VertexProgram::M3X2(Registers &r, Vector4f &dst, Vector4f &src0, Src &src1)
        {
-               Vector4f row0 = reg(r, src1, 0);
-               Vector4f row1 = reg(r, src1, 1);
+               Vector4f row0 = fetchRegisterF(r, src1, 0);
+               Vector4f row1 = fetchRegisterF(r, src1, 1);
 
                dst.x = dot3(src0, row0);
                dst.y = dot3(src0, row1);
@@ -868,9 +875,9 @@ namespace sw
 
        void VertexProgram::M3X3(Registers &r, Vector4f &dst, Vector4f &src0, Src &src1)
        {
-               Vector4f row0 = reg(r, src1, 0);
-               Vector4f row1 = reg(r, src1, 1);
-               Vector4f row2 = reg(r, src1, 2);
+               Vector4f row0 = fetchRegisterF(r, src1, 0);
+               Vector4f row1 = fetchRegisterF(r, src1, 1);
+               Vector4f row2 = fetchRegisterF(r, src1, 2);
 
                dst.x = dot3(src0, row0);
                dst.y = dot3(src0, row1);
@@ -879,10 +886,10 @@ namespace sw
 
        void VertexProgram::M3X4(Registers &r, Vector4f &dst, Vector4f &src0, Src &src1)
        {
-               Vector4f row0 = reg(r, src1, 0);
-               Vector4f row1 = reg(r, src1, 1);
-               Vector4f row2 = reg(r, src1, 2);
-               Vector4f row3 = reg(r, src1, 3);
+               Vector4f row0 = fetchRegisterF(r, src1, 0);
+               Vector4f row1 = fetchRegisterF(r, src1, 1);
+               Vector4f row2 = fetchRegisterF(r, src1, 2);
+               Vector4f row3 = fetchRegisterF(r, src1, 3);
 
                dst.x = dot3(src0, row0);
                dst.y = dot3(src0, row1);
@@ -892,9 +899,9 @@ namespace sw
 
        void VertexProgram::M4X3(Registers &r, Vector4f &dst, Vector4f &src0, Src &src1)
        {
-               Vector4f row0 = reg(r, src1, 0);
-               Vector4f row1 = reg(r, src1, 1);
-               Vector4f row2 = reg(r, src1, 2);
+               Vector4f row0 = fetchRegisterF(r, src1, 0);
+               Vector4f row1 = fetchRegisterF(r, src1, 1);
+               Vector4f row2 = fetchRegisterF(r, src1, 2);
 
                dst.x = dot4(src0, row0);
                dst.y = dot4(src0, row1);
@@ -903,10 +910,10 @@ namespace sw
 
        void VertexProgram::M4X4(Registers &r, Vector4f &dst, Vector4f &src0, Src &src1)
        {
-               Vector4f row0 = reg(r, src1, 0);
-               Vector4f row1 = reg(r, src1, 1);
-               Vector4f row2 = reg(r, src1, 2);
-               Vector4f row3 = reg(r, src1, 3);
+               Vector4f row0 = fetchRegisterF(r, src1, 0);
+               Vector4f row1 = fetchRegisterF(r, src1, 1);
+               Vector4f row2 = fetchRegisterF(r, src1, 2);
+               Vector4f row3 = fetchRegisterF(r, src1, 3);
 
                dst.x = dot4(src0, row0);
                dst.y = dot4(src0, row1);
@@ -1188,7 +1195,7 @@ namespace sw
                }
                else
                {
-                       Int4 condition = As<Int4>(reg(r, src).x);
+                       Int4 condition = As<Int4>(fetchRegisterF(r, src).x);
                        IF(r, condition);
                }
        }
@@ -1358,7 +1365,7 @@ namespace sw
                Nucleus::setInsertBlock(testBlock);
                r.enableContinue = restoreContinue;
 
-               const Vector4f &src = reg(r, temporaryRegister);
+               const Vector4f &src = fetchRegisterF(r, temporaryRegister);
                Int4 condition = As<Int4>(src.x);
                condition &= r.enableStack[r.enableIndex - 1];
                r.enableStack[r.enableIndex] = condition;
@@ -1453,7 +1460,7 @@ namespace sw
                }
                else
                {
-                       Int index = As<Int>(Float(reg(r, s).x.x));
+                       Int index = As<Int>(Float(fetchRegisterF(r, s).x.x));
 
                        for(int i = 0; i < 16; i++)
                        {

diff --git a/src/Shader/VertexProgram.hpp b/src/Shader/VertexProgram.hpp
index 097f90c..dc2121b 100644 (file)
--- a/src/Shader/VertexProgram.hpp
+++ b/src/Shader/VertexProgram.hpp
@@ -41,7 +41,7 @@ namespace sw
                void program(Registers &r);
                void passThrough(Registers &r);
 
-               Vector4f reg(Registers &r, const Src &src, int offset = 0);
+               Vector4f fetchRegisterF(Registers &r, const Src &src, int offset = 0);
                Vector4f readConstant(Registers &r, const Src &src, int offset = 0);
                Int relativeAddress(Registers &r, const Shader::Parameter &var);
                Int4 enableMask(Registers &r, const Shader::Instruction *instruction);