Exemple #1
0
        public static Vector2 LoadVector2(FakeStruct fake, int offset)
        {
            Vector2 v = new Vector2();

            v.x = fake.GetFloat(offset);
            v.y = fake.GetFloat(offset + 1);
            return(v);
        }
Exemple #2
0
        public static Color LoadColor(FakeStruct fake, int offset)
        {
            Color v = new Color();

            v.r = fake.GetFloat(offset);
            v.g = fake.GetFloat(offset + 1);
            v.b = fake.GetFloat(offset + 2);
            v.a = fake.GetFloat(offset + 3);
            return(v);
        }
Exemple #3
0
        public static Quaternion LoadQuaternion(FakeStruct fake, int offset)
        {
            Quaternion v = new Quaternion();

            v.x = fake.GetFloat(offset);
            v.y = fake.GetFloat(offset + 1);
            v.z = fake.GetFloat(offset + 2);
            v.w = fake.GetFloat(offset + 3);
            return(v);
        }
Exemple #4
0
        public static Vector4 LoadVector4(FakeStruct fake, int offset)
        {
            Vector4 v = new Vector4();

            v.x = fake.GetFloat(offset);
            v.y = fake.GetFloat(offset + 1);
            v.z = fake.GetFloat(offset + 2);
            v.w = fake.GetFloat(offset + 3);
            return(v);
        }
Exemple #5
0
        void CompatibleReadValue(DataFieldInfo info, FakeStruct fake, int offset, object instance)
        {
            switch (info.DBType)
            {
            case DataType2.Byte:
                info.field.SetValue(instance, (byte)fake[offset]);
                break;

            case DataType2.SByte:
                info.field.SetValue(instance, (sbyte)fake[offset]);
                break;

            case DataType2.Int16:
                info.field.SetValue(instance, (Int16)fake[offset]);
                break;

            case DataType2.UInt16:
                info.field.SetValue(instance, (UInt16)fake[offset]);
                break;

            case DataType2.Int32:
            case DataType2.UInt32:
                info.field.SetValue(instance, fake[offset]);
                break;

            case DataType2.Float:
                info.field.SetValue(instance, fake.GetFloat(offset));
                break;

            case DataType2.Int64:
            case DataType2.UInt64:
                if (info.OldFieldInfo.DataLength == 4)
                {
                    info.field.SetValue(instance, fake[offset]);
                }
                else
                {
                    info.field.SetValue(instance, fake.GetInt64(offset));
                }
                break;

            case DataType2.Double:
                if (info.OldFieldInfo.DataLength == 4)
                {
                    info.field.SetValue(instance, fake.GetFloat(offset));
                }
                else
                {
                    info.field.SetValue(instance, fake.GetDouble(offset));
                }
                break;

            case DataType2.Decimal:
                if (info.OldFieldInfo.DataLength == 4)
                {
                    info.field.SetValue(instance, fake.GetFloat(offset));
                }
                else if (info.OldFieldInfo.DataLength == 8)
                {
                    info.field.SetValue(instance, fake.GetDouble(offset));
                }
                else
                {
                    info.field.SetValue(instance, fake.GetDecimal(offset));
                }
                break;
            }
        }
Exemple #6
0
        void CompatibleReadValue(DataFieldInfo info, FakeStruct fake, int offset, IntPtr ptr)
        {
            switch (info.DBType)
            {
            case DataType2.Byte:
                unsafe { *(byte *)(ptr + info.MemOffset) = (byte)fake[offset]; }
                break;

            case DataType2.SByte:
                unsafe { *(sbyte *)(ptr + info.MemOffset) = (sbyte)fake[offset]; }
                break;

            case DataType2.Int16:
                unsafe { *(Int16 *)(ptr + info.MemOffset) = (Int16)fake[offset]; }
                break;

            case DataType2.UInt16:
                unsafe { *(UInt16 *)(ptr + info.MemOffset) = (UInt16)fake[offset]; }
                break;

            case DataType2.Int32:
                unsafe { *(Int32 *)(ptr + info.MemOffset) = (Int32)fake[offset]; }
                break;

            case DataType2.UInt32:
                unsafe { *(UInt32 *)(ptr + info.MemOffset) = (UInt32)fake[offset]; }
                break;

            case DataType2.Float:
                unsafe { *(float *)(ptr + info.MemOffset) = fake.GetFloat(offset); }
                break;

            case DataType2.Int64:
            case DataType2.UInt64:
                if (info.OldFieldInfo.DataLength == 4)
                {
                    unsafe { *(Int32 *)(ptr + info.MemOffset) = (Int32)fake[offset]; }
                }
                else
                {
                    unsafe { *(Int64 *)(ptr + info.MemOffset) = fake.GetInt64(offset); }
                }
                break;

            case DataType2.Double:
                if (info.OldFieldInfo.DataLength == 4)
                {
                    unsafe { *(float *)(ptr + info.MemOffset) = fake.GetFloat(offset); }
                }
                else
                {
                    unsafe { *(double *)(ptr + info.MemOffset) = fake.GetDouble(offset); }
                }
                break;

            case DataType2.Decimal:
                if (info.OldFieldInfo.DataLength == 4)
                {
                    unsafe { *(float *)(ptr + info.MemOffset) = fake.GetFloat(offset); }
                }
                else if (info.OldFieldInfo.DataLength == 8)
                {
                    unsafe { *(double *)(ptr + info.MemOffset) = fake.GetDouble(offset); }
                }
                else
                {
                    unsafe { *(decimal *)(ptr + info.MemOffset) = fake.GetDecimal(offset); }
                }
                break;
            }
        }