Пример #1
0
        public static AlphaFunction GetAlphaFunction(GXCompareType compareType)
        {
            switch (compareType)
            {
            case GXCompareType.Never:
                return(AlphaFunction.Never);

            case GXCompareType.Less:
                return(AlphaFunction.Less);

            case GXCompareType.Equal:
                return(AlphaFunction.Equal);

            case GXCompareType.LEqual:
                return(AlphaFunction.Lequal);

            case GXCompareType.Greater:
                return(AlphaFunction.Greater);

            case GXCompareType.NEqual:
                return(AlphaFunction.Notequal);

            case GXCompareType.GEqual:
                return(AlphaFunction.Gequal);

            case GXCompareType.Always:
                return(AlphaFunction.Always);

            default:
                return(AlphaFunction.Always);
            }
        }
Пример #2
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public static DepthFunction toDepthFunction(GXCompareType type)
        {
            switch (type)
            {
            case GXCompareType.Always:
                return(DepthFunction.Always);

            case GXCompareType.Equal:
                return(DepthFunction.Equal);

            case GXCompareType.GEqual:
                return(DepthFunction.Gequal);

            case GXCompareType.Greater:
                return(DepthFunction.Greater);

            case GXCompareType.LEqual:
                return(DepthFunction.Lequal);

            case GXCompareType.Less:
                return(DepthFunction.Less);

            case GXCompareType.NEqual:
                return(DepthFunction.Notequal);

            case GXCompareType.Never:
                return(DepthFunction.Never);
            }
            return(DepthFunction.Never);
        }
Пример #3
0
        public static DepthFunction GetOpenGLDepthFunc(GXCompareType gxCompare)
        {
            switch (gxCompare)
            {
            case GXCompareType.Never: return(DepthFunction.Never);

            case GXCompareType.Less: return(DepthFunction.Less);

            case GXCompareType.Equal: return(DepthFunction.Equal);

            case GXCompareType.LEqual: return(DepthFunction.Lequal);

            case GXCompareType.Greater: return(DepthFunction.Greater);

            case GXCompareType.NEqual: return(DepthFunction.Notequal);

            case GXCompareType.GEqual: return(DepthFunction.Gequal);

            case GXCompareType.Always: return(DepthFunction.Always);

            default:
                WLog.Warning(LogCategory.Rendering, null, "Unsupported GXCompareType: \"{0}\" in GetOpenGLDepthFunc!", gxCompare);
                return(DepthFunction.Less);
            }
        }
Пример #4
0
 public AlphaCompare(GXCompareType com0, byte ref0, GXAlphaOp op, GXCompareType com1, byte ref2)
 {
     Comp0      = com0;
     Reference0 = ref0;
     Operation  = op;
     Comp1      = com1;
     Reference1 = ref2;
 }
Пример #5
0
 public static DepthFunction GetOpenGLDepthFunc(GXCompareType gxCompare)
 {
     switch (gxCompare)
     {
         case GXCompareType.Never: return DepthFunction.Never;
         case GXCompareType.Less: return DepthFunction.Less;
         case GXCompareType.Equal: return DepthFunction.Equal;
         case GXCompareType.LEqual: return DepthFunction.Lequal;
         case GXCompareType.Greater: return DepthFunction.Greater;
         case GXCompareType.NEqual: return DepthFunction.Notequal;
         case GXCompareType.GEqual: return DepthFunction.Gequal;
         case GXCompareType.Always: return DepthFunction.Always;
         default:
             WLog.Warning(LogCategory.Rendering, null, "Unsupported GXCompareType: \"{0}\" in GetOpenGLDepthFunc!", gxCompare);
             return DepthFunction.Less;
     }
 }
Пример #6
0
        private static string GetCompareString(GXCompareType compare, string a, byte refVal)
        {
            string outStr = "";
            float  fRef   = refVal / 255f;

            if (compare != GXCompareType.Always)
            {
                WLog.Warning(LogCategory.TEVShaderGenerator, null, "Untested alpha-test functionality: {0}", compare);
            }

            switch (compare)
            {
            case GXCompareType.Never: outStr = "false"; break;

            case GXCompareType.Less: outStr = "<"; break;

            case GXCompareType.Equal: outStr = "=="; break;

            case GXCompareType.LEqual: outStr = "<="; break;

            case GXCompareType.Greater: outStr = ">"; break;

            case GXCompareType.NEqual: outStr = "!="; break;

            case GXCompareType.GEqual: outStr = ">="; break;

            case GXCompareType.Always: outStr = "true"; break;

            default:
                WLog.Warning(LogCategory.TEVShaderGenerator, null, "Invalid comparison function, defaulting to always.");
                outStr = "true";
                break;
            }

            if (outStr == "false" || outStr == "true")
            {
                return(outStr);
            }

            return(string.Format("{0} {1} {2}", a, outStr, fRef));
        }
Пример #7
0
 public ZMode(bool enabled, GXCompareType func, bool updateEnabled)
 {
     Enable       = enabled;
     Function     = func;
     UpdateEnable = updateEnabled;
 }