Example #1
0
        public static Eixos2 operator +(Eixos2 a, Eixos2 b)
        {
            Eixos2 ret = (Eixos2)a.NovaInstancia();

            ret.X = a.X + b.X;
            ret.Y = a.Y + b.Y;
            return(ret);
        }
Example #2
0
 public Eixos2(Eixos2 eixos)
 {
     Obj    = eixos.Obj;
     this.X = eixos.X;
     this.Y = eixos.Y;
     Nome   = eixos.Nome;
     Tag    = eixos.Tag;
 }
Example #3
0
        /// <summary>
        /// Obtém a posição no espaço 2D através da coordenada x e y da tela
        /// </summary>
        /// <param name="cam"></param>
        /// <param name="mouseXY"></param>
        /// <returns>Retorna ponto 2d pela coordenada X e Y da tela</returns>
        public static Eixos2 ObterPosEspaco2DMouseXY(
            this Camera2D cam, Eixos2 mouseXY)
        {
            Vetor2 PosCamZoomDiff = new Vetor2();

            PosCamZoomDiff = cam.Pos / cam.PosZ * cam.ZoomCamera - cam.Pos;

            float x = cam.Left + mouseXY.X + PosCamZoomDiff.X;
            float y = cam.Top + mouseXY.Y + PosCamZoomDiff.Y;

            Vetor2 ponto   = new Vetor2(x * cam.PosZ / cam.ZoomCamera, y * cam.PosZ / cam.ZoomCamera); // Reduz escala para tamanho real em 2D
            Eixos2 ponto2D = Util2D.RotacionarPonto2D(cam.Pos, ponto, cam.Angulo.Z);                   // Rotaciona ponto no tamanho real

            return(ponto2D);
        }
Example #4
0
        public static PointF ObterXYTelaPeloEspaco2D(this Camera2D cam, Eixos2 pos2D)
        {
            Vetor2 PosCam         = new Vetor2(cam.Pos);
            Vetor2 PosCamZoomDiff = new Vetor2();

            PosCamZoomDiff = cam.Pos / cam.PosZ * cam.ZoomCamera - cam.Pos;

            Vetor2 globalPos = (Vetor2)pos2D * cam.ZoomCamera / cam.PosZ;
            Eixos2 rot       = Util2D.RotacionarPonto2D(PosCam * cam.ZoomCamera / cam.PosZ,
                                                        globalPos, -cam.Angulo.Z);

            PointF pontoTela = new PointF();

            pontoTela.X = -cam.Left - PosCamZoomDiff.X + rot.X;
            pontoTela.Y = -cam.Top - PosCamZoomDiff.Y + rot.Y;

            return(pontoTela);
        }
Example #5
0
        /// <summary>
        /// Obtém objetos no espaço 2D conforme a seleção pela tela da câmera
        /// </summary>
        /// <param name="engine"></param>
        /// <param name="cam"></param>
        /// <param name="verticesTela"></param>
        /// <returns></returns>
        public static IEnumerable <Objeto2D> ObterObjetos2DMouseXY(this EpicoGraphics engine, Camera2D cam, params Vertice2[] verticesTela)
        {
            for (int i = 0; i < verticesTela.Length; i++)
            {
                // Converte X e Y da tela para as coordenadas X e Y no mundo 2D
                Eixos2 xy = ObterPosEspaco2DMouseXY(cam, verticesTela[i]);
                verticesTela[i].X = xy.X;
                verticesTela[i].Y = xy.Y;
            }

            for (int i = 0; i < engine.objetos2D.Count; i++)
            {
                if (IntersecaoEntrePoligonos(verticesTela,
                                             engine.objetos2D[i].Vertices.Select(x => new Vertice2(x.Global.X, x.Global.Y)).ToArray()))
                {
                    yield return(engine.objetos2D[i]);
                }
            }
        }
Example #6
0
        /// <summary>
        /// Interseção entre uma reta e um retângulo
        /// </summary>
        /// <param name="pontoA"></param>
        /// <param name="pontoB"></param>
        /// <param name="minX"></param>
        /// <param name="minY"></param>
        /// <param name="maxX"></param>
        /// <param name="maxY"></param>
        /// <returns></returns>
        public static bool IntersecaoRetaRetangulo(Eixos2 pontoA, Eixos2 pontoB, float minX, float minY, float maxX, float maxY)
        {
            // Completamente fora!
            if ((pontoA.X <= minX && pontoB.X <= minX) || (pontoA.Y <= minY && pontoB.Y <= minY) ||
                (pontoA.X >= maxX && pontoB.X >= maxX) || (pontoA.Y >= maxY && pontoB.Y >= maxY))
            {
                return(false);
            }

            float m = (pontoB.Y - pontoA.Y) / (pontoB.X - pontoA.X);

            float y = m * (minX - pontoA.X) + pontoA.Y;

            if (y >= minY && y <= maxY)
            {
                return(true);
            }

            y = m * (maxX - pontoA.X) + pontoA.Y;
            if (y >= minY && y <= maxY)
            {
                return(true);
            }

            float x = (minY - pontoA.Y) / m + pontoA.X;

            if (x >= minX && x <= maxX)
            {
                return(true);
            }

            x = (maxY - pontoA.Y) / m + pontoA.X;
            if (x >= minX && x <= maxX)
            {
                return(true);
            }

            return(false);
        }
Example #7
0
        public static IEnumerable <Origem2> ObterOrigensObjeto2DPelaTela(this Camera2D cam, List <Objeto2D> objs, params Vertice2[] verticesTela)
        {
            for (int i = 0; i < verticesTela.Length; i++)
            {
                // Converte X e Y da tela para as coordenadas X e Y no mundo 2D
                Eixos2 xy = ObterPosEspaco2DMouseXY(cam, verticesTela[i]);
                verticesTela[i].X = xy.X;
                verticesTela[i].Y = xy.Y;
            }

            for (int o = 0; o < objs.Count; o++)
            {
                Objeto2D obj = objs[o];
                for (int i = 0; i < obj.Origens.Count; i++)
                {
                    Origem2 origem = obj.Origens[i];
                    if (IntersecaoEntrePoligonos(verticesTela,
                                                 new Vertice2(origem.Global.X, origem.Global.Y)))
                    {
                        yield return(origem);
                    }
                }
            }
        }
Example #8
0
 /// <summary>
 /// Rotaciona um ponto 2D a partir de um ponto de origem
 /// </summary>
 /// <param name="origem">Ponto de origem do objeto</param>
 /// <param name="p">Ponto a ser rotacionado</param>
 /// <param name="graus">Diferença de ângulos no caso de rotação ou soma dos ângulo no caso de acoplamento de objetos.</param>
 /// <returns></returns>
 public static Eixos2 RotacionarPonto2D(Eixos2 origem, Eixos2 ponto, float graus)
 {
     return(RotacionarPonto2D(origem.X, origem.Y, ponto.X, ponto.Y, graus));
 }
Example #9
0
 public static bool IntersecaoRetaRetangulo(Eixos2 pontoA, Eixos2 pontoB, RectangleF rect)
 {
     return(IntersecaoRetaRetangulo(pontoA, pontoB, rect.X, rect.Y, rect.Right, rect.Bottom));
 }
Example #10
0
 public static float AnguloEntreDoisPontos(this Eixos2 pontoA, Eixos2 pontoB)
 {
     return(AnguloEntreDoisPontos(pontoA.X, pontoA.Y, pontoB.X, pontoB.Y));
 }
Example #11
0
 public static float DistanciaEntreDoisPontos(this Eixos2 pontoA, Eixos2 pontoB)
 {
     return(DistanciaEntreDoisPontos(pontoA.X, pontoA.Y, pontoB.X, pontoB.Y));
 }
Example #12
0
 public static Objeto2D ObterUnicoObjeto2DMouseXY(this EpicoGraphics engine, Camera2D camera, Eixos2 ponto)
 {
     return(ObterObjetos2DMouseXY(engine, camera, ponto).LastOrDefault());
 }
Example #13
0
 public static IEnumerable <Objeto2D> ObterObjetos2DMouseXY(
     this EpicoGraphics engine, Camera2D camera, Eixos2 ponto)
 {
     return(ObterObjetos2DMouseXY(engine, camera, new Vertice2(ponto.X, ponto.Y)));
 }
Example #14
0
 public Vetor3(Eixos2 eixos2) : base(eixos2)
 {
 }
Example #15
0
 public Eixos2(ObjetoEpico Obj, Eixos2 eixos)
 {
     base.Obj = Obj;
     this.X   = eixos.X;
     this.Y   = eixos.Y;
 }
Example #16
0
 public Vertice2(Eixos2 eixos2) : base(eixos2)
 {
 }