Beispiel #1
0
        public static MqScene Parse(MqChunk chunk)
        {
            var rt = new MqScene
            {
                baseChunk = chunk,
            };

            foreach (var i in chunk.Children)
            {
                switch (i.Name.ToLower())
                {
                case "pos":
                    rt.Position = i.Arguments.Select(float.Parse).ToArray();

                    break;

                case "lookat":
                    rt.LookAt = i.Arguments.Select(float.Parse).ToArray();

                    break;

                case "head":
                    rt.Head = float.Parse(i.Arguments.First());

                    break;

                case "pich":
                    rt.Pitch = float.Parse(i.Arguments.First());

                    break;

                case "bank":
                    rt.Bank = float.Parse(i.Arguments.First());

                    break;

                case "ortho":
                    rt.Ortho = i.Arguments.First() == "1";

                    break;

                case "zoom2":
                    rt.Zoom2 = float.Parse(i.Arguments.First());

                    break;

                case "amb":
                    rt.Ambient = i.Arguments.Select(float.Parse).ToArray();

                    break;

                case "dirlights":
                    rt.DirectionalLights = i.Children.Select(MqDirectionalLight.Parse).ToList();

                    break;
                }
            }

            return(rt);
        }
Beispiel #2
0
        public static MqDirectionalLight Parse(MqChunk chunk)
        {
            var rt = new MqDirectionalLight
            {
                baseChunk = chunk,
            };

            foreach (var i in chunk.Children)
            {
                switch (i.Name.ToLower())
                {
                case "dir":
                    rt.Direction = i.Arguments.Select(float.Parse).ToArray();

                    break;

                case "color":
                    rt.Color = i.Arguments.Select(float.Parse).ToArray();

                    break;
                }
            }

            return(rt);
        }
Beispiel #3
0
        public static MqFace Parse(MqChunk chunk)
        {
            var rt = new MqFace
            {
                baseChunk = chunk,
            };

            foreach (var i in chunk.Attributes)
            {
                switch (i.Name.ToLower())
                {
                case "v":
                    rt.Vertices = i.Arguments.Select(int.Parse).ToArray();

                    break;

                case "m":
                    rt.Material = int.Parse(i.Arguments.First());

                    break;

                case "uv":
                    rt.UV = i.Arguments.Select(float.Parse).Buffer(2).Select(_ => _.ToArray()).ToArray();

                    break;

                case "col":
                    rt.VertexColor = i.Arguments.Select(uint.Parse).Select(_ => new MqVertexColor((byte)(_ & 0xFF), (byte)((_ >> 8) & 0xFF), (byte)((_ >> 16) & 0xFF), (byte)((_ >> 24) & 0xFF))).ToArray();

                    break;
                }
            }

            return(rt);
        }
Beispiel #4
0
        public static MqFace Parse(MqChunk chunk)
        {
            var rt = new MqFace
            {
                baseChunk = chunk,
            };

            foreach (var i in chunk.Attributes)
                switch (i.Name.ToLower())
                {
                    case "v":
                        rt.Vertices = i.Arguments.Select(int.Parse).ToArray();

                        break;
                    case "m":
                        rt.Material = int.Parse(i.Arguments.First());

                        break;
                    case "uv":
                        rt.UV = i.Arguments.Select(float.Parse).Buffer(2).Select(_ => _.ToArray()).ToArray();

                        break;
                    case "col":
                        rt.VertexColor = i.Arguments.Select(uint.Parse).Select(_ => new MqVertexColor((byte)(_ & 0xFF), (byte)((_ >> 8) & 0xFF), (byte)((_ >> 16) & 0xFF), (byte)((_ >> 24) & 0xFF))).ToArray();

                        break;
                }

            return rt;
        }
Beispiel #5
0
        public static MqDocument Parse(string text)
        {
            var rt        = new MqDocument();
            var tokenizer = new MqTokenizer(text);
            var header    = new[] { "Metasequoia", "Document", "\n", "Format", "Text", "Ver" };

            if (!tokenizer.Take(header.Length).Select(_ => _.Text).SequenceEqual(header))
            {
                throw new InvalidOperationException("invalid format");
            }

            rt.Version = float.Parse(tokenizer.MoveNext().EnsureKind(MqTokenizer.DigitTokenKind).Text);

            if (rt.Version >= 2)
            {
                throw new NotSupportedException("specified format version not supported");
            }

            foreach (var i in tokenizer)
            {
                if (i.Kind == MqTokenizer.IdentifierTokenKind)
                {
                    var chunk = MqChunk.Parse(tokenizer);

                    switch (chunk.Name.ToLower())
                    {
                    case "includexml":
                        rt.IncludeXml = chunk.Arguments.First().Trim('"');

                        break;

                    case "scene":
                        rt.Scene = MqScene.Parse(chunk);

                        break;

                    case "material":
                        rt.Materials = chunk.Children.Select(MqMaterial.Parse).ToList();

                        break;

                    case "object":
                        rt.Objects.Add(MqObject.Parse(chunk));

                        break;

                    case "eof":
                        break;

                    default:
                        rt.CustomChunks.Add(chunk);

                        break;
                    }
                }
            }

            return(rt);
        }
Beispiel #6
0
        public MqChunk ToChunk()
        {
            baseChunk = baseChunk ?? new MqChunk();
            baseChunk.Child("dir").SetArguments(this.Direction.Select(_ => _.ToString("0.000")));
            baseChunk.Child("color").SetArguments(this.Color.Select(_ => _.ToString("0.000")));

            return baseChunk;
        }
Beispiel #7
0
        public MqChunk ToChunk()
        {
            baseChunk = baseChunk ?? new MqChunk();
            baseChunk.Child("dir").SetArguments(this.Direction.Select(_ => _.ToString("0.000")));
            baseChunk.Child("color").SetArguments(this.Color.Select(_ => _.ToString("0.000")));

            return(baseChunk);
        }
Beispiel #8
0
        public MqChunk Child(string name, bool createIfNotFound = true)
        {
            var value = this.Children.FirstOrDefault(_ => _.Name.Equals(name, StringComparison.CurrentCulture));

            if (createIfNotFound && value == null)
            {
                this.Children.Add(value = new MqChunk
                {
                    Name = name,
                });
            }

            return(value);
        }
Beispiel #9
0
        public static MqChunk Parse(MqTokenizer tokenizer)
        {
            while (tokenizer.Current.Kind == MqTokenizer.NewLineTokenKind)
            {
                tokenizer.MoveNext();
            }

            var rt = new MqChunk
            {
                Name = tokenizer.Current.Kind == MqTokenizer.IdentifierTokenKind || tokenizer.Current.Kind == MqTokenizer.StringTokenKind
                                        ? tokenizer.Current.Text
                                        : null,
            };
            var args = tokenizer.StartWith(tokenizer.Current.Kind == MqTokenizer.DigitTokenKind ? new[] { tokenizer.Current } : new Token[0])
                       .TakeWhile(_ => _.Kind != MqTokenizer.BeginChildrenTokenKind && _.Kind != MqTokenizer.NewLineTokenKind)
                       .ToArray();

            rt.Arguments  = args.TakeWhile(_ => _.Kind == MqTokenizer.DigitTokenKind || _.Kind == MqTokenizer.StringTokenKind).Select(_ => _.Text).ToList();
            rt.Attributes = Util.Defer(() =>
            {
                var attrs   = args.Skip(rt.Arguments.Count);
                var current = attrs.FirstOrDefault();

                return(attrs.GroupBy(_ =>
                {
                    if (_.Kind == MqTokenizer.IdentifierTokenKind)
                    {
                        current = _;
                    }

                    return current;
                })
                       .Select(_ => new MqChunkAttribute
                {
                    Name = _.Key.Text,
                    Arguments = _.Skip(1).Select(t => t.Text).ToList(),
                }));
            }).ToList();

            if (tokenizer.Current.Kind == MqTokenizer.BeginChildrenTokenKind)
            {
                rt.Children = tokenizer.TakeWhile(_ => _.Kind != MqTokenizer.EndChildrenTokenKind)
                              .Select(_ => Parse(tokenizer))
                              .ToList();
                tokenizer.MoveNext(MqTokenizer.EndChildrenTokenKind);
            }

            return(rt);
        }
Beispiel #10
0
        public MqChunk ToChunk()
        {
            baseChunk = baseChunk ?? new MqChunk();
            baseChunk.SetArguments(this.Vertices.Length.ToString());
            baseChunk.SetAttributes(new[]
            {
                new MqChunkAttribute("V", this.Vertices.Select(_ => _.ToString())),
                new MqChunkAttribute("M", this.Material.ToString()),
                this.UV == null ? null : new MqChunkAttribute("UV", this.UV.SelectMany(_ => _).Select(f => f.ToString("0.00000"))),
                this.VertexColor == null ? null : new MqChunkAttribute("COL", this.VertexColor.Select(_ => _.ToString())),
            }
                                    .Where(_ => _ != null));

            return(baseChunk);
        }
Beispiel #11
0
        public static MqChunk Parse(MqTokenizer tokenizer)
        {
            while (tokenizer.Current.Kind == MqTokenizer.NewLineTokenKind)
                tokenizer.MoveNext();

            var rt = new MqChunk
            {
                Name = tokenizer.Current.Kind == MqTokenizer.IdentifierTokenKind || tokenizer.Current.Kind == MqTokenizer.StringTokenKind
                    ? tokenizer.Current.Text
                    : null,
            };
            var args = tokenizer.StartWith(tokenizer.Current.Kind == MqTokenizer.DigitTokenKind ? new[] { tokenizer.Current } : new Token[0])
                                .TakeWhile(_ => _.Kind != MqTokenizer.BeginChildrenTokenKind && _.Kind != MqTokenizer.NewLineTokenKind)
                                .ToArray();

            rt.Arguments = args.TakeWhile(_ => _.Kind == MqTokenizer.DigitTokenKind || _.Kind == MqTokenizer.StringTokenKind).Select(_ => _.Text).ToList();
            rt.Attributes = Util.Defer(() =>
            {
                var attrs = args.Skip(rt.Arguments.Count);
                var current = attrs.FirstOrDefault();

                return attrs.GroupBy(_ =>
                {
                    if (_.Kind == MqTokenizer.IdentifierTokenKind)
                        current = _;

                    return current;
                })
                .Select(_ => new MqChunkAttribute
                {
                    Name = _.Key.Text,
                    Arguments = _.Skip(1).Select(t => t.Text).ToList(),
                });
            }).ToList();

            if (tokenizer.Current.Kind == MqTokenizer.BeginChildrenTokenKind)
            {
                rt.Children = tokenizer.TakeWhile(_ => _.Kind != MqTokenizer.EndChildrenTokenKind)
                                       .Select(_ => Parse(tokenizer))
                                       .ToList();
                tokenizer.MoveNext(MqTokenizer.EndChildrenTokenKind);
            }

            return rt;
        }
Beispiel #12
0
        public static MqDirectionalLight Parse(MqChunk chunk)
        {
            var rt = new MqDirectionalLight
            {
                baseChunk = chunk,
            };

            foreach (var i in chunk.Children)
                switch (i.Name.ToLower())
                {
                    case "dir":
                        rt.Direction = i.Arguments.Select(float.Parse).ToArray();

                        break;
                    case "color":
                        rt.Color = i.Arguments.Select(float.Parse).ToArray();

                        break;
                }

            return rt;
        }
Beispiel #13
0
        public MqChunk ToChunk()
        {
            baseChunk      = baseChunk ?? new MqChunk();
            baseChunk.Name = "Scene";
            baseChunk.Child("pos").SetArguments(this.Position.Select(_ => _.ToString("0.0000")));
            baseChunk.Child("lookat").SetArguments(this.LookAt.Select(_ => _.ToString("0.0000")));
            baseChunk.Child("head").SetArguments(this.Head.ToString("0.0000"));
            baseChunk.Child("pich").SetArguments(this.Pitch.ToString("0.0000"));
            baseChunk.Child("bank").SetArguments(this.Bank.ToString("0.0000"));
            baseChunk.Child("ortho").SetArguments(this.Ortho ? "1" : "0");
            baseChunk.Child("zoom2").SetArguments(this.Zoom2.ToString("0.0000"));
            baseChunk.Child("amb").SetArguments(this.Ambient.Select(_ => _.ToString("0.000")));

            if (this.DirectionalLights.Any())
            {
                baseChunk.Child("dirlights").SetArguments(this.DirectionalLights.Count.ToString()).SetChildren(this.DirectionalLights.Select(_ => _.ToChunk()));
            }
            else
            {
                baseChunk.RemoveChildren("dirlights");
            }

            return(baseChunk);
        }
Beispiel #14
0
        public MqChunk ToChunk()
        {
            baseChunk = baseChunk ?? new MqChunk();
            baseChunk.Name = "Scene";
            baseChunk.Child("pos").SetArguments(this.Position.Select(_ => _.ToString("0.0000")));
            baseChunk.Child("lookat").SetArguments(this.LookAt.Select(_ => _.ToString("0.0000")));
            baseChunk.Child("head").SetArguments(this.Head.ToString("0.0000"));
            baseChunk.Child("pich").SetArguments(this.Pitch.ToString("0.0000"));
            baseChunk.Child("bank").SetArguments(this.Bank.ToString("0.0000"));
            baseChunk.Child("ortho").SetArguments(this.Ortho ? "1" : "0");
            baseChunk.Child("zoom2").SetArguments(this.Zoom2.ToString("0.0000"));
            baseChunk.Child("amb").SetArguments(this.Ambient.Select(_ => _.ToString("0.000")));

            if (this.DirectionalLights.Any())
                baseChunk.Child("dirlights").SetArguments(this.DirectionalLights.Count.ToString()).SetChildren(this.DirectionalLights.Select(_ => _.ToChunk()));
            else
                baseChunk.RemoveChildren("dirlights");

            return baseChunk;
        }
Beispiel #15
0
        public static MqScene Parse(MqChunk chunk)
        {
            var rt = new MqScene
            {
                baseChunk = chunk,
            };

            foreach (var i in chunk.Children)
                switch (i.Name.ToLower())
                {
                    case "pos":
                        rt.Position = i.Arguments.Select(float.Parse).ToArray();

                        break;
                    case "lookat":
                        rt.LookAt = i.Arguments.Select(float.Parse).ToArray();

                        break;
                    case "head":
                        rt.Head = float.Parse(i.Arguments.First());

                        break;
                    case "pich":
                        rt.Pitch = float.Parse(i.Arguments.First());

                        break;
                    case "bank":
                        rt.Bank = float.Parse(i.Arguments.First());

                        break;
                    case "ortho":
                        rt.Ortho = i.Arguments.First() == "1";

                        break;
                    case "zoom2":
                        rt.Zoom2 = float.Parse(i.Arguments.First());

                        break;
                    case "amb":
                        rt.Ambient = i.Arguments.Select(float.Parse).ToArray();

                        break;
                    case "dirlights":
                        rt.DirectionalLights = i.Children.Select(MqDirectionalLight.Parse).ToList();

                        break;
                }

            return rt;
        }
Beispiel #16
0
        public MqChunk ToChunk()
        {
            baseChunk      = baseChunk ?? new MqChunk();
            baseChunk.Name = Surround(this.Name);
            baseChunk.Attribute("shader").SetArguments(((int)this.Shader).ToString());
            baseChunk.Attribute("vcol").SetArguments(this.VertexColor ? "1" : "0");
            baseChunk.Attribute("col").SetArguments(this.Color.Select(_ => _.ToString("0.000")));
            baseChunk.Attribute("dif").SetArguments(this.Diffusion.ToString("0.000"));
            baseChunk.Attribute("amb").SetArguments(this.Ambient.ToString("0.000"));
            baseChunk.Attribute("emi").SetArguments(this.Emmisive.ToString("0.000"));
            baseChunk.Attribute("spc").SetArguments(this.Specular.ToString("0.000"));
            baseChunk.Attribute("power").SetArguments(this.Power.ToString("0.000"));

            if (string.IsNullOrEmpty(this.Texture))
            {
                baseChunk.RemoveAttributes("tex");
            }
            else
            {
                baseChunk.Attribute("tex").SetArguments(Surround(this.Texture));
            }

            if (string.IsNullOrEmpty(this.AlphaMap))
            {
                baseChunk.RemoveAttributes("aplane");
            }
            else
            {
                baseChunk.Attribute("aplane").SetArguments(Surround(this.AlphaMap));
            }

            if (string.IsNullOrEmpty(this.Bump))
            {
                baseChunk.RemoveAttributes("bump");
            }
            else
            {
                baseChunk.Attribute("bump").SetArguments(Surround(this.Bump));
            }

            if (this.ProjectionType == MqProjectionType.UV)
            {
                baseChunk.RemoveAttributes("proj_type");
            }
            else
            {
                baseChunk.Attribute("proj_type").SetArguments(((int)this.ProjectionType).ToString());
            }

            if (this.ProjectionPosition.All(_ => _ == 0))
            {
                baseChunk.RemoveAttributes("proj_pos");
            }
            else
            {
                baseChunk.Attribute("proj_pos").SetArguments(this.ProjectionPosition.Select(_ => _.ToString("0.000")));
            }

            if (this.ProjectionScale.All(_ => _ == 1))
            {
                baseChunk.RemoveAttributes("proj_scale");
            }
            else
            {
                baseChunk.Attribute("proj_scale").SetArguments(this.ProjectionScale.Select(_ => _.ToString("0.000")));
            }

            if (this.ProjectionAngle.All(_ => _ == 0))
            {
                baseChunk.RemoveAttributes("proj_angle");
            }
            else
            {
                baseChunk.Attribute("proj_angle").SetArguments(this.ProjectionAngle.Select(_ => _.ToString("0.000")));
            }

            return(baseChunk);
        }
Beispiel #17
0
        public static MqMaterial Parse(MqChunk chunk)
        {
            var rt = new MqMaterial
            {
                baseChunk = chunk,
                Name      = chunk.Name.Trim('"'),
            };

            foreach (var i in chunk.Attributes)
            {
                switch (i.Name.ToLower())
                {
                case "shader":
                    rt.Shader = (MqShader)int.Parse(i.Arguments.First());

                    break;

                case "vcol":
                    rt.VertexColor = i.Arguments.FirstOrDefault() == "1";

                    break;

                case "col":
                    rt.Color = i.Arguments.Select(float.Parse).ToArray();

                    break;

                case "dif":
                    rt.Diffusion = float.Parse(i.Arguments.First());

                    break;

                case "amb":
                    rt.Ambient = float.Parse(i.Arguments.First());

                    break;

                case "emi":
                    rt.Emmisive = float.Parse(i.Arguments.First());

                    break;

                case "spc":
                    rt.Specular = float.Parse(i.Arguments.First());

                    break;

                case "power":
                    rt.Power = float.Parse(i.Arguments.First());

                    break;

                case "tex":
                    rt.Texture = i.Arguments.First().Trim('"');

                    break;

                case "aplane":
                    rt.Texture = i.Arguments.First().Trim('"');

                    break;

                case "bump":
                    rt.Texture = i.Arguments.First().Trim('"');

                    break;

                case "proj_type":
                    rt.ProjectionType = (MqProjectionType)int.Parse(i.Arguments.First());

                    break;

                case "proj_pos":
                    rt.ProjectionPosition = i.Arguments.Select(float.Parse).ToArray();

                    break;

                case "proj_scale":
                    rt.ProjectionScale = i.Arguments.Select(float.Parse).ToArray();

                    break;

                case "proj_angle":
                    rt.ProjectionAngle = i.Arguments.Select(float.Parse).ToArray();

                    break;
                }
            }

            return(rt);
        }
Beispiel #18
0
        public static MqObject Parse(MqChunk chunk)
        {
            var rt = new MqObject
            {
                Name = chunk.Arguments.First().Trim('"'),
            };

            foreach (var i in chunk.Children)
                switch (i.Name.ToLower())
                {
                    case "depth":
                        rt.Depth = int.Parse(i.Arguments.First());

                        break;
                    case "folding":
                        rt.Folding = i.Arguments.First() == "1";

                        break;
                    case "scale":
                        rt.Scale = i.Arguments.Select(float.Parse).ToArray();

                        break;
                    case "rotation":
                        rt.Rotation = i.Arguments.Select(float.Parse).ToArray();

                        break;
                    case "translation":
                        rt.Translation = i.Arguments.Select(float.Parse).ToArray();

                        break;
                    case "patch":
                        rt.Patch = (MqPatchType)int.Parse(i.Arguments.First());

                        break;
                    case "segment":
                        rt.Segment = int.Parse(i.Arguments.First());

                        break;
                    case "visible":
                        rt.Visible = i.Arguments.First() == "15";

                        break;
                    case "locking":
                        rt.Locking = i.Arguments.First() == "1";

                        break;
                    case "shading":
                        rt.Shading = (MqShading)int.Parse(i.Arguments.First());

                        break;
                    case "facet":
                        rt.Facet = float.Parse(i.Arguments.First());

                        break;
                    case "color":
                        rt.Color = i.Arguments.Select(float.Parse).ToArray();

                        break;
                    case "color_type":
                        rt.ColorType = i.Arguments.First() == "1";

                        break;
                    case "mirror":
                        rt.Mirror = (MqMirrorType)int.Parse(i.Arguments.First());

                        break;
                    case "mirror_axis":
                        rt.MirrorAxis = (MqMirrorAxis)int.Parse(i.Arguments.First());

                        break;
                    case "mirror_dis":
                        rt.MirrorDistance = float.Parse(i.Arguments.First());

                        break;
                    case "lathe":
                        rt.Lathe = (MqLatheType)int.Parse(i.Arguments.First());

                        break;
                    case "lathe_axis":
                        rt.LatheAxis = (MqLatheAxis)int.Parse(i.Arguments.First());

                        break;
                    case "lathe_seg":
                        rt.LatheSegments = int.Parse(i.Arguments.First());

                        break;
                    case "vertex":
                        rt.Vertex = i.Children.Select(_ => _.Arguments.Select(float.Parse).ToArray()).ToList();

                        break;
                    case "vertexattr":
                        var children = i.Children.ToDictionary(_ => _.Name);

                        if (children.ContainsKey("weit"))
                            foreach (var j in children["weit"].Children)
                                rt.Weight.Add(int.Parse(j.Arguments.First()), float.Parse(j.Arguments[1]));

                        break;
                    case "face":
                        rt.Faces = i.Children.Select(MqFace.Parse).ToList();

                        break;
                }

            return rt;
        }
Beispiel #19
0
        public MqChunk Child(string name, bool createIfNotFound = true)
        {
            var value = this.Children.FirstOrDefault(_ => _.Name.Equals(name, StringComparison.CurrentCulture));

            if (createIfNotFound && value == null)
                this.Children.Add(value = new MqChunk
                {
                    Name = name,
                });

            return value;
        }
Beispiel #20
0
        public MqChunk ToChunk()
        {
            baseChunk = baseChunk ?? new MqChunk();
            baseChunk.Name = "Object";
            baseChunk.SetArguments("\"" + this.Name + "\"");
            baseChunk.Child("depth").SetArguments(this.Depth.ToString());
            baseChunk.Child("folding").SetArguments(this.Folding ? "1" : "0");
            baseChunk.Child("scale").SetArguments(this.Scale.Select(_ => _.ToString("0.000000")));
            baseChunk.Child("rotation").SetArguments(this.Scale.Select(_ => _.ToString("0.000000")));
            baseChunk.Child("translation").SetArguments(this.Scale.Select(_ => _.ToString("0.000000")));

            if (this.Patch == MqPatchType.None)
            {
                baseChunk.RemoveChildren("patch");
                baseChunk.RemoveChildren("segment");
            }
            else
            {
                baseChunk.Child("patch").SetArguments(((int)this.Patch).ToString());
                baseChunk.Child("segment").SetArguments(this.Segment.ToString());
            }

            baseChunk.Child("visible").SetArguments(this.Visible ? "15" : "0");
            baseChunk.Child("locking").SetArguments(this.Locking ? "1" : "0");
            baseChunk.Child("shading").SetArguments(((int)this.Shading).ToString());
            baseChunk.Child("facet").SetArguments(this.Facet.ToString("0.0"));
            baseChunk.Child("color").SetArguments(this.Color.Select(_ => _.ToString("0.000")));
            baseChunk.Child("color_type").SetArguments(this.ColorType ? "1" : "0");

            if (this.Mirror == MqMirrorType.None)
                baseChunk.RemoveChildren("mirror");
            else
            {
                baseChunk.Child("mirror").SetArguments(((int)this.Mirror).ToString());
                baseChunk.Child("mirror_axis").SetArguments(((int)this.MirrorAxis).ToString());
                baseChunk.Child("mirror_dis").SetArguments(this.MirrorDistance.ToString("0.000"));
            }

            if (this.Lathe == MqLatheType.None)
                baseChunk.RemoveChildren("lathe");
            else
            {
                baseChunk.Child("lathe").SetArguments(((int)this.Lathe).ToString());
                baseChunk.Child("lathe_axis").SetArguments(((int)this.LatheAxis).ToString());
                baseChunk.Child("lathe_seg").SetArguments(this.LatheSegments.ToString());
            }

            baseChunk.Child("vertex").SetArguments(this.Vertex.Count.ToString()).SetChildren(this.Vertex.Select(v => new MqChunk().SetArguments(v.Select(_ => _.ToString("0.0000")))));

            if (this.Weight.Any())
                baseChunk.Child("vertexattr").Child("weit").SetChildren(this.Weight.Select(_ => new MqChunk().SetArguments(_.Key.ToString(), _.Value.ToString("0.000"))));
            else
            {
                var attr = baseChunk.Child("vertexattr");

                attr.RemoveChildren("weit");

                if (!attr.Children.Any())
                    baseChunk.RemoveChildren("vertexattr");
            }

            baseChunk.Child("face").SetArguments(this.Faces.Count.ToString()).SetChildren(this.Faces.Select(_ => _.ToChunk()));

            return baseChunk;
        }
Beispiel #21
0
        public static MqMaterial Parse(MqChunk chunk)
        {
            var rt = new MqMaterial
            {
                baseChunk = chunk,
                Name = chunk.Name.Trim('"'),
            };

            foreach (var i in chunk.Attributes)
                switch (i.Name.ToLower())
                {
                    case "shader":
                        rt.Shader = (MqShader)int.Parse(i.Arguments.First());

                        break;
                    case "vcol":
                        rt.VertexColor = i.Arguments.FirstOrDefault() == "1";

                        break;
                    case "col":
                        rt.Color = i.Arguments.Select(float.Parse).ToArray();

                        break;
                    case "dif":
                        rt.Diffusion = float.Parse(i.Arguments.First());

                        break;
                    case "amb":
                        rt.Ambient = float.Parse(i.Arguments.First());

                        break;
                    case "emi":
                        rt.Emmisive = float.Parse(i.Arguments.First());

                        break;
                    case "spc":
                        rt.Specular = float.Parse(i.Arguments.First());

                        break;
                    case "power":
                        rt.Power = float.Parse(i.Arguments.First());

                        break;
                    case "tex":
                        rt.Texture = i.Arguments.First().Trim('"');

                        break;
                    case "aplane":
                        rt.Texture = i.Arguments.First().Trim('"');

                        break;
                    case "bump":
                        rt.Texture = i.Arguments.First().Trim('"');

                        break;
                    case "proj_type":
                        rt.ProjectionType = (MqProjectionType)int.Parse(i.Arguments.First());

                        break;
                    case "proj_pos":
                        rt.ProjectionPosition = i.Arguments.Select(float.Parse).ToArray();

                        break;
                    case "proj_scale":
                        rt.ProjectionScale = i.Arguments.Select(float.Parse).ToArray();

                        break;
                    case "proj_angle":
                        rt.ProjectionAngle = i.Arguments.Select(float.Parse).ToArray();

                        break;
                }

            return rt;
        }
Beispiel #22
0
        public MqChunk ToChunk()
        {
            baseChunk = baseChunk ?? new MqChunk();
            baseChunk.Name = Surround(this.Name);
            baseChunk.Attribute("shader").SetArguments(((int)this.Shader).ToString());
            baseChunk.Attribute("vcol").SetArguments(this.VertexColor ? "1" : "0");
            baseChunk.Attribute("col").SetArguments(this.Color.Select(_ => _.ToString("0.000")));
            baseChunk.Attribute("dif").SetArguments(this.Diffusion.ToString("0.000"));
            baseChunk.Attribute("amb").SetArguments(this.Ambient.ToString("0.000"));
            baseChunk.Attribute("emi").SetArguments(this.Emmisive.ToString("0.000"));
            baseChunk.Attribute("spc").SetArguments(this.Specular.ToString("0.000"));
            baseChunk.Attribute("power").SetArguments(this.Power.ToString("0.000"));

            if (string.IsNullOrEmpty(this.Texture))
                baseChunk.RemoveAttributes("tex");
            else
                baseChunk.Attribute("tex").SetArguments(Surround(this.Texture));

            if (string.IsNullOrEmpty(this.AlphaMap))
                baseChunk.RemoveAttributes("aplane");
            else
                baseChunk.Attribute("aplane").SetArguments(Surround(this.AlphaMap));

            if (string.IsNullOrEmpty(this.Bump))
                baseChunk.RemoveAttributes("bump");
            else
                baseChunk.Attribute("bump").SetArguments(Surround(this.Bump));

            if (this.ProjectionType == MqProjectionType.UV)
                baseChunk.RemoveAttributes("proj_type");
            else
                baseChunk.Attribute("proj_type").SetArguments(((int)this.ProjectionType).ToString());

            if (this.ProjectionPosition.All(_ => _ == 0))
                baseChunk.RemoveAttributes("proj_pos");
            else
                baseChunk.Attribute("proj_pos").SetArguments(this.ProjectionPosition.Select(_ => _.ToString("0.000")));

            if (this.ProjectionScale.All(_ => _ == 1))
                baseChunk.RemoveAttributes("proj_scale");
            else
                baseChunk.Attribute("proj_scale").SetArguments(this.ProjectionScale.Select(_ => _.ToString("0.000")));

            if (this.ProjectionAngle.All(_ => _ == 0))
                baseChunk.RemoveAttributes("proj_angle");
            else
                baseChunk.Attribute("proj_angle").SetArguments(this.ProjectionAngle.Select(_ => _.ToString("0.000")));

            return baseChunk;
        }
Beispiel #23
0
        public MqChunk ToChunk()
        {
            baseChunk = baseChunk ?? new MqChunk();
            baseChunk.SetArguments(this.Vertices.Length.ToString());
            baseChunk.SetAttributes(new[]
            {
                new MqChunkAttribute("V", this.Vertices.Select(_ => _.ToString())),
                new MqChunkAttribute("M", this.Material.ToString()),
                this.UV == null ? null : new MqChunkAttribute("UV", this.UV.SelectMany(_ => _).Select(f => f.ToString("0.00000"))),
                this.VertexColor == null ? null : new MqChunkAttribute("COL", this.VertexColor.Select(_ => _.ToString())),
            }
            .Where(_ => _ != null));

            return baseChunk;
        }
Beispiel #24
0
        public static MqObject Parse(MqChunk chunk)
        {
            var rt = new MqObject
            {
                Name = chunk.Arguments.First().Trim('"'),
            };

            foreach (var i in chunk.Children)
            {
                switch (i.Name.ToLower())
                {
                case "depth":
                    rt.Depth = int.Parse(i.Arguments.First());

                    break;

                case "folding":
                    rt.Folding = i.Arguments.First() == "1";

                    break;

                case "scale":
                    rt.Scale = i.Arguments.Select(float.Parse).ToArray();

                    break;

                case "rotation":
                    rt.Rotation = i.Arguments.Select(float.Parse).ToArray();

                    break;

                case "translation":
                    rt.Translation = i.Arguments.Select(float.Parse).ToArray();

                    break;

                case "patch":
                    rt.Patch = (MqPatchType)int.Parse(i.Arguments.First());

                    break;

                case "segment":
                    rt.Segment = int.Parse(i.Arguments.First());

                    break;

                case "visible":
                    rt.Visible = i.Arguments.First() == "15";

                    break;

                case "locking":
                    rt.Locking = i.Arguments.First() == "1";

                    break;

                case "shading":
                    rt.Shading = (MqShading)int.Parse(i.Arguments.First());

                    break;

                case "facet":
                    rt.Facet = float.Parse(i.Arguments.First());

                    break;

                case "color":
                    rt.Color = i.Arguments.Select(float.Parse).ToArray();

                    break;

                case "color_type":
                    rt.ColorType = i.Arguments.First() == "1";

                    break;

                case "mirror":
                    rt.Mirror = (MqMirrorType)int.Parse(i.Arguments.First());

                    break;

                case "mirror_axis":
                    rt.MirrorAxis = (MqMirrorAxis)int.Parse(i.Arguments.First());

                    break;

                case "mirror_dis":
                    rt.MirrorDistance = float.Parse(i.Arguments.First());

                    break;

                case "lathe":
                    rt.Lathe = (MqLatheType)int.Parse(i.Arguments.First());

                    break;

                case "lathe_axis":
                    rt.LatheAxis = (MqLatheAxis)int.Parse(i.Arguments.First());

                    break;

                case "lathe_seg":
                    rt.LatheSegments = int.Parse(i.Arguments.First());

                    break;

                case "vertex":
                    rt.Vertex = i.Children.Select(_ => _.Arguments.Select(float.Parse).ToArray()).ToList();

                    break;

                case "vertexattr":
                    var children = i.Children.ToDictionary(_ => _.Name);

                    if (children.ContainsKey("weit"))
                    {
                        foreach (var j in children["weit"].Children)
                        {
                            rt.Weight.Add(int.Parse(j.Arguments.First()), float.Parse(j.Arguments[1]));
                        }
                    }

                    break;

                case "face":
                    rt.Faces = i.Children.Select(MqFace.Parse).ToList();

                    break;
                }
            }

            return(rt);
        }
Beispiel #25
0
        public MqChunk ToChunk()
        {
            baseChunk      = baseChunk ?? new MqChunk();
            baseChunk.Name = "Object";
            baseChunk.SetArguments("\"" + this.Name + "\"");
            baseChunk.Child("depth").SetArguments(this.Depth.ToString());
            baseChunk.Child("folding").SetArguments(this.Folding ? "1" : "0");
            baseChunk.Child("scale").SetArguments(this.Scale.Select(_ => _.ToString("0.000000")));
            baseChunk.Child("rotation").SetArguments(this.Scale.Select(_ => _.ToString("0.000000")));
            baseChunk.Child("translation").SetArguments(this.Scale.Select(_ => _.ToString("0.000000")));

            if (this.Patch == MqPatchType.None)
            {
                baseChunk.RemoveChildren("patch");
                baseChunk.RemoveChildren("segment");
            }
            else
            {
                baseChunk.Child("patch").SetArguments(((int)this.Patch).ToString());
                baseChunk.Child("segment").SetArguments(this.Segment.ToString());
            }

            baseChunk.Child("visible").SetArguments(this.Visible ? "15" : "0");
            baseChunk.Child("locking").SetArguments(this.Locking ? "1" : "0");
            baseChunk.Child("shading").SetArguments(((int)this.Shading).ToString());
            baseChunk.Child("facet").SetArguments(this.Facet.ToString("0.0"));
            baseChunk.Child("color").SetArguments(this.Color.Select(_ => _.ToString("0.000")));
            baseChunk.Child("color_type").SetArguments(this.ColorType ? "1" : "0");

            if (this.Mirror == MqMirrorType.None)
            {
                baseChunk.RemoveChildren("mirror");
            }
            else
            {
                baseChunk.Child("mirror").SetArguments(((int)this.Mirror).ToString());
                baseChunk.Child("mirror_axis").SetArguments(((int)this.MirrorAxis).ToString());
                baseChunk.Child("mirror_dis").SetArguments(this.MirrorDistance.ToString("0.000"));
            }

            if (this.Lathe == MqLatheType.None)
            {
                baseChunk.RemoveChildren("lathe");
            }
            else
            {
                baseChunk.Child("lathe").SetArguments(((int)this.Lathe).ToString());
                baseChunk.Child("lathe_axis").SetArguments(((int)this.LatheAxis).ToString());
                baseChunk.Child("lathe_seg").SetArguments(this.LatheSegments.ToString());
            }

            baseChunk.Child("vertex").SetArguments(this.Vertex.Count.ToString()).SetChildren(this.Vertex.Select(v => new MqChunk().SetArguments(v.Select(_ => _.ToString("0.0000")))));

            if (this.Weight.Any())
            {
                baseChunk.Child("vertexattr").Child("weit").SetChildren(this.Weight.Select(_ => new MqChunk().SetArguments(_.Key.ToString(), _.Value.ToString("0.000"))));
            }
            else
            {
                var attr = baseChunk.Child("vertexattr");

                attr.RemoveChildren("weit");

                if (!attr.Children.Any())
                {
                    baseChunk.RemoveChildren("vertexattr");
                }
            }

            baseChunk.Child("face").SetArguments(this.Faces.Count.ToString()).SetChildren(this.Faces.Select(_ => _.ToChunk()));

            return(baseChunk);
        }