示例#1
0
 public static ref T or <T>(ref T lhs, T rhs)
     where T : unmanaged
 {
     if (typeof(T) == typeof(float))
     {
         BitConverter.Int32BitsToSingle(BitConverter.SingleToInt32Bits(float32(lhs)) | BitConverter.SingleToInt32Bits(float32(rhs)));
     }
     else if (typeof(T) == typeof(float))
     {
         BitConverter.Int64BitsToDouble(BitConverter.DoubleToInt64Bits(float64(lhs)) | BitConverter.DoubleToInt64Bits(float64(rhs)));
     }
     else
     {
         throw unsupported <T>();
     }
     return(ref lhs);
 }
示例#2
0
        public static ShaderIrOperImmf GetOperImmf19_20(long OpCode)
        {
            uint Imm = (uint)(OpCode >> 20) & 0x7ffff;

            bool Neg = ((OpCode >> 56) & 1) != 0;

            Imm <<= 12;

            if (Neg)
            {
                Imm |= 0x80000000;
            }

            float Value = BitConverter.Int32BitsToSingle((int)Imm);

            return(new ShaderIrOperImmf(Value));
        }
示例#3
0
        public override async Task <Vertex[]> GetVerticesAsync()
        {
            if (CachedVerticies != null)
            {
                return(CachedVerticies);
            }

            var xArr = await Stream.GetAttributeArray(VertexAttribute.X);

            var yArr = await Stream.GetAttributeArray(VertexAttribute.Y);

            var zArr = await Stream.GetAttributeArray(VertexAttribute.Z);

            var cArr = await Stream.GetAttributeArray(VertexAttribute.Color);

            var uvArr = await GetUVsAsync();

            var vtxArr = new Vertex[Stream.Length];

            for (int i = 0; i < vtxArr.Length; i++)
            {
                var x = BitConverter.Int32BitsToSingle(xArr[i]);
                var y = BitConverter.Int32BitsToSingle(yArr[i]);
                var z = BitConverter.Int32BitsToSingle(zArr[i]);

                var xyz = new Vector3(x, y, z);
                var uv  = uvArr[i];

                var c = BitConverter.GetBytes(cArr[i]);

                var r = c[0] / 255.0f;
                var g = c[1] / 255.0f;
                var b = c[2] / 255.0f;

                var a = c[3] / 255.0f;

                var color = new Color(r, g, b, a);

                vtxArr[i] = new Vertex(i, xyz, uv, color);
            }

            CachedVerticies = vtxArr;

            return(vtxArr);
        }
示例#4
0
        public static float PreviousFloat(float value)
        {
            if (value <= 0)
            {
                return(-NextFloat(-value));
            }
            if (float.IsNaN(value))
            {
                return(value);
            }
            if (float.IsNegativeInfinity(value))
            {
                return(value);
            }
            int bits = BitConverter.SingleToInt32Bits(value);

            return(BitConverter.Int32BitsToSingle(bits - 1));
        }
示例#5
0
            public static TestStruct Create()
            {
                var testStruct = new TestStruct();
                var random     = new Random();

                for (var i = 0; i < Op1ElementCount; i++)
                {
                    _data1[i] = TestLibrary.Generator.GetSingle();
                }
                Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector256 <Single>, byte>(ref testStruct._fld1), ref Unsafe.As <Single, byte>(ref _data1[0]), (uint)Unsafe.SizeOf <Vector256 <Single> >());
                for (var i = 0; i < Op2ElementCount; i++)
                {
                    _data2[i] = BitConverter.Int32BitsToSingle(1);
                }
                Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector256 <Single>, byte>(ref testStruct._fld2), ref Unsafe.As <Single, byte>(ref _data2[0]), (uint)Unsafe.SizeOf <Vector256 <Single> >());

                return(testStruct);
            }
示例#6
0
        public unsafe static void ConvertD32FS8ToD24S8(Span <byte> output, ReadOnlySpan <byte> input)
        {
            Span <uint>         outputUint = MemoryMarshal.Cast <byte, uint>(output);
            ReadOnlySpan <uint> inputUint  = MemoryMarshal.Cast <byte, uint>(input);

            int i = 0;

            for (; i < inputUint.Length; i += 2)
            {
                float depth        = BitConverter.Int32BitsToSingle((int)inputUint[i]);
                uint  stencil      = inputUint[i + 1];
                uint  depthStencil = (Math.Clamp((uint)(depth * 0xffffff), 0, 0xffffff) << 8) | (stencil & 0xff);

                int j = i >> 1;

                outputUint[j] = depthStencil;
            }
        }
示例#7
0
        public static float Exp2(float power)
        {
            if (MathF.Abs(power) > MathV.FloatMaximumPower)
            {
                throw new ArgumentOutOfRangeException(nameof(power));
            }

            // R for polynomial generation
            // exponent2 = data.frame(x = seq(-0.536, 0.536, by = 0.001))
            // exponent2$exp = 2 ^ (exponent2$x)
            // exponentFit = lm(exp ~x + I(x ^ 2) + I(x ^ 3) + I(x ^ 4) + I(x ^ 5), data = exponent2)
            float integerPart        = MathF.Round(power);
            float x                  = power - integerPart; // fractional part
            float integerExponent    = BitConverter.Int32BitsToSingle(((int)integerPart + MathV.FloatMantissaZero) << MathV.FloatMantissaBits);
            float fractionalExponent = MathV.One + MathV.Exp2Beta1 * x + MathV.Exp2Beta2 * x * x + MathV.Exp2Beta3 * x * x * x + MathV.Exp2Beta4 * x * x * x * x;

            return(integerExponent * fractionalExponent);
        }
示例#8
0
        public static float VectorExtractSingle(Vector128 <float> Vector, byte Index)
        {
            if (Sse41.IsSupported)
            {
                return(Sse41.Extract(Vector, Index));
            }
            else if (Sse2.IsSupported)
            {
                Vector128 <ushort> ShortVector = Sse.StaticCast <float, ushort>(Vector);

                int Low  = Sse2.Extract(ShortVector, (byte)(Index * 2 + 0));
                int High = Sse2.Extract(ShortVector, (byte)(Index * 2 + 1));

                return(BitConverter.Int32BitsToSingle(Low | (High << 16)));
            }

            throw new PlatformNotSupportedException();
        }
示例#9
0
        public static float NextFloat(float value)
        {
            if (value < 0)
            {
                return(-PreviousFloat(-value));
            }
            value = System.Math.Abs(value); // needed to handle -0
            if (float.IsNaN(value))
            {
                return(value);
            }
            if (float.IsPositiveInfinity(value))
            {
                return(value);
            }
            int bits = BitConverter.SingleToInt32Bits(value);

            return(BitConverter.Int32BitsToSingle(bits + 1));
        }
示例#10
0
        public unsafe void SetExtraData(float FlipX, float FlipY, int Instance)
        {
            BindProgram();

            EnsureExtraBlock();

            GL.BindBuffer(BufferTarget.UniformBuffer, ExtraUboHandle);

            float *Data = stackalloc float[ExtraDataSize];

            Data[0] = FlipX;
            Data[1] = FlipY;
            Data[2] = BitConverter.Int32BitsToSingle(Instance);

            //Invalidate buffer
            GL.BufferData(BufferTarget.UniformBuffer, ExtraDataSize * sizeof(float), IntPtr.Zero, BufferUsageHint.StreamDraw);

            GL.BufferSubData(BufferTarget.UniformBuffer, IntPtr.Zero, ExtraDataSize * sizeof(float), (IntPtr)Data);
        }
        public static void RegisterAllLittleEndian()
        {
            Register(BinaryPrimitives.ReadInt16LittleEndian, BinaryPrimitives.WriteInt16LittleEndian);
            Register(BinaryPrimitives.ReadInt32LittleEndian, BinaryPrimitives.WriteInt32LittleEndian);
            Register(BinaryPrimitives.ReadInt64LittleEndian, BinaryPrimitives.WriteInt64LittleEndian);
            Register(BinaryPrimitives.ReadUInt16LittleEndian, BinaryPrimitives.WriteUInt16LittleEndian);
            Register(BinaryPrimitives.ReadUInt32LittleEndian, BinaryPrimitives.WriteUInt32LittleEndian);
            Register(BinaryPrimitives.ReadInt64LittleEndian, BinaryPrimitives.WriteInt64LittleEndian);
            Register(BinaryPrimitives.ReadUInt64LittleEndian, BinaryPrimitives.WriteUInt64LittleEndian);
            Register(
                src => BitConverter.Int32BitsToSingle(BinaryPrimitives.ReadInt32LittleEndian(src)),
                (dst, val) => BinaryPrimitives.WriteInt32LittleEndian(dst, BitConverter.SingleToInt32Bits(val)));
            Register(
                src => BitConverter.Int64BitsToDouble(BinaryPrimitives.ReadInt64LittleEndian(src)),
                (dst, val) => BinaryPrimitives.WriteInt64LittleEndian(dst, BitConverter.DoubleToInt64Bits(val)));

            IsAlreadySet = true;
            Endianness   = Endianness.LittleEndian;
        }
示例#12
0
文件: Oven.cs 项目: bauerslab/Oven
        /// <summary>Parses PID coefficient floating point values from the raw bytes</summary>
        private static PID ParsePid(List <byte> pidRaw)
        {
            if (pidRaw?.Count() != 12)
            {
                return(0, 0, 0);
            }

            byte[] raw = new byte[12];
            for (uint x = 0; x < 12; x++)
            {
                raw[x] = pidRaw[(int)(4 * (x / 4) + 3 - x % 4)];
            }

            float p = BitConverter.Int32BitsToSingle(BitConverter.ToInt32(raw, 0));
            float i = BitConverter.Int32BitsToSingle(BitConverter.ToInt32(raw, 4));
            float d = BitConverter.Int32BitsToSingle(BitConverter.ToInt32(raw, 8));

            return(p, i, d);
        }
示例#13
0
        private long[] UploadShaders(NvGpuVmm Vmm)
        {
            long[] Tags = new long[5];

            long BasePosition = MakeInt64From2xInt32(NvGpuEngine3dReg.ShaderAddress);

            for (int Index = 0; Index < 6; Index++)
            {
                int Control = ReadRegister(NvGpuEngine3dReg.ShaderNControl + Index * 0x10);
                int Offset  = ReadRegister(NvGpuEngine3dReg.ShaderNOffset + Index * 0x10);

                //Note: Vertex Program (B) is always enabled.
                bool Enable = (Control & 1) != 0 || Index == 1;

                if (!Enable)
                {
                    continue;
                }

                long Tag = BasePosition + (uint)Offset;

                GalShaderType ShaderType = GetTypeFromProgram(Index);

                Tags[(int)ShaderType] = Tag;

                Gpu.Renderer.CreateShader(Vmm, Tag, ShaderType);
                Gpu.Renderer.BindShader(Tag);
            }

            int RawSX = ReadRegister(NvGpuEngine3dReg.ViewportScaleX);
            int RawSY = ReadRegister(NvGpuEngine3dReg.ViewportScaleY);

            float SX = BitConverter.Int32BitsToSingle(RawSX);
            float SY = BitConverter.Int32BitsToSingle(RawSY);

            float SignX = MathF.Sign(SX);
            float SignY = MathF.Sign(SY);

            Gpu.Renderer.SetUniform2F(GalConsts.FlipUniformName, SignX, SignY);

            return(Tags);
        }
        public static FQuat ReadQuatFloat32NoW(this FArchive Ar)
        {
            const int  XShift = 21;
            const int  YShift = 10;
            const uint ZMask  = 0x000003ff;
            const uint YMask  = 0x001ffc00;
            const uint XMask  = 0xffe00000;

            var packed    = Ar.Read <uint>();
            var unpackedX = packed >> XShift;
            var unpackedY = (packed & YMask) >> YShift;
            var unpackedZ = (packed & ZMask);

            var x        = BitConverter.Int32BitsToSingle((int)(((((unpackedX >> 7) & 7) + 123) << 23) | ((unpackedX & 0x7F | 32 * (unpackedX & 0xFFFFFC00)) << 16)));
            var y        = BitConverter.Int32BitsToSingle((int)(((((unpackedY >> 7) & 7) + 123) << 23) | ((unpackedY & 0x7F | 32 * (unpackedY & 0xFFFFFC00)) << 16)));
            var z        = BitConverter.Int32BitsToSingle((int)(((((unpackedZ >> 6) & 7) + 123) << 23) | ((unpackedZ & 0x3F | 32 * (unpackedZ & 0xFFFFFE00)) << 17)));
            var wSquared = 1.0f - x * x - y * y - z * z;

            return(new FQuat(x, y, z, wSquared > 0.0f ? MathF.Sqrt(wSquared) : 0.0f));
        }
示例#15
0
        /// <summary>
        /// Sets the constant values required by the FSR RCAS shader on the provided command buffer
        ///
        /// Logic ported from "FsrRcasCon()" in Runtime/PostProcessing/Shaders/ffx/ffx_fsr1.hlsl
        /// For a more user-friendly version of this function, see SetRcasConstantsLinear().
        /// </summary>
        /// <param name="cmd">Command buffer to modify</param>
        /// <param name="sharpnessStops">The scale is {0.0 := maximum, to N>0, where N is the number of stops(halving) of the reduction of sharpness</param>
        public static void SetRcasConstants(CommandBuffer cmd, float sharpnessStops = kDefaultSharpnessStops)
        {
            // Transform from stops to linear value.
            float sharpnessLinear = Mathf.Pow(2.0f, -sharpnessStops);

            Vector4 constants;

            uint  sharpnessAsHalf        = Mathf.FloatToHalf(sharpnessLinear);
            int   packedSharpness        = (int)(sharpnessAsHalf | (sharpnessAsHalf << 16));
            float packedSharpnessAsFloat = BitConverter.Int32BitsToSingle(packedSharpness);

            constants.x = sharpnessLinear;
            constants.y = packedSharpnessAsFloat;

            // Fill the last constant with zeros to avoid using uninitialized memory
            constants.z = 0.0f;
            constants.w = 0.0f;

            cmd.SetGlobalVector(ShaderConstants._FsrRcasConstants, constants);
        }
示例#16
0
        public override string ToString()
        {
            var opcodeString = EnumUtils.GetDescription(OpCode);

            switch (GetOperandKind(OpCode))
            {
            case OperandKind.None:
                return(opcodeString);

            case OperandKind.BrTableOperand:
                return($"{opcodeString} {string.Join("-", uIntArrayOperand!.Select(x => $"0x{x:X}"))} 0x{operand:x}");

            case OperandKind.BlockType:
                return($"{opcodeString} {(ValueKind)operand}");

            case OperandKind.LabelIndex:
            case OperandKind.FuncIndex:
            case OperandKind.IndirectCallTypeIndex:
                return($"{opcodeString} 0x{operand:X}");

            case OperandKind.MemArg:
                return($"{opcodeString} 0x{operand & 0xFFFFFFFF00000000:X} 0x{operand & 0xFFFFFFFF:X}");

            case OperandKind.Zero:
            case OperandKind.LocalIndex:
            case OperandKind.GlobalIndex:
            case OperandKind.ImmediateI32:
            case OperandKind.ImmediateI64:
                return($"{opcodeString} {operand}");

            case OperandKind.ImmediateF32:
                return($"{opcodeString} {BitConverter.Int32BitsToSingle((int)operand)}");

            case OperandKind.ImmediateF64:
                return($"{opcodeString} {BitConverter.Int64BitsToDouble((long)operand)}");

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
示例#17
0
        public Single ReadSingle(Int64 position)
        {
            int sizeOfType = sizeof(Single);

            EnsureSafeToRead(position, sizeOfType);

            Single result;

            unsafe {
                byte *pointer = null;
                RuntimeHelpers.PrepareConstrainedRegions();
                try {
                    _buffer.AcquirePointer(ref pointer);
                    pointer += (_offset + position);

#if ALIGN_ACCESS
                    // check if pointer is aligned
                    if (((int)pointer & (sizeOfType - 1)) == 0)
                    {
#endif
                    result = BitConverter.Int32BitsToSingle(*((int *)(pointer)));
#if ALIGN_ACCESS
                }
                else
                {
                    UInt32 tempResult = (UInt32)(*pointer | *(pointer + 1) << 8 | *(pointer + 2) << 16 | *(pointer + 3) << 24);
                    result = *((float *)&tempResult);
                }
#endif
                }
                finally {
                    if (pointer != null)
                    {
                        _buffer.ReleasePointer();
                    }
                }
            }

            return(result);
        }
示例#18
0
        public static float HalfToSingle(int value)
        {
            int mantissa = (value >> 0) & 0x3ff;
            int exponent = (value >> 10) & 0x1f;
            int sign     = (value >> 15) & 0x1;

            if (exponent == 0x1f)
            {
                // NaN or Infinity.
                mantissa <<= 13;
                exponent   = 0xff;
            }
            else if (exponent != 0 || mantissa != 0)
            {
                if (exponent == 0)
                {
                    // Denormal.
                    int e = -1;
                    int m = mantissa;

                    do
                    {
                        e++;
                        m <<= 1;
                    }while ((m & 0x400) == 0);

                    mantissa = m & 0x3ff;
                    exponent = e;
                }

                mantissa <<= 13;
                exponent   = 127 - 15 + exponent;
            }

            int output = (sign << 31) | (exponent << 23) | mantissa;

            return(BitConverter.Int32BitsToSingle(output));
        }
        /// <summary>
        /// Reads a <see cref="float"/> value from an array of bytes.
        /// </summary>
        /// <param name="bytes">The array of bytes to read from.</param>
        /// <param name="position">The position in the array where the value should be read.</param>
        /// <param name="endianness">The endianness.</param>
        /// <returns>The value.</returns>
        public static float ReadFloat(this byte[] bytes, int position, Endianness endianness)
        {
            Debug.Assert(bytes != null && position >= 0 && bytes.Length >= position + SizeOfFloat);

            int value;

            unchecked
            {
                value = endianness.IsBigEndian()

                    ? bytes[position] << 24 | bytes[position + 1] << 16 |
                        bytes[position + 2] << 8 | bytes[position + 3]

                    : bytes[position] | bytes[position + 1] << 8 |
                        bytes[position + 2] << 16 | bytes[position + 3] << 24;
            }

#if NETSTANDARD2_0
            return(BitConverter.ToSingle(BitConverter.GetBytes(value), 0));
#else
            // this is essentially an unsafe *((float*)&value)
            return(BitConverter.Int32BitsToSingle(value));
#endif
        }
示例#20
0
        public static float ConvertHalfToSingle(ushort x)
        {
            uint x_sign     = (uint)(x >> 15) & 0x0001;
            uint x_exp      = (uint)(x >> 10) & 0x001F;
            uint x_mantissa = (uint)x & 0x03FF;

            if (x_exp == 0 && x_mantissa == 0)
            {
                // Zero
                return(BitConverter.Int32BitsToSingle((int)(x_sign << 31)));
            }

            if (x_exp == 0x1F)
            {
                // NaN or Infinity
                return(BitConverter.Int32BitsToSingle((int)((x_sign << 31) | 0x7F800000 | (x_mantissa << 13))));
            }

            int exponent = (int)x_exp - 15;

            if (x_exp == 0)
            {
                // Denormal
                x_mantissa <<= 1;
                while ((x_mantissa & 0x0400) == 0)
                {
                    x_mantissa <<= 1;
                    exponent--;
                }
                x_mantissa &= 0x03FF;
            }

            uint new_exp = (uint)((exponent + 127) & 0xFF) << 23;

            return(BitConverter.Int32BitsToSingle((int)((x_sign << 31) | new_exp | (x_mantissa << 13))));
        }
示例#21
0
        public void Step1()
        {
            var num = new[] { 0.001f, 0.01f, 0.0625f, 0.1f, 0.25f, 0.5f, 1f, 2f, 4f, 8f, 10f, 16f, 100f, 1000f };

            foreach (var n in num)
            {
                var c1  = 0x5f3759df;
                var c2  = 1597488759;
                var ans = 1.0f / Math.Sqrt(n);

                // Console.WriteLine(FloatToString(n));
                // Console.WriteLine(FloatToString(1.0f / (float)Math.Sqrt(n)));
                var i = BitConverter.SingleToInt32Bits(n);

                var sum1 = c1 - (i >> 1);
                var y1   = BitConverter.Int32BitsToSingle(sum1);

                var sum2 = c2 - (i >> 1);
                var y2   = BitConverter.Int32BitsToSingle(sum2);

                var diff = Math.Abs(ans - y1) < Math.Abs(ans - y2) ? "<" : ">";
                Console.WriteLine("{0}, {1}, {2}", ans - y1, ans - y2, diff);
            }
        }
示例#22
0
 private void CheckOneSingle(string s, uint expectedBits)
 {
     CheckOneSingle(s, BitConverter.Int32BitsToSingle((int)(expectedBits)));
 }
示例#23
0
 private float ReadRegisterFloat(NvGpuEngine3dReg Reg)
 {
     return(BitConverter.Int32BitsToSingle(ReadRegister(Reg)));
 }
示例#24
0
 public static float ReplacementInt32ToSingleBits(this int value) => BitConverter.Int32BitsToSingle(value);
示例#25
0
 public float ReadFloat()
 {
     return(BitConverter.Int32BitsToSingle(this.ReadInt()));
 }
示例#26
0
 public static float ReadFloatRaw <TInput>(ref Reader <TInput> reader) => BitConverter.Int32BitsToSingle(reader.ReadInt32());
示例#27
0
 public virtual unsafe float ReadSingle() => BitConverter.Int32BitsToSingle(BinaryPrimitives.ReadInt32LittleEndian(InternalRead(4)));
示例#28
0
 private static ShaderIrOperImmf Immf32_20(this long OpCode)
 {
     return(new ShaderIrOperImmf(BitConverter.Int32BitsToSingle((int)(OpCode >> 20))));
 }
示例#29
0
 public float AsFloat()
 {
     return BitConverter.Int32BitsToSingle((int)Value);
 }
示例#30
0
 public static float ReadSingleLittleEndian(ReadOnlySpan <byte> source)
 {
     return(!BitConverter.IsLittleEndian ?
            BitConverter.Int32BitsToSingle(ReverseEndianness(MemoryMarshal.Read <int>(source))) :
            MemoryMarshal.Read <float>(source));
 }