XeNTaX

Code: Select all

struct UVHeader
{
    int vertCount; //or id
    int type; //14, 15 or 16
    int size; //size of each uv
    int dataSize; //vertCount * size = dataSize
}
//Type is associated with size
//Type:Size 14:8, 15:12, 16:16
//I assume in some cases they have 2 UVs

struct UnknStruct00
{
    int i0; //always 1
    int i1; //always 1
    int i2; //always 0
    int i3; //always 0
    int i4; //always 0
    int i5; //Always a Constant -65536 (which is the minimum short value)
    int i6; //UV offset
    ushort s0,s1; //always 4096 and another increasing value
};

This class doesn't seem important
I had originally thought [b]i5[/b] was a bias but i did not know what to scale it to and why that was necessary.

Code: Select all

//Big Endian file
struct UVHeader
{
    int vertCount; //or id
    int type; //14,15,16
    int uvSize; //8,12,16  (single uv size)
    int totalSize; //vertCount * uvSize= totalSize
}uvHeader[20]

Code: Select all

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HalfFloat
{
    class Program
    {
        static void Main(string[] args)
        {
            {
                string hex = "0x3862";
                short h = Convert.ToInt16(hex, 16);

                //From this paper ftp://www.fox-toolkit.org/pub/fasthalffloatconversion.pdf
                float f = ((h & 0x8000) << 16) | (((h & 0x7c00) + 0x1C000) << 13) | ((h & 0x03FF) << 13);
                Console.Write("Short h {0}: is Float {1}  //" + h.ToString("X"), h, f);

                //Same as the half float in 010 Editor
                //http://codereview.stackexchange.com/questions/45007/half-precision-reader-writer-for-c
                f = HalfFloat(Convert.ToInt32(hex, 16));
                Console.Write("\nShort h {0}: is Float {1}  //" + h.ToString("X"), h, f);
            }

            //I thought we had to flip the hex for  Big endians? This failed
            {
                string hex = "0x6238";
                short h = Convert.ToInt16(hex, 16);
                float f = ((h & 0x8000) << 16) | (((h & 0x7c00) + 0x1C000) << 13) | ((h & 0x03FF) << 13);
                Console.Write("\nShort h {0}: is Float {1}  //" + h.ToString("X"), h, f);

                f = HalfFloat(Convert.ToInt32(hex, 16));
                Console.Write("\nShort h {0}: is Float {1}  //" + h.ToString("X"), h, f);
            }
            Console.ReadKey();
        }

        // ignores the higher 16 bits
        public static float HalfFloat(int hbits)
        {
            int mant = hbits & 0x03ff;            // 10 bits mantissa
            int exp = hbits & 0x7c00;            // 5 bits exponent
            if (exp == 0x7c00)                   // NaN/Inf
                exp = 0x3fc00;                    // -> NaN/Inf
            else if (exp != 0)                   // normalized value
            {
                exp += 0x1c000;                   // exp - 15 + 127
                if (mant == 0 && exp > 0x1c400)  // smooth transition
                    return BitConverter.ToSingle(BitConverter.GetBytes((hbits & 0x8000) << 16
                                                    | exp << 13 | 0x3ff),0);
            }
            else if (mant != 0)                  // && exp==0 -> subnormal
            {
                exp = 0x1c400;                    // make it normal
                do
                {
                    mant <<= 1;                   // mantissa * 2
                    exp -= 0x400;                 // decrease exp by 1
                } while ((mant & 0x400) == 0); // while not normal
                mant &= 0x3ff;                    // discard subnormal bit
            }                                     // else +/-0 -> +/-0
            return BitConverter.ToSingle(
                BitConverter.GetBytes(          // combine all parts
                (hbits & 0x8000) << 16          // sign  << ( 31 - 15 )
                | (exp | mant) << 13),0);         // value << ( 23 - 10 )
        }

    }
}