Beispiel #1
0
        public GPUFetchDataType ReadFetchDataType()
        {
            if (_Current >= _Params.Length)
            {
                return(0);
            }

            GPUFetchDataType ret = 0;
            var str = ReadString();

            System.Enum.TryParse <GPUFetchDataType>(str, out ret);
            return(ret);
        }
Beispiel #2
0
        private static bool Convert(Byte[] data, int offset, GPUFetchFormat format, GPUFetchDataType dataType, string[] values, ref int numStr)
        {
            switch (format)
            {
            case GPUFetchFormat.FMT_8:
            {
                values[numStr++] = Convert(data, offset + 0, 1, dataType);
                return(false);
            }

            case GPUFetchFormat.FMT_8_8_8_8:
            {
                values[numStr++] = Convert(data, offset + 0, 1, dataType);
                values[numStr++] = Convert(data, offset + 1, 1, dataType);
                values[numStr++] = Convert(data, offset + 2, 1, dataType);
                values[numStr++] = Convert(data, offset + 3, 1, dataType);
                return(true);
            }

            case GPUFetchFormat.FMT_2_10_10_10:
            {
                values[numStr++] = "FMT_2_10_10_10.X";
                values[numStr++] = "FMT_2_10_10_10.Y";
                values[numStr++] = "FMT_2_10_10_10.Z";
                values[numStr++] = "FMT_2_10_10_10.W";
                return(true);
            }

            case GPUFetchFormat.FMT_8_8:
            {
                values[numStr++] = Convert(data, offset + 0, 1, dataType);
                values[numStr++] = Convert(data, offset + 1, 1, dataType);
                return(true);
            }

            case GPUFetchFormat.FMT_16:
            {
                values[numStr++] = Convert(data, offset + 0, 2, dataType);
                return(true);
            }

            case GPUFetchFormat.FMT_16_16:
            {
                values[numStr++] = Convert(data, offset + 0, 2, dataType);
                values[numStr++] = Convert(data, offset + 2, 2, dataType);
                return(true);
            }

            case GPUFetchFormat.FMT_16_16_16_16:
            {
                values[numStr++] = Convert(data, offset + 0, 2, dataType);
                values[numStr++] = Convert(data, offset + 2, 2, dataType);
                values[numStr++] = Convert(data, offset + 4, 2, dataType);
                values[numStr++] = Convert(data, offset + 6, 2, dataType);
                return(true);
            }

            case GPUFetchFormat.FMT_32:
            {
                values[numStr++] = Convert(data, offset + 0, 4, dataType);
                return(true);
            }

            case GPUFetchFormat.FMT_32_32:
            {
                values[numStr++] = Convert(data, offset + 0, 4, dataType);
                values[numStr++] = Convert(data, offset + 4, 4, dataType);
                return(true);
            }

            case GPUFetchFormat.FMT_32_32_32_32:
            {
                values[numStr++] = Convert(data, offset + 0, 4, dataType);
                values[numStr++] = Convert(data, offset + 4, 4, dataType);
                values[numStr++] = Convert(data, offset + 8, 4, dataType);
                values[numStr++] = Convert(data, offset + 12, 4, dataType);
                return(true);
            }

            case GPUFetchFormat.FMT_32_FLOAT:
            {
                values[numStr++] = Convert(data, offset + 0, 4, GPUFetchDataType.FLOAT);
                return(true);
            }

            case GPUFetchFormat.FMT_32_32_FLOAT:
            {
                values[numStr++] = Convert(data, offset + 0, 4, GPUFetchDataType.FLOAT);
                values[numStr++] = Convert(data, offset + 4, 4, GPUFetchDataType.FLOAT);
                return(true);
            }

            case GPUFetchFormat.FMT_32_32_32_32_FLOAT:
            {
                values[numStr++] = Convert(data, offset + 0, 4, GPUFetchDataType.FLOAT);
                values[numStr++] = Convert(data, offset + 4, 4, GPUFetchDataType.FLOAT);
                values[numStr++] = Convert(data, offset + 8, 4, GPUFetchDataType.FLOAT);
                values[numStr++] = Convert(data, offset + 12, 4, GPUFetchDataType.FLOAT);
                return(true);
            }

            case GPUFetchFormat.FMT_32_32_32_FLOAT:
            {
                values[numStr++] = Convert(data, offset + 0, 4, GPUFetchDataType.FLOAT);
                values[numStr++] = Convert(data, offset + 4, 4, GPUFetchDataType.FLOAT);
                values[numStr++] = Convert(data, offset + 8, 4, GPUFetchDataType.FLOAT);
                return(true);
            }
            }

            return(false);
        }
Beispiel #3
0
        private static string Convert(Byte[] data, int offset, UInt32 numBytes, GPUFetchDataType dataType)
        {
            switch (dataType)
            {
            case GPUFetchDataType.UINT:
            {
                if (numBytes == 1)
                {
                    return(data[offset].ToString());
                }
                else if (numBytes == 2)
                {
                    return(BitConverter.ToUInt16(data, offset).ToString());
                }
                else if (numBytes == 4)
                {
                    return(BitConverter.ToUInt32(data, offset).ToString());
                }
                break;
            }

            case GPUFetchDataType.UNORM:
            {
                if (numBytes == 1)
                {
                    var val = data[offset];
                    return(((float)val / (float)byte.MaxValue).ToString());
                }
                else if (numBytes == 2)
                {
                    var val = BitConverter.ToUInt16(data, offset);
                    return(((float)val / (float)UInt16.MaxValue).ToString());
                }
                else if (numBytes == 4)
                {
                    var val = BitConverter.ToUInt32(data, offset);
                    return(((double)val / (double)UInt32.MaxValue).ToString());
                }
                break;
            }

            case GPUFetchDataType.SINT:
            {
                if (numBytes == 1)
                {
                    return(((Char)data[offset]).ToString());
                }
                else if (numBytes == 2)
                {
                    return(BitConverter.ToInt16(data, offset).ToString());
                }
                else if (numBytes == 4)
                {
                    return(BitConverter.ToInt32(data, offset).ToString());
                }
                break;
            }

            case GPUFetchDataType.SNORM:
            {
                if (numBytes == 1)
                {
                    var val = (char)data[offset];
                    return(((float)val / (float)char.MaxValue).ToString());
                }
                else if (numBytes == 2)
                {
                    var val = BitConverter.ToInt16(data, offset);
                    return(((float)val / (float)Int16.MaxValue).ToString());
                }
                else if (numBytes == 4)
                {
                    var val = BitConverter.ToInt32(data, offset);
                    return(((double)val / (double)Int32.MaxValue).ToString());
                }
                break;
            }

            case GPUFetchDataType.FLOAT:
            {
                if (numBytes == 4)
                {
                    var val = BitConverter.ToSingle(data, offset);
                    return(val.ToString());
                }
                break;
            }
            }

            return("UNKNOWN");
        }