Example #1
0
        public void GetBitsTest()
        {
            Half   value    = new Half(555.555);
            ushort expected = 24663;
            ushort actual   = Half.GetBits(value);

            Assert.Equal(expected, actual);
        }
Example #2
0
        private int WriteVertices(BinaryWriter writer, Submesh submesh, int flagCount, List <int> boneIndices)
        {
            var startPosition = writer.BaseStream.Position;

            foreach (var v in submesh.Vertices)
            {
                GmdUtils.WriteVector3(v.Position, writer);

                if (v.BoneIndices != null)
                {
                    writer.Write((byte)(v.BoneWeights[0] * 255));
                    writer.Write((byte)(v.BoneWeights[1] * 255));
                    writer.Write((byte)(v.BoneWeights[2] * 255));
                    writer.Write((byte)(v.BoneWeights[3] * 255));

                    writer.Write((byte)(boneIndices.IndexOf(v.BoneIndices[0])));
                    writer.Write((byte)(boneIndices.IndexOf(v.BoneIndices[1])));
                    writer.Write((byte)(boneIndices.IndexOf(v.BoneIndices[2])));
                    writer.Write((byte)(boneIndices.IndexOf(v.BoneIndices[3])));
                }

                GmdUtils.WriteNormal(v.Normal, writer);
                writer.Write((byte)0);

                for (int i = 0; i < flagCount; i++)
                {
                    writer.Write((byte)255);
                    writer.Write((byte)255);
                    writer.Write((byte)255);
                    writer.Write((byte)255);
                }

                // writer.Write(100);
                // writer.Write((byte)0);
                // if ((mesh.Format >> 12 & 7L) == 7L)
                // {
                //     writer.Write(0);
                // }
                //
                // if ((mesh.Format >> 21 & 7L) == 7L)
                // {
                //     writer.Write(0);
                // }
                //
                // if ((mesh.Format >> 24 & 7L) == 7L)
                // {
                //     writer.Write(0);
                // }
                writer.Write(Half.GetBits(new Half(v.Uv0.X)));
                writer.Write(Half.GetBits(new Half(1 - v.Uv0.Y)));

                if (v.Uv1.HasValue)
                {
                    writer.Write(Half.GetBits(new Half(v.Uv1.Value.X)));
                    writer.Write(Half.GetBits(new Half(1 - v.Uv1.Value.Y)));
                }

                if (v.Uv2.HasValue)
                {
                    writer.Write(Half.GetBits(new Half(v.Uv2.Value.X)));
                    writer.Write(Half.GetBits(new Half(1 - v.Uv2.Value.Y)));
                }

                if (v.Uv3.HasValue)
                {
                    writer.Write(Half.GetBits(new Half(v.Uv3.Value.X)));
                    writer.Write(Half.GetBits(new Half(1 - v.Uv3.Value.Y)));
                }
            }

            var endPosition = writer.BaseStream.Position;

            // Stride
            return((int)((endPosition - startPosition) / submesh.Vertices.Length));
        }
Example #3
0
    ///<summary>Saves state dict to a file.</summary>
    ///<param name = "state_dict">A dictionary containing a whole state of the module.</param>
    ///<param name = "fname">Output file name.</param>
    public static void save(Dictionary <string, Tensor> state_dict, string fname)
    {
        var fs = new BinaryWriter(File.Create(fname));

        foreach (var x in state_dict.Keys)
        {
            fs.Write(x);
            var data = state_dict[x];
            fs.Write(data.__ndim);
            fs.Write(data.__batch);
            fs.Write(data.__time);
            fs.Write(data.__depth);
            fs.Write(data.__height);
            fs.Write(data.__width);
            switch (data.dtype)
            {
            case torch.dtype.float16:
            {
                fs.Write((byte)0);
                var src = data.__data_float16;
                for (int i = 0; i < src.Length; i++)
                {
                    fs.Write(Half.GetBits(src[i]));
                }
                break;
            }

            case torch.dtype.float32:
            {
                fs.Write((byte)1);
                var src = data.__data_float32;
                for (int i = 0; i < src.Length; i++)
                {
                    fs.Write(src[i]);
                }
                break;
            }

            case torch.dtype.float64:
            {
                fs.Write((byte)2);
                var src = data.__data_float64;
                for (int i = 0; i < src.Length; i++)
                {
                    fs.Write(src[i]);
                }
                break;
            }

            case torch.dtype.uint8:
            {
                fs.Write((byte)3);
                var src = data.__data_uint8;
                for (int i = 0; i < src.Length; i++)
                {
                    fs.Write(src[i]);
                }
                break;
            }

            case torch.dtype.int8:
            {
                fs.Write((byte)4);
                var src = data.__data_int8;
                for (int i = 0; i < src.Length; i++)
                {
                    fs.Write(src[i]);
                }
                break;
            }

            case torch.dtype.int16:
            {
                fs.Write((byte)5);
                var src = data.__data_int16;
                for (int i = 0; i < src.Length; i++)
                {
                    fs.Write(src[i]);
                }
                break;
            }

            case torch.dtype.int32:
            {
                fs.Write((byte)6);
                var src = data.__data_int32;
                for (int i = 0; i < src.Length; i++)
                {
                    fs.Write(src[i]);
                }
                break;
            }

            case torch.dtype.int64:
            {
                fs.Write((byte)7);
                var src = data.__data_int64;
                for (int i = 0; i < src.Length; i++)
                {
                    fs.Write(src[i]);
                }
                break;
            }

            case torch.dtype.@bool:
            {
                fs.Write((byte)8);
                var src = data.__data_bool;
                for (int i = 0; i < src.Length; i++)
                {
                    fs.Write(src[i]);
                }
                break;
            }
            }
        }
        fs.Close();
    }
Example #4
0
        public void WriteHalf(Half value)
        {
            ushort bits = Half.GetBits(value);

            WriteUShort(bits);
        }