public byte[] SaveToBytes()
        {
            var ms     = new System.IO.MemoryStream();
            var writer = new System.IO.BinaryWriter(ms);

            writer.Write(Encoding.ASCII.GetBytes("EFKM"));
            writer.Write((int)Version);
            writer.Write(GUID);

            {
                var bw = new Utils.BinaryWriter();
                bw.Push(Names.Count);
                var keys = Names.Keys.ToArray();
                for (int i = 0; i < keys.Length; i++)
                {
                    bw.Push((int)keys[i]);
                    bw.Push(Names[keys[i]], Encoding.UTF8);
                    bw.Push(Descriptions[keys[i]], Encoding.UTF8);
                }

                var binary = bw.GetBinary();
                writer.Write(Encoding.ASCII.GetBytes("DESC"));
                writer.Write(binary.Length);
                writer.Write(binary);
            }

            {
                var bw = new Utils.BinaryWriter();

                bw.Push(ShadingModel);
                bw.Push(HasNormal);
                bw.Push(HasRefraction);
                bw.Push(CustomData1Count);
                bw.Push(CustomData2Count);

                bw.Push(Textures.Length);
                foreach (var info in Textures)
                {
                    bw.Push(info.Name, Encoding.UTF8);
                    bw.Push(info.UniformName, Encoding.UTF8);
                    bw.Push(info.DefaultPath, Encoding.UTF8);
                    bw.Push(info.Index);
                    bw.Push(info.Priority);
                    bw.Push(info.IsParam);
                    bw.Push((int)info.Type);
                    bw.Push(info.Sampler);
                }

                bw.Push(Uniforms.Length);
                foreach (var info in Uniforms)
                {
                    bw.Push(info.Name, Encoding.UTF8);
                    bw.Push(info.UniformName, Encoding.UTF8);

                    bw.Push(info.Offset);
                    bw.Push(info.Priority);
                    bw.Push(info.Type);
                    bw.Push(info.DefaultValues[0]);
                    bw.Push(info.DefaultValues[1]);
                    bw.Push(info.DefaultValues[2]);
                    bw.Push(info.DefaultValues[3]);
                }

                var binary = bw.GetBinary();
                writer.Write(Encoding.ASCII.GetBytes("PRM_"));
                writer.Write(binary.Length);
                writer.Write(binary);
            }

            {
                var bw = new Utils.BinaryWriter();

                bw.Push(CustomData.Length);
                foreach (var data in CustomData)
                {
                    bw.Push(data.Summaries.Count);
                    var keys = data.Summaries.Keys.ToArray();
                    foreach (var key in keys)
                    {
                        bw.Push((int)key);
                        bw.Push(data.Summaries[key], Encoding.UTF8);
                        bw.Push(data.Descriptions[key], Encoding.UTF8);
                    }
                }

                bw.Push(Textures.Length);
                foreach (var texture in Textures)
                {
                    bw.Push(texture.Summaries.Count);
                    var keys = texture.Summaries.Keys.ToArray();
                    foreach (var key in keys)
                    {
                        bw.Push((int)key);
                        bw.Push(texture.Summaries[key], Encoding.UTF8);
                        bw.Push(texture.Descriptions[key], Encoding.UTF8);
                    }
                }

                bw.Push(Uniforms.Length);
                foreach (var uniform in Uniforms)
                {
                    bw.Push(uniform.Summaries.Count);
                    var keys = uniform.Summaries.Keys.ToArray();
                    foreach (var key in keys)
                    {
                        bw.Push((int)key);
                        bw.Push(uniform.Summaries[key], Encoding.UTF8);
                        bw.Push(uniform.Descriptions[key], Encoding.UTF8);
                    }
                }

                var binary = bw.GetBinary();
                writer.Write(Encoding.ASCII.GetBytes("PRM2"));
                writer.Write(binary.Length);
                writer.Write(binary);
            }

            {
                var bw = new Utils.BinaryWriter();

                bw.Push(CustomData.Length);

                for (int j = 0; j < CustomData.Length; j++)
                {
                    bw.Push(CustomData[j].DefaultValues[0]);
                    bw.Push(CustomData[j].DefaultValues[1]);
                    bw.Push(CustomData[j].DefaultValues[2]);
                    bw.Push(CustomData[j].DefaultValues[3]);
                }

                var binary = bw.GetBinary();
                writer.Write(Encoding.ASCII.GetBytes("E_CD"));
                writer.Write(binary.Length);
                writer.Write(binary);
            }

            {
                var bw = new Utils.BinaryWriter();
                bw.Push(Code, Encoding.UTF8);

                var binary = bw.GetBinary();
                writer.Write(Encoding.ASCII.GetBytes("GENE"));
                writer.Write(binary.Length);
                writer.Write(binary);
            }

            {
                string jsonText = JsonConvert.SerializeObject(EditorData);
                jsonText = jsonText.Replace("/", "\\/");

                var bw = new Utils.BinaryWriter();
                bw.Push(jsonText, Encoding.UTF8, true, 0);

                var binary = bw.GetBinary();
                writer.Write(Encoding.ASCII.GetBytes("DATA"));
                writer.Write(binary.Length);
                writer.Write(binary);
            }

            return(ms.ToArray());
        }
Exemple #2
0
        byte[] Compress(System.Xml.XmlDocument xml)
        {
            // visit all nodes
            Func <System.Xml.XmlNodeList, List <Element> > visit = null;

            visit = (System.Xml.XmlNodeList xmlNodes) =>
            {
                var elements = new List <Element>();

                for (int i = 0; i < xmlNodes.Count; i++)
                {
                    if (xmlNodes[i].NodeType == System.Xml.XmlNodeType.XmlDeclaration)
                    {
                        continue;
                    }

                    var element = new Element();

                    element.Name = xmlNodes[i].Name;

                    if (xmlNodes[i].ChildNodes.Count == 1 &&
                        xmlNodes[i].ChildNodes[0].NodeType == System.Xml.XmlNodeType.Text)
                    {
                        var value = xmlNodes[i].ChildNodes[0].Value;
                        element.Value = value;
                    }
                    else
                    {
                        element.Children = visit(xmlNodes[i].ChildNodes);
                    }

                    elements.Add(element);
                }

                return(elements);
            };

            var visits = visit(xml.ChildNodes);

            // compress
            var keys   = new Dictionary <string, Int16>();
            var values = new Dictionary <string, Int16>();
            Func <List <Element>, byte[]> comp = null;

            comp = (elements) =>
            {
                Utils.BinaryWriter res = new Utils.BinaryWriter();

                res.Push((Int16)elements.Count);
                foreach (var item in elements)
                {
                    if (!keys.ContainsKey(item.Name))
                    {
                        keys[item.Name] = (Int16)keys.Count();
                    }
                    res.Push(keys[item.Name]);

                    var  valueStr    = item.Value as string;
                    bool isHaveValue = !string.IsNullOrEmpty(valueStr);
                    res.Push(isHaveValue);
                    if (isHaveValue)
                    {
                        if (!values.ContainsKey(valueStr))
                        {
                            values[valueStr] = (Int16)values.Count();
                        }
                        res.Push(values[valueStr]);
                    }

                    bool isHaveChildren = item.Children != null && item.Children.Count != 0;
                    res.Push(isHaveChildren);
                    if (isHaveChildren)
                    {
                        res.PushDirectly(comp(item.Children));
                    }
                }
                return(res.GetBinary());
            };

            var binary = new Utils.BinaryWriter();

            var valueBuf = comp(visits);

            binary.Push((Int16)keys.Count);
            foreach (var item in keys)
            {
                binary.Push(item.Key, Encoding.UTF8, false, 2);
                binary.Push(item.Value);
            }

            binary.Push((Int16)values.Count);
            foreach (var item in values)
            {
                binary.Push(item.Key, Encoding.UTF8, false, 2);
                binary.Push(item.Value);
            }

            binary.PushDirectly(valueBuf);

            return(Utils.Zlib.Compress(binary.GetBinary()));
        }