Beispiel #1
0
        public void Resize(float scale)
        {
            AABB = new RectangleAABB();
            var a = AABB.A;
            var b = AABB.B;

            foreach (var part in Parts)
            {
                for (var i = 0; i < part.Vertices.Length; i++)
                {
                    var vertex = part.Vertices[i];
                    vertex.OriginalPosition = vertex.Position;
                    vertex.Position.X      *= scale;
                    vertex.Position.Y      *= scale;
                    vertex.Position.Z      *= scale;
                    part.Vertices[i]        = vertex;
                }
                foreach (var p in part.Points)
                {
                    p.Position = p.Position * scale;
                }
                foreach (var p in part.MorphPoints)
                {
                    p.Position = p.Position * scale;
                }
                UpdateAABB(part, ref a, ref b);
            }
            AABB.A = a;
            AABB.B = b;
        }
Beispiel #2
0
        public static RectangleAABB FromStream(BinaryReader br)
        {
            var result = new RectangleAABB();

            result.A = Vector3Ex.FromStream(br);
            result.B = Vector3Ex.FromStream(br);
            return(result);
        }
Beispiel #3
0
        public float SetSize(float diagonal)
        {
            Vector2 a = new Vector2(99999.0f, 99999.0f), b = new Vector2(-99999.0f, -99999.0f);


            foreach (var part in Parts)
            {
                foreach (var vertex in part.Vertices)
                {
                    a.X = Math.Min(vertex.Position.X, a.X);
                    a.Y = Math.Min(vertex.Position.Y, a.Y);
                    b.X = Math.Max(vertex.Position.X, b.X);
                    b.Y = Math.Max(vertex.Position.Y, b.Y);
                }
            }


            var d = (b - a).Length;

            if (d == 0.0f)
            {
                return(0.0f);
            }
            var scale = diagonal / d;

            AABB = new RectangleAABB();
            var a1 = AABB.A;
            var b1 = AABB.B;

            foreach (var part in Parts)
            {
                for (var i = 0; i < part.Vertices.Length; i++)
                {
                    var vertex = part.Vertices[i];
                    vertex.OriginalPosition = vertex.Position * scale;
                    vertex.Position.X      *= scale;
                    vertex.Position.Y      *= scale;
                    vertex.Position.Z      *= scale;
                    part.Vertices[i]        = vertex;
                }
                foreach (var p in part.Points)
                {
                    p.Position = p.Position * scale;
                }
                foreach (var p in part.MorphPoints)
                {
                    p.Position = p.Position * scale;
                }

                UpdateAABB(part, ref a1, ref b1);
            }
            AABB.A = a1;
            AABB.B = b1;
            return(1.0f / scale);
        }
Beispiel #4
0
        public float Transform(float k, RectangleAABB aabb)
        {
            if (Parts.Count == 0)
            {
                return(0.0f);
            }
            AABB = aabb;
            var newWidht = aabb.Height * k;
            var scaleX   = newWidht / aabb.Width;
            //Scale.X = scaleX;
            //Scale.X = 1.0f;//(float)Math.Sqrt(Math.Abs(k * AABB.Size.Y / AABB.Size.X));
            //Scale.Y = 1.0f / Scale.X;
            var centerX = (aabb.B.X + aabb.A.X) * 0.5f;

            //var count = 0.0f;
            //foreach (var part in Parts)
            //    foreach (var v in part.Vertices)
            //    {
            //        count += 1.0f;
            //        center += v.Position;
            //    }
            //center /= count;
            //Center = center.Xy;

            foreach (var part in Parts)
            {
                for (var i = 0; i < part.Vertices.Length; i++)
                {
                    var vertex = part.Vertices[i];
                    vertex.OriginalPosition = vertex.Position;
                    vertex.Position.X      -= centerX;
                    vertex.Position.X      *= scaleX;
                    //vertex.Position.Y *= Scale.Y;
                    vertex.Position.X += centerX;
                    part.Vertices[i]   = vertex;
                }
                foreach (var p in part.Points)
                {
                    var pos = p.Position;
                    pos.X -= centerX;
                    pos.X *= scaleX;
                    //pos.Y *= Scale.Y;
                    pos.X     += centerX;
                    p.Position = pos;
                }
            }

            AABB.A = new Vector3((AABB.A.X - centerX) * scaleX + centerX, AABB.A.Y, AABB.A.Z);
            AABB.B = new Vector3((AABB.B.X - centerX) * scaleX + centerX, AABB.B.Y, AABB.B.Z);
            return(scaleX);
        }
Beispiel #5
0
        public void SetBlendingInfo(Vector2 leye, Vector2 reye, Vector2 lip, Vector2 face)
        {
            var aabb = new RectangleAABB();

            var a = aabb.A;
            var b = aabb.B;

            a.Y    = Math.Min(Math.Min(leye.Y, lip.Y), reye.Y);
            b.Y    = Math.Max(Math.Max(leye.Y, lip.Y), reye.Y);
            a.X    = Math.Min(Math.Min(leye.X, lip.X), reye.X);
            b.X    = Math.Max(Math.Max(leye.X, lip.X), reye.X);
            aabb.A = a;
            aabb.B = b;

            BlendingInfos.Clear();
            var radius = Math.Abs(leye.X - reye.X) * 0.2f;

            BlendingInfos.Add(new BlendingInfo
            {
                Position = leye,
                Radius   = radius
            });
            BlendingInfos.Add(new BlendingInfo
            {
                Position = reye,
                Radius   = radius
            });
            BlendingInfos.Add(new BlendingInfo
            {
                Position = aabb.Center.Xy,
                Radius   = (aabb.Center.Xy - aabb.B.Xy).Length * 0.4f
            });
            BlendingInfos.Add(new BlendingInfo
            {
                Position = lip,
                Radius   = (aabb.Center.Xy - lip).Length * 0.5f
            });
            BlendingInfos.Add(new BlendingInfo
            {
                Position = (leye + reye) * 0.5f,
                Radius   = (aabb.B.Xy - face).Length * 0.4f
            });
            foreach (var part in Parts)
            {
                part.FillBlendingData(BlendingInfos);
            }
        }
Beispiel #6
0
        public void Load(string path)
        {
            if (!File.Exists(path))
            {
                return;
            }

            Parts.Clear();
            using (var br = new BinaryReader(File.Open(path, FileMode.Open)))
            {
                AABB       = RectangleAABB.FromStream(br);
                Scale      = Vector2Ex.FromStream(br);
                Center     = Vector2Ex.FromStream(br);
                MorphScale = br.ReadSingle();

                var cnt = br.ReadInt32();
                for (var i = 0; i < cnt; i++)
                {
                    Parts.Add(RenderMeshPart.FromStream(br));
                }
            }
        }